Operating Systems. Engr. Abdul-Rahman Mahmood MS, PMP, MCP, QMR(ISO9001:2000) alphapeeler.sf.net/pubkeys/pkey.htm

Transcription

1 Operating Systems Engr. Abdul-Rahman Mahmood MS, PMP, MCP, QMR(ISO9001:2000) alphapeeler.sf.net/pubkeys/pkey.htm pk.linkedin.com/in/armahmood abdulmahmood-sss alphasecure mahmood_cubix VC++, VB, ASP

2 The exec() System Call The exec functions of Unix-like operating systems are a collection of functions that causes the running process to be completely replaced by the program passed as argument to the function. As a new process is not created, the process ID (PID) does not change across an execute, but the data, heap and stack of the calling process are replaced by those of the new process. Example1: /* using execvp to execute the contents of argv */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> int main(int argc, char *argv[]) { execvp(argv[1], &argv[1]); perror("exec failure"); exit(1); } Compile using: $ gcc execvp.c -o execvp.o $./execvp.o ps PID TTY TIME CMD 1681 pts/0 00:00:00 bash 1708 pts/0 00:00:00 ps

3 The wait() System Call A parent process usually needs to synchronize its actions by waiting until the child process has either stopped or terminated its actions. The wait() system call allows the parent process to suspend its activities until one of these actions has occurred. The wait() system call accepts a single argument, which is a pointer to an integer and returns a value defined as type pid_t. If the calling process does not have any child associated with it, wait will return immediately with a value of -1. If any child processes are still active, the calling process will suspend its activity until a child process terminates.

4 An example of wait(): #include <sys/types.h> #include <sys/wait.h> Void main() { int status; pid_t pid; pid = fork(); if(pid == -1) printf( \nerror child not created ); else if (pid == 0) /* child process */ { printf("\n I'm the child!"); exit(0); } else /* parent process */ { wait(&status); printf("\n I'm the parent!") printf("\n Child returned: %d\n", status) } } wait(&status) causes the parent to sleep until the child process is finished execution. The exit status of the child is returned to the parent.

5 Scheduling Criteria CPU utilization keep the CPU as busy as possible Throughput # of processes that complete their execution per time unit Waiting time amount of time a process has been waiting in the ready queue For Non preemptive Algos = S.T A.T For Preemptive Algos = F.T A.T B.T Turnaround time amount of time to execute a particular process. Finish Time Arrival Time Response time amount of time it takes from when a request was submitted until the first response is produced, not output (for time-sharing environment)

6 Optimization Criteria Max CPU utilization Max throughput Min turnaround time Min waiting time Min response time

7 FCFS Scheduling Process Burst Time P 1 24 P 2 3 P 3 3 Suppose that the processes arrive in the order: P 1, P 2, P3, all at 0 ms. The Gantt Chart for the schedule is: P 1 P 2 P Waiting time for P 1 = 0; P 2 = 24; P 3 = 27 Average waiting time: ( )/3 = 17 ms Average turn around time (ATAT) = FT-AT = ( ) / 3 = 81/3 = 27 Average response time = First Response Arrival time = P1= 0-0, P2=24-0, P3=27-0, 27-0 => ART = ( ) / 3 = 51/3 = 17 ms

8 FCFS Scheduling (Cont.) Suppose that the processes arrive in the order P 2, P 3, P 1 The Gantt chart for the schedule is: P 2 P 3 P Waiting time for P 1 = 6; P 2 = 0 ; P 3 = 3 Average waiting time: ( )/3 = 3 Much better than previous case Convoy effect short process behind long process

9 SJF Scheduling Use these lengths to schedule the process with the shortest time Two schemes: nonpreemptive once CPU given to the process it cannot be preempted until completes its CPU burst preemptive (Shortest-Remaining -Time-First (SRTF)) if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. SJF is optimal gives minimum average waiting time for a given set of processes The difficult of SJF is knowing the length of the next CPU request.

10 Non-Preemptive SJF Process Arrival Time Burst Time P P P P SJF (non-preemptive) P 1 P 3 P 2 P Average waiting time = ST AT = ( )/4 = 16/4 = 4 ms Average Turn around time (ATAT) = FT AT = (7-0 )+(12-2 )+(8-4 )+(16-5) ATAT = = 32/4 = 8 ms

11 Example of Preemptive SJF Shortest Remaining Time First (SRTF) Process Arrival Time Burst Time P P P P SJF (preemptive) P 1 P 2 P 3 P 2 P 4 P AWT = ( )/4 = 3 ms Average Turn around time (ATAT) = FT AT = (16-0 )+(7-2 )+(5-4 )+(11-5) ATAT = ( ) /= 28 / 4 = 7 ms 16

12 Priority-based Scheduling Process Burst Time Priority P P P P P (Assume all processes arrives at same time i.e., 0 ms.) P 2 P P 3 5 P 1 P 3 P AWT = P1=6, P2=0, P3=16, P4=18, P5=1, AWT = ( )/5 = 41/5 = 8.2 ms ATAT = FT AT = = 60 /5 = 12ms GMU CS 571

13 Priority-Based Scheduling Problem: Indefinite Blocking (or Starvation) low priority processes may never execute. One solution: Aging as time progresses, increase the priority of the processes that wait in the system for a long time. Priority Assignment Internal factors: timing constraints, memory requirements, the ratio of average I/O burst to average CPU burst. External factors: Importance of the process, financial considerations, hierarchy among users GMU CS 571

14 Round Robin Scheduling Each process gets a small unit of CPU time (time quantum). After this time has elapsed, the process is preempted and added to the end of the ready queue. Newly-arriving processes (and processes that complete their I/O bursts) are added to the end of the ready queue If there are n processes in the ready queue and the time quantum is q, then no process waits more than (n-1)q time units. Performance q large FCFS q small Processor Sharing (The system appears to the users as though each of the n processes has its own processor running at the (1/n) th of the speed of the real processor) GMU CS 571

15 Example for Round-Robin Process Burst Time P 1 53 P 2 17 P 3 68 P 4 24 (Assume all processes arrives at same time i.e., 0 ms.) The Gantt chart: (Time Quantum = 20) P 1 P 2 P 3 P 4 P 1 P 3 P 4 P 1 P 3 P Average wait time = ( )/4 = 73 ms ATAT=FT AT=( )/4 = 454/4 = ms Typically, higher average turnaround time (amount of time to execute a particular process) than SJF, but better response time (amount of time it takes from when a request was submitted until the first response is produced).

16 Example for Round-Robin Process Burst Time P 1 53 P 2 17 P 3 68 P 4 24 (Assume all processes arrives at same time i.e., 0 ms.) The Gantt chart: (Time Quantum = 30) P 1 P 2 P 3 P 4 P 1 P 3 P Average wait time = ( )/4 = 68 When Time Quantum = 10 get average wait time = ( )/4 = 75.5