What is a Process?
A process is a program during execution. ¾ Program = static file (image) ¾ Process = executing program = program + execution state.
OS Structure, A process is the basic unit of execution in an operating system ¾ Each process has a number, its process identifier (pid). Processes & Process Management Different processes may run different instances of the same program ¾ E.g., my javac and your javac process both run the Java compiler
At a minimum, process execution requires following resources: ¾ Memory to contain the program code and data ¾ A set of CPU registers to support execution
1 2 Program to Process Process in Memory
What is in memory. Program to process. We write a program in e.g., Java. A compiler turns that program into an instruction list. main; a = 2 What you wrote Stack The CPU interpp(gprets the instruction list (which is more a graph of X; b = 2 basic blocks). void X (int b) { if(b == 1) { void X (int b) { Heap … if(b == 1) { void X (int b) { int main() { … if(b == 1) { int a = 2; int main() { … X(a); int a = 2; int main() { } X(a); int a = 2; } X(a); What must the OS track for a Code process? }
3 4 Processes and Process Management Keeping track of a process Details for running a program
A program consists of code and data On running a program, the loader: A process has code. ¾ reads and interprets the executable file ¾ OS must track program counter (code location). ¾ sets up the process ’ s memory to contain the code & data from executable A process has a stack. ¾ pushes “argc”, “argv” on the stack ¾ sets the CPU registers properly & calls “_start()” ¾ OS must track stack pointer. Program starts running at _start() OS stores state of processes’ computation in _start(args) { initialize_java(); a process control block (PCB). ret = main(args); ¾ E.ggp., each process has an identifier (process exit(re t) } identifier, or PID) we say “process” is now running, and no longer think of “program” Data (program instructions, stack & heap) When main() returns, OS calls “exit()” which destroys the resides in memory, metadata is in PCB (which process and returns all resources is a kernel data structure in memory)
5 6 Process Contexts Process Life Cycle Example: Multiprogramming
Processes are always either executing, waiting to I/O execute or blocked waiting for an event to occur Program 1OS Program 2 Device User Program n maa{in{ read{ k: read()
Start Done ... startIO() User Program 2 save state schedule() main{ User Program 1 } Ready Running “System Software ” endio{ interrupt Operating System schedule() Blocked k+1: save } restore state A preemptive scheduler will force a transition from Memory state running to ready. A non-preemptive scheduler waits. }
7 8 Scheduling Processes
When a process is waiting for I/O what is its scheduling state? OS has PCBs for active processes. OS pppppquts PCB on an appropriate queue. 1. Ready ¾ Ready to run queue. 2. Running ¾ Blocked for IO queue (Queue per device). 3. Blocked ¾ Zombie queue. 4. Zombie Stopping a process and starting another is 5. Exited called a context switch. ¾ 100-10,000 per second, so must be fast.
9 10 Why Use Processes? Why Use Processes?
Consider a Web server Consider a Web server get network message (URL) from client get network message (URL) from client create child process, send it URL fetch URL data from disk Child compose response fetch URL data from disk send response compose response send response How well does this web server perform? If server has configgpguration file open for writing With many i ncomi ng request s? ¾ Prevent child from overwriting configuration That access data all over the disk? How does server know child serviced request? ¾ Need return code from child process
11 12 The Genius of Separating Fork/Exec The Genius of Separating Fork/Exec
Decoupling fork and exec lets you do anything to the Life with CreateProcess(filename); child’s process environment without adding it to the ¾ But I want to close a file in the child. CreateProcess API. CreateProcess(filename, list of files); int ppid = getpid(); // Remember parent’s pid ¾ And I want to change the child’s environment. fork(); // create a child CreateProcess(filename, CLOSE_FD, new_envp); if(getpid() != ppid) { // child continues here ¾ Etc. (and a very ugly etc.) // Do anything (unmap memory, close net connections…) = split this process into 2 (new PID) fork() exec(“program”, argc, argv0, argv1, …); ¾ Returns 0 in child fork()} creates a child process that inherits: ¾ Returns pid of child in parent ¾ identica l copy of all par ent’ s v ari abl es & m em or y exec() = overlay this process with new program ¾ identical copy of all parent’s CPU registers (except one) Parent and child execute at the same point after fork() returns: (PID does not change) ¾ by convention, for the child, fork() returns 0 ¾ by convention, for the parent, fork() returns the process identifier of the child ¾ fork() return code a convenience, could always use getpid()
13 14 Program Loading: exec()
The exec() call allows a process to “load” a different What creates a process? program and start execution at main (actually _start). 1. Fork It allows a process to specify the number of 2. Exec arguments (argc) and the string argument array (argv). 3. Both
If the call is successful ¾ it is the same process … ¾ btitbut it runs a diff eren t program !!
Code, stack & heap is overwritten ¾ Sometimes memory mapped files are preserved.
15 16 General Purpose Process Creation A shell forks and then execs a calculator
int pid = fork(); int pidcalc_main(){ = fork(); In the parent process: if(pid == 0) { if(pidint q== = 0)7; { main() close(“.history”); close(“.history”);do_init(); … exec(“/bin/calc”); exec(“/bin/calc”);ln = get_input(); int ppid = getpid(); // Remember parent’s pid } else { } elseexec_in(ln); { fork(); // create a child wait(pid); wait(pid); if(getpid() != ppid) { // child continues here exec_status = exec(“calc”, argc, argv0, argv1, …); USER printf(“Why would I execute?”); OS } pid = 128127 else { // parent continues here open files = “.history” Process Control printf(“Who’s your daddy?”); last_cpu = 0 Blocks (PCBs) … child_status = wait(pid); pid = 128 } open files = last_cpu = 0 17 18 A shell forks and then execs a calculator At what cost, fork()?
main; a = 2 Stack Stack Simple implementation of fork(): ¾ allocate memory for the child process 0xFC0933CA Heap 0x43178050 Heap ¾ copy parent’ s memory and CPU registers to child ’ s ¾ Expensive !! int shell_main() { int calc_main() { In 99% of the time, we call exec() after calling fork() int a = 2; int q = 7; ¾ the memory copying during fork() operation is useless … Code … Code ¾ the child process will likely close the open files & connections USER ¾ overhead is therefore high OS vfork() pid = 127128 ¾ a system call that creates a process “without” creating an identical open files = “.history” Process Control memory image last_cpu = 0 Blocks (PCBs) ¾ child process should call exec() almost immediately ¾ Unfortunate example of implementation influence on interface pid = 128 Current Linux & BSD 4.4 have it for backwards compatibility open files = ¾ Copy-on-write to implement fork avoids need for vfork last_cpu = 0 19 20 Orderly Termination: exit() The wait() System Call
After the program finishes execution, it calls exit() A child program returns a value to the parent, so the parent This system call: must arrange to receive that value ¾ takes the “result” of the program as an argument ¾ closes all open files, connections, etc. The wait() system call serves this purpose ¾ deallocates memory ¾ it puts the parent to sleep waiting for a child’s result ¾ deallocates most of the OS structures supporting the process ¾ when a child calls exit(), the OS unblocks the parent and returns ¾ checks if parent is alive: the value passed by exit() as a result of the wait call (along with the pid of the child) If so, it holds the result value until parent requests it; in this case, process does not really die, but it enters the zombie/defunct state ¾ if there are no children alive, wait() returns immediately If not, it deallocates all data structures, the process is dead ¾ also, if there are zombies waiting for their parents, wait() returns ¾ cleans up all waiting zombies one of the values immediately (and deallocates the zombie) Process termination is the ultimate garbage collection (resource reclamation).
21 22 Process Control Tying it All Together: The Unix Shell
while(! EOF) { OS must include calls to enable special control of a process: read input handle regular expressions Priorityyp manipulation: int pp()id = fork(); // create a child ¾ nice(), which specifies base process priority (initial priority) if(pid == 0) { // child continues here ¾ In UNIX, process priority decays as the process consumes CPU exec(“program”, argc, argv0, argv1, …); } Debugging support: else { // parent continues here ¾ ptrace(), allows a process to be put under control of another … process ¾ The other process can set breakpoints, examine registers, etc. } Alarms and time: ¾ Sleep puts a process on a timer queue waiting for some number of seconds, supporting an alarm functionality Translates
23 24 A Dose of Reality: Scheduling in Solaris Anatomy of a Process
mapped segments Header DLL’s
Code Process’s Stack address space Initialized data
Process Control Block Heap PC Stack Pointer Initialized data Registers PID Executable File UID Code Scheduling Priority Close to our scheduling diagram, but more complicated List of open files …
25 26 Unix fork() example
The execution context for the child process is a copy of the parent’s context at the time of the call ¾ fork() returns child PID in parent, and 0 in child main { int childPID; fork() S1;
childPID = fork();
if(childPID == 0) childPID Code Code else { = 0 Data Data wait(); childPID } Stack Stack = xxx
S2; } Parent Child
27