Presentation is loading. Please wait.

Presentation is loading. Please wait.

CMPT 300: Operating Systems I Ch 3: Processes Dr. Mohamed Hefeeda

Similar presentations

Presentation on theme: "CMPT 300: Operating Systems I Ch 3: Processes Dr. Mohamed Hefeeda"— Presentation transcript:

1 CMPT 300: Operating Systems I Ch 3: Processes Dr. Mohamed Hefeeda
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 Note:
process execution must progress in sequential fashion Note: The terms job and process are interchangeable A process includes: program counter stack data section

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

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 pure overhead; 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 Scheduling: The Big Picture (cont’d)
Disk Jobs Job sched. CPU sched. Midterm sched. 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, Execution
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 Process scheduling
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

Download ppt "CMPT 300: Operating Systems I Ch 3: Processes Dr. Mohamed Hefeeda"

Similar presentations

Ads by Google