Introduction to Systems Programming Lecture 2

1. Introduction to Systems Programming Lecture 2 Processes & Scheduling

2. Categories of System Calls System calls provide API: language spoken by the virtual machines (processes) applications run on. • Process management: creation, destruction, contents • I/O devices management: • File system: file creation/deletion, reading/writing, access rights • Network devices: opening/closing, reading/writing, standing by • Virtual memory management • Inter-process communication

3. Why Multiple Processes? • Tool for parallelism: e.g., read input while producing output • Better utilization of resources • Concurrent independent programs • Modularity • Many users can share the system

4. 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 • Windows 98: • Alt+Ctrl+Del • Start  Programs  Accessories  System Tools  System Monitor

5. How is a process realized? Process Control Block (PCB): a data structure in OS. • CPU state: registers • Memory maps • Static info: PID, owner, file… • Resources in use (devices, files) • Accounting (CPU usage, memory usage...)

6. pid resourcestruct OS process Why so? • Allow preemption and resumption • Enforce security policy • Resources are used only via handles • check once, save credentials for later • handles can’t be used by another process process table

7. 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

8. Unix Processes • Parent process creates children processes (recursively: get a tree of processes) • Resource sharing • Parent and children usually share some resources • Execution • Parent and children execute concurrently. • Parent waits until children terminate.

9. 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. • Near one-to-one relationship between system call and C library function that issues the system call.

10. 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 • execv(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) • Block until child exits • Return exit code of dead process.

11. Simple Example int pid, ret_val; char* args[10]; // ... if ((pid = fork()) == 0) { // child processargs[0] = “17”; args[1] = “Moshe”; args[2] = (char*) 0; // end of args execv(“a.out”, args);}// only parent reaches hereif (waitpid(-1, &ret_val, 0) == pid) //...

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

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

14. Win32 API Process Management • In Windows there is a huge library of “system” functions called the Win32 API. • Not all functions result in system calls. • CreateProcess()– Create a new process (fork+execve) • ExitProcess() – Terminate Execution • WaitForSingleObject()– Wait for termination • Can wait for many other events • There is no separation into fork and execv in Win32 • No Parent-Child relationship.

15. 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 from another process

16. Process Scheduling Basics OS maintains lists of processes. • 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 • OS places current process in appropriate list • Dispatcher/scheduler (a part of the OS): • chooses new “current process” from the ready list • loads registers from PCB  activates the process context switch

17. Schematic Scheduling

18. CPU scheduling by OS • CPU scheduling decisions when a process: 1. Switches from running to waiting state. (syscall) 2. Switches from running to ready state. (interrupt) 3. Switches from waiting to ready. (interrupt) • Terminates. (syscall) • Dispatcher: Module in OS to execute scheduling decisions. This is done by: • switching context • switching to user mode • jumping to the proper location in the user program to restart that program

19. 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.

20. Typical CPU burst distribution

21. 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

22. P1 P2 P3 0 24 27 30 Example: FCFS Scheduling • 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

23. P2 P3 P1 0 3 6 30 FCFS: continued What if arrival 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

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

25. 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. • If there are n processes in the ready queue and the time quantum is q, then 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 • q “too” large  FCFS • But q must be large with respect to context switch, otherwise overhead is too high.

26. P1 P2 P3 P4 P1 P3 P4 P1 P3 P3 0 20 37 57 77 97 117 121 134 154 162 Round Robin: Example 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.

27. SJF in CPU scheduling • Associate with each process the length of its next CPU burst. Use these lengths to schedule the process with the shortest time. • Two alternatives: • Non-preemptive – once CPU given to the process it cannot be preempted until completes its CPU burst. • Preemptive – if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. Aka Shortest-Remaining-Time-First (SRTF). • But: OS does not know length of next CPU burst!

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

29. 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.

30. Exponential Averaging: Example =0.5

31. 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

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

33. Dynamic Priorities Example: multilevel feedback

34. Dynamic Priorities: Unix • Initially: base priority (kernel/user) • While waiting: fixed • Count running time (clock interrupts, PCB) • Priority of a process is lowered if its CPU usage is high • CPU counter is reduced by ½ every second • User can lower priority by calling “nice”