Introduction to Systems Programming Lecture 2

1. Introduction to Systems Programming Lecture 2 Processes & Scheduling

2. Multi-Programming • A computer can do “several things at once” • Browse the net • Write an email • Listen to net radio • Print a document • … but CPU only does one thing at a time • CPU switches between running programs

3. What is a process? A process is an executing program • When we double click on icon linked to “iexplore.exe”, the OS creates a new process: • Allocates some memory for the program • loads instructions from the disk into RAM • Does some book-keeping • Gives control to the new process

4. What does a process have? • Resources • Address space: the RAM allocated to the program • Program image: machine instructions • file handles, child processes, accounting info… • Thread of execution • Instruction address (program counter) • Registers and CPU state • Stack of called procedures

5. Baker Recipe instructions Ingredients (flour, sugar,…) Cake Program != Process CPU Program Input Output Analogy: Baking a Cake

6. Child is injured Baker marks place in recipe Switches to “medical help” Return to recipe in same place Interrupt Save process state higher priority process Resume process Analogy cont.

7. Which processes are running? • Unix: the ps command shows the active processes. To see all processes type “ps –aux” (linux) or “ps –ef” (Sun) • Lots of output so use “ps –aux | more” • Alternative: the “top” command • Windows 2000 / XP: • Alt+Ctrl+Del Task Manager

8. What the OS knows about a process Process Control Block (PCB): a data structure in OS. • Static info: PID, owner, file… • Resources in use (devices, files) • Memory maps • CPU state: (place for content of) registers • Accounting (CPU usage, memory usage...)

9. How are processes created? • An existing process issues a system call to create a new process. • The creating process can be: • An OS process (Windows Explorer, Desktop process that handles “double click”, the “cmd” shell,….) • A regular user process

10. Process Management System Calls • Create a process • allocate initial memory • allocate process ID • loads initial binary image • optionally: send arguments to process • Destroy a process • terminate the process • free resources associated with it • optionally: return value • Wait for a process: block until specified process terminates, optionally obtain returned value

11. Process management in Unix and Windows

12. Unix Processes • Parent process creates children processes (recursively: get a tree of processes) • OS maintains information about which process is the parent of each process • Execution • Parent and children execute concurrently. • Parent waits until children terminate (sort of).

13. Unix Process Creation • Address space • Child duplicate of parent. • Child has a program loaded into it. • Two system calls needed • fork system call creates new process • exec system calls replaces process’ memory space with a new program.

14. Unix Process Management • fork: (return TWICE if successful) • Create a copy of the current process • Return 0 to the “child” process • Return child’s pid to the “parent” process • exec(file,argv): (NEVER return if successful) • Make current process run file with given arguments argv • exit(code): (NEVER return if successful) • Terminate current process with given return code (0 means OK) • waitpid(pid, &code, options): (return only when appropriate) • wait until child exits

15. Simple Example int pid, ret_val; // pid == process ID ... if ((pid = fork()) == 0) { // pid is 0  only child process exec(command, parameters, …);}else{ // pid is not 0  only parent reaches here waitpid(-1, &ret_val, 0);} Wait for any child to exit Child’s return value

16. Fork Example: Chain #include <stdio.h> void main(void) { int i; for (i = 0; i < 6; i++) { if (0 != fork()) break; // parent exits the loop } fprintf(stderr, “Process: %ld Parent: %ld\n", (long)getpid(), (long)getppid()); sleep(1); }

17. Fork Example: Fan #include <stdio.h> void main(void) { int i; for (i = 0; i < 6; i++) { if (0 == fork()) break; // child exits the loop } fprintf(stderr, “Process: %ld Parent: %ld\n", (long)getpid(), (long)getppid()); sleep(1); }

18. Win32 processes • In Windows there is a huge library of “system” functions called the Win32 API. • Not all functions result in system calls (many are not executed in kernel mode) • No Parent-Child relationship between processes.

19. Win32 Process Management API • CreateProcess()– Create a new process (fork+exec) • ExitProcess() – Terminate Execution • WaitForSingleObject()– Wait for termination • Can wait for many other events • There is no separation into fork and exec in Win32

20. Process scheduling

21. Process Scheduling Basics - 1 • current process runs, until either • an interrupt occurs, or • it makes a system call, or • it runs for too long (interrupt: timer expired) • OS gets control, handles the interrupt/syscall …  … But OS does NOT immediately “return” to the process that was running before !

22. Process Scheduling Basics - 2 • OS maintains several lists of processes. • OS saves current process’ registers in PCB • Place (PCB of) current process in appropriate list • Dispatcher/scheduler (a part of the OS): • chooses new “current process” from the Ready list • loads its registers from PCB • activates the process context switch

23. Schematic Scheduling

24. Process Life Cycle new terminated scheduled admitted exit, kill ready running interrupt/yield event occurrence wait for event waiting event: an interrupt, or a signal (system call) from another process

25. When does CPU scheduling occur? • The OS makes a CPU scheduling decision when: • A process switches from running to ready state. (interrupt) • A process switches from running to waiting state. (syscall) • A process switches from waiting to ready. (interrupt) • A process terminates. (syscall)

26. The Dispatcher • A module in OS to execute scheduling decisions. • This is done by: • switching context • (loading stored register values from PCB) • switching to user mode • jumping to the proper location in the user program to restart that program • Small, tricky to write, assembly function

27. Scheduling Policies Who’s turn is it now?

28. To Preempt or not to Preempt? • Preemptive: A Process can be suspended and resumed • Non-preemptive: A process runs until it voluntarily gives up the CPU (wait for event or terminate). • Most modern OSs use preemptive CPU scheduling, implemented via timer interrupt. • Non-preemptive is used when suspending a process is impossible or very expensive: e.g., can’t “replace” a flight crew in middle of flight.

29. Typical CPU burst distribution

30. Scheduling Criteria • Abstract scheduling terminology • CPU == Server • CPU burst == job • System view: • Utilization: percentage of the time server is busy • Throughput: number of jobs done per time unit • Individual job view: • Turnaround time: how long does it take for a job to finish • Waiting time: turnaround time minus “solo” execution time

31. Example: FCFS Scheduling P1 P2 P3 0 24 27 30 • First Come, First Served. Natural, fair, simple to implement • Assume non-preemptive version • Example: Jobs are P1(duration: 24 units); P2(3); and P3 (3), arriving in this order at time 0 • Gantt Chart for FCFS schedule: • Average waiting time: (0 + 24 + 27)/3 = 17

32. FCFS: continued P2 P3 P1 0 3 6 30 What if execution order is P2 , P3 , P1 ? • Gantt chart: • Average waiting time: (6 + 0 + 3)/3 = 3 • Much better! • Convoy effect: many short jobs stuck behind one long job

33. Scheduling policy: SJF • “Shortest Job First”: • Assume each job has a known execution time • Schedule the shortest job first • Can prove: SJF ensures minimal average waiting time! • In pure form, mostly theoretical: OS does not know in advance how long the next CPU burst will last

34. Preemptive Scheduling: Round Robin • Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. • After this time has elapsed, the process is preempted and added to the end of the ready queue. • Then the process at head of queue is scheduled.

35. Performance of Round Robin • n processes in the ready queue • time quantum is q, • each process gets 1/n of the CPU time in chunks of at most q time units at once. • No process waits more than (n-1)q time units. • Performance • If q too large  FCFS • But q must be large with respect to context switch, otherwise overhead is too high.

36. Round Robin: Example P1 P2 P3 P4 P1 P3 P4 P1 P3 P3 0 20 37 57 77 97 117 121 134 154 162 ProcessBurst Time P1 53 P2 17 P3 68 P4 24 • Gantt chart for time quantum 20: • Typically, higher average turnaround than SJF, but better response.

37. SJF for CPU Scheduling • Associate with each process the (estimated) length of its next CPU burst. Use these lengths to schedule the process with the shortest time. • if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. A.k.a. Shortest-Remaining-Time-First (SRTF).

38. Estimating length of CPU burst • Idea: use length of previous CPU bursts • Heuristic: use exponential averaging (aging).

39. Exponential Averaging Expanding the formula, we get: n+1 =  tn+(1 - )  tn-1+ … +(1 -  )j  tn-j+ … +(1 -  )n 0 • Since both  and (1 - ) are less than or equal to 1, each successive term has less weight than its predecessor. •  =0 • n+1 = n = … = 0 • Recent history does not count. •  =1 • n+1 = tn • Only the actual last CPU burst counts.

40. Exponential Averaging: Example =0.5

41. Priority Scheduling Idea: Jobs are assigned priorities.Always, the job with the highest priority runs. Note: All scheduling policies are priority scheduling! Question: How to assign priorities? priority 1 priority 2 priority M

42. Example for Priorities Static priorities can lead to starvation!

43. Dynamic Priorities Example: multilevel feedback

44. Process Process Control Block (PCB) Unix process creation: fork / exec Context switch Dispatcher Preemption CPU Burst FCFS SJF Round-Robin Exponential aging Starvation Concepts for review