1. CS 153 Design of Operating Systems Spring 2015 Lecture 5: Processes and Threads

2. 2 Announcements l Homework 1 out (to be posted on ilearn) l Project 1 u Make sure to go over it so that you can ask the TAs in lab if anything is unclear u Both design document and code due before class on Feb. 3 rd l Read scheduling and synchronization in textbook u Don’t wait for these topics to be covered in class u You especially need to understand priority donation in project l Piazza enrollment u Some of you haven’t enrolled u You will miss announcements – especially about projects l All set with project groups? u Email your TA today if you have not notified group or if you are looking for a partner

3. 3 Process Creation: Unix l In Unix, processes are created using fork() int fork() Usually combined with exec() fork() + exec() ~= CreateProcess() l fork() u Creates and initializes a new PCB u Creates a new address space u Initializes the address space with a copy of the entire contents of the address space of the parent u Initializes the kernel resources to point to the resources used by parent (e.g., open files) u Places the PCB on the ready queue l Fork returns twice u Returns the child’s PID to the parent, “0” to the child

4. 4 fork() int main(int argc, char *argv[]) { char *name = argv[0]; int child_pid = fork(); if (child_pid == 0) { printf(“Child of %s is %d\n”, name, getpid()); return 0; } else { printf(“My child is %d\n”, child_pid); return 0; } What does this program print?

5. 5 Example Output [well ~]$ gcc t.c [well ~]$./a.out My child is 486 Child of a.out is 486

6. 6 Duplicating Address Spaces child_pid = fork(); if (child_pid == 0) { printf(“child”); } else { printf(“parent”); } ParentChild child_pid = fork(); if (child_pid == 0) { printf(“child”); } else { printf(“parent”); } PC child_pid = 486child_pid = 0 PC

7. 7 Divergence child_pid = fork(); if (child_pid == 0) { printf(“child”); } else { printf(“parent”); } ParentChild child_pid = fork(); if (child_pid == 0) { printf(“child”); } else { printf(“parent”); } PC child_pid = 486child_pid = 0

8. 8 Example Continued [well ~]$ gcc t.c [well ~]$./a.out My child is 486 Child of a.out is 486 [well ~]$./a.out Child of a.out is 498 My child is 498 Why is the output in a different order?

9. 9 Why fork()? l Very useful when the child… u Is cooperating with the parent u Relies upon the parent’s data to accomplish its task l Example: Web server while (1) { int sock = accept(); if ((child_pid = fork()) == 0) { Handle client request } else { Close socket }

10. 10 Process Creation: Unix (2) l Wait a second. How do we actually start a new program? int exec(char *prog, char *argv[]) l exec() u Stops the current process u Loads the program “prog” into the process’ address space u Initializes hardware context and args for the new program u Places the PCB onto the ready queue u Note: It does not create a new process l What does it mean for exec to return? l What does it mean for exec to return with an error?

11. 11 Process Creation: Unix (3) l fork() is used to create a new process, exec is used to load a program into the address space l What happens if you run “exec csh” in your shell? l What happens if you run “exec ls” in your shell? Try it. l fork() can return an error. Why might this happen?

12. 12 Process Termination l All good processes must come to an end. But how? u Unix: exit(int status), NT: ExitProcess(int status) l Essentially, free resources and terminate u Terminate all threads (coming up) u Close open files, network connections u Allocated memory (and VM pages out on disk) u Remove PCB from kernel data structures, delete l Note that a process does not need to clean up itself u OS will handle this on its behalf

13. 13 wait() a second… l Often it is convenient to pause until a child process has finished u Think of executing commands in a shell l Use wait() (WaitForSingleObject) u Suspends the current process until a child process ends u waitpid() suspends until the specified child process ends l Wait has a return value…what is it? l Unix: Every process must be reaped by a parent u What happens if a parent process exits before a child? u What do you think is a “zombie” process?

14. 14 Unix Shells while (1) { char *cmd = read_command(); int child_pid = fork(); if (child_pid == 0) { Manipulate STDIN/OUT/ERR file descriptors for pipes, redirection, etc. exec(cmd); panic(“exec failed”); } else { if (!(run_in_background)) waitpid(child_pid); }

15. 15 Processes l Recall that … u A process includes many things: »An address space (all code and data pages) »OS resources (e.g., open files) and accounting info »Execution state (PC, SP, regs, etc.) u Processes are completely isolated from each other l Creating a new process is costly because of all of the data structures that must be allocated and initialized u Recall struct proc in Solaris u Expensive even with OS tricks l Communicating between processes is costly because most communication goes through the OS u Overhead of system calls and copying data P1 P2 OS

16. 16 Parallel Programs l Also recall our Web server example that forks off copies of itself to handle multiple simultaneous requests u Or any parallel program that executes on a multiprocessor l To execute these programs we need to u Create several processes that execute in parallel u Cause each to map to the same address space to share data »They are all part of the same computation u Have the OS schedule these processes in parallel l This situation is very inefficient u Space: PCB, page tables, etc. u Time: create data structures, fork and copy addr space, etc.

17. 17 Rethinking Processes l What is similar in these cooperating processes? u They all share the same code and data (address space) u They all share the same privileges u They all share the same resources (files, sockets, etc.) l What don’t they share? u Each has its own execution state: PC, SP, and registers l Key idea: Separate resources from execution state l Exec state also called thread of control, or thread

18. 18 Recap: Process Components l A process is named using its process ID (PID) l A process contains all of the state for a program in execution u An address space u The code for the executing program u The data for the executing program u A set of operating system resources »Open files, network connections, etc. u An execution stack encapsulating the state of procedure calls u The program counter (PC) indicating the next instruction u A set of general-purpose registers with current values u Current execution state (Ready/Running/Waiting) Per- Process State Per- Thread State

19. 19 Threads l Modern OSes (Mac OS, Windows, Linux) separate the concepts of processes and threads u The thread defines a sequential execution stream within a process (PC, SP, registers) u The process defines the address space and general process attributes (everything but threads of execution) l A thread is bound to a single process u Processes, however, can have multiple threads l Threads become the unit of scheduling u Processes are now the containers in which threads execute u Processes become static, threads are the dynamic entities

20. 20 Recap: Process Address Space Stack 0x00000000 0xFFFFFFFF Code (Text Segment) Static Data (Data Segment) Heap (Dynamic Memory Alloc) Address Space SP PC

21. 21 Threads in a Process Stack (T1) Code Static Data Heap Stack (T2)Stack (T3) Thread 1 Thread 3 Thread 2 PC (T1) PC (T3) PC (T2)

22. 22 Thread Design Space One Thread/Process Many Address Spaces (Early Unix) One Thread/Process One Address Space (MSDOS) Many Threads/Process Many Address Spaces (Mac OS, Unix, Windows) Many Threads/Process One Address Space (Pilot, Java) Address Space Thread

23. 23