Transcript CMPT 880: Internet Architectures and Protocols

School of Computing Science
Simon Fraser University
CMPT 300: Operating Systems I
Ch 3: Processes
Dr. Mohamed Hefeeda
1
Objectives
 Understand
 Process concept
 Process scheduling
 Creating and terminating processes
 Interprocess communication
2
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
3
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;
Local variables
Return address
Dynamically
allocated
Global variables
Program code
}
4
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
5
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
6
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
7
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
8
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
9
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)
10
Scheduling: The Big Picture (cont’d)
Midterm sched.
Jobs
Disk
Job sched.
CPU sched.
In most small and interactive systems (UNIX, WinXP, …),
only the CPU scheduler exists
11
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/Obound jobs in the system
12
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)
13
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
14
Process Lifetime
15
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
16
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
17
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 %d Completed“, pid);
exit(0);
Note: fork returns 0 to child and the pid of the new
}
}
process to parent.
18
A tree of processes on a typical Solaris
19
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)
20
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
21
Interprocess Communication Models
Message Passing
Shared Memory
22
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)
23
IPC: Message Passing
 If processes P and Q wish to communicate, they
need to:
 establish a communication
 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)
24
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
25
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
26
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
27