Process Concepts and Scheduling in Operating Systems

1. School of Computing Science Simon Fraser University CMPT 300: Operating Systems I Ch 3: Processes Dr. Mohamed Hefeeda

2. Objectives • Understand • Process concept • Process scheduling • Creating and terminating processes • Interprocess communication

3. Process Concept • Process is a program in execution • process execution must progress in sequential fashion • Note: • The terms job and process are interchangeable • A process includes: • program counter • stack • data section

4. Local variables Return address Dynamically allocated Global variables Program code Process in Memory • int global = 0; • int main (int arg) • { • float local; • char *ptr; • ptr = malloc(100); • local = 0; • local += 10*5; • ….. • …. • foo(); • …. /* return addr */ • …. • return 0; • }

5. Process State • As process executes, it changes state • new: just created • running: instructions are being executed • waiting: process is waiting for some event to occur • ready: process is waiting for CPU • terminated: process has finished execution

6. Process Control Block (PCB) • OS maintains info about process in PCB • Process state • Program counter • CPU registers • CPU scheduling info • Memory-management info • Accounting info • I/O status info • PCB used to manage processes • E.g., to switch CPU from one process to another • Typically, a large C structure in kernel • Linux: struct task_struct

7. CPU Switch From Process to Process(Context Switch) • When switching occurs, kernel • Saves state of P0 in PCB0 (in memory) • Loads state of P1 from PCB1 into registers • State = values of the CPU registers, including the program counter, stack pointer

8. Context Switch • Context-switch time is pureoverhead; no useful work is done • Switching time depends on hardware support • Some systems (Sun UltraSPARC) provide multiple register sets  very fast switching (just change a pointer) • Typical systems, few milliseconds for switching

9. Job Types • Jobs (Processes) can be described as either: • I/O-bound process – spends more time doing I/O than computations, many short CPU bursts • CPU-bound process – spends more time doing computations; few very long CPU bursts

10. Scheduling: The Big Picture • Consider a large computer system to which many jobs are submitted • Initially, jobs go to the secondary storage (disk) • Then, job scheduler chooses some of them to go to memory (ready queue) • Then, CPU scheduler chooses from ready queue a job to run on CPU • Medium-term scheduler may move (swap) some partially-executed jobs from memory to disk(to enhance performance)

11. Jobs Midterm sched. Disk Job sched. CPU sched. Scheduling: The Big Picture (cont’d) In most small and interactive systems (UNIX, WinXP, …), only the CPU scheduler exists

12. Schedulers • Long-term scheduler (or job scheduler) • Selects which processes should be brought into ready queue • Controls the degree of multiprogramming • Invoked infrequently (seconds, minutes) •  can be slow • Should maintain a ‘good mix’ of CPU-bound and I/O-bound jobs in the system

13. Schedulers (cont’d) • Short-term scheduler (or CPU scheduler) • selects which process should be executed next and allocates CPU to it • Short-term scheduler is invoked very frequently (milliseconds) •  must be fast • Medium-term scheduler • Swaps processes in and out of ready queue to enhance performance (i.e., maintain the good mix of jobs)

14. Scheduling Queues • Processes migrate among various queues • Job queue – set of all processes in the system • Ready queue – set of all processes residing in main memory, ready and waiting to execute • Device queues – set of processes waiting for an I/O device

15. Process Lifetime

16. Process Creation • Parent process creates children processes, • which, in turn may create other processes, • forming a tree of processes • Execution • Parent and children execute concurrently • Parent waits until children terminate • Resource sharing can take the form: • Parent and children share all resources • Children share subset of parent’s resources • Parent and children share no resources

17. Process Creation: Unix Example • Process creates another process (child) by using fork system call • Child is a copy of the parent • Typically, child loads another program into its address space using exec system call • Parent waits for its children to terminate

18. C Program Forking Separate Process int main() { pid_t pid; pid = fork(); /* fork another process */ if (pid < 0) { /* error occurred */ fprintf (stderr, “fork Failed"); exit(-1); } else if (pid == 0) { /* child process */ execlp ("/bin/ls", "ls", NULL); } else { /* parent process */ /* parent will wait for child to complete */ wait (NULL); printf ("Child Complete"); exit(0); } } Note: fork returns 0 to child and the pid of the new process to parent.

19. A tree of processes on a typical Solaris

20. Process Termination • Process executes last statement and asks OS to delete it (exit) • Process’ resources are de-allocated by OS • Output data from child to parent (via wait) • Parent may terminate execution of children processes (abort) • Child has exceeded allocated resources • Task assigned to child is no longer required • If parent is exiting • Some OSes do not allow child to continue if its parent terminates • All children of the children are terminated (cascad termination)

21. Cooperating Processes • Cooperating process can affect or be affected by the execution of another process • Why processes cooperate? • Information sharing • Computation speed-up • Modularity, Convenience • Interprocess Communication (IPC) methods • Shared memory • Message passing

22. Interprocess Communication Models Message Passing Shared Memory

23. IPC: Shared Memory • Processes communicate by creating a shared place in memory • One process creates a shared memory—shmget() • Other processes attach shared memory to their own address space—shmat() • Then, shared memory is treated as regular memory • Synchronization is needed to prevent concurrent access to shared memory (conflicts) • Pros • Fast (memory speed) • Convenient to programmers (just regular memory) • Cons • Need to manage conflicts (tricky for distributed systems)

24. IPC: Message Passing • If processes P and Q wish to communicate, they need to: • establish a communication channel between them • exchange messages via: • send (message) – message size fixed or variable • receive (message) • Pros • No conflict  easy to exchange messages especially in distributed systems • Cons • Overhead (message headers) • Slow • prepare messages • Kernel involvement: sender  kernel  receiver (several system calls)

25. IPC: Message Passing (cont’d) • Communication channel can be • Direct: Processes must name each other explicitly: • send (P, message) – send a message to process P • receive (Q, message) – receive a message from process Q • Indirect: Processes communicate via mailboxes (or ports) • Messages are sent to and received from mailboxes • Each mailbox has a unique id • Send (A, message) – send a message to mailbox A • Receive (A, message) – receive a message from mailbox A

26. IPC: Message Passing (cont’d) • Synchronization: message passing is either • Blocking (or synchronous) • send () has sender block until message is received • receive () has receiver block until message is available • Non-blocking (or asynchronous) • send () has sender send message and continue • receive () has receiver receive a valid message or null • Buffering: Queue of messages attached to communication channel • Zero capacity – Sender must wait for receiver (rendezvous) • Bounded capacity – Sender must wait if link full • Unbounded capacity – Sender never waits

27. Summary • Process is a program in execution • OS maintains process info in PCB • Process State diagram • Creating and terminating processes (fork) • Process scheduling • Long-, short-, and medium-term schedulers • Scheduling queues • Interprocess communication • Shared memory • Message passing