Lecture 3: Processes

Operating System

1
Major Requirements of an
Operating System
 Interleave the execution of several processes
to maximize processor utilization while
providing reasonable response time
 Allocate resources to processes in
conformance with a specific policy while at
the same time avoiding deadlock
 Support interprocess communication and user
creation of processes, both of which may aid
in the structuring of applications
2
Contents
 Process Definition
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

3
Contents
 Process Definition
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

4
Processes - Definition
 Also called a job
 Execution of an individual program
 Process components:
 An executable program – text section
 The associated data needed by the program
 Stack – temporary data (e.g. function parameters, return
addresses, and local variables)
 Data section – global variables
 Heap – memory which is dynamically allocated during process
run time
 The execution context of the program
 All information the operating system needs to manage the
process
 Including the value of program counter and the contents of the
processor’s registers
5
Process in memory

6
Process Trace
 Processes can be traced
 For a program to be executed, a process is
created for that program.
 We can characterize the behavior of an individual
process by listing the sequence of instructions that
execute for that process.
 Such a listing is called a trace of the process.
 We can characterizing behavior of the processor
by showing how the traces of the various
processes are interleaved.

7
Example for processes tracing

8
Process A OS Process B OS Process C OS Process A OS Process C
9
time
Example for processes tracing
(cont.)

10
Contents
 Process Definition
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

11
Process State
- Two-State Process Model
 Process may be in one of two states
 Running
 Not-running

12
Not-Running Process in a
Queue

13
Process State
 Not-running
 ready to execute
 Waiting (also called blocked)
 waiting for I/O
 Dispatcher cannot just select the
process that has been the longest in the
queue because it may be blocked

14
Process State
- A Five-State Model
 New: The process is being created
 Running: Instructions are being executed
 Waiting (blocked): The process is waiting
for some event to occur
 Ready: The process is waiting to be
assigned to a processor
 Terminated: The process has finished
execution

15
Process State
- A Five-State Model

16
Queueing-Diagram Representation
of Five-State Model

17
Queueing-Diagram Representation
of Five-State Model

18
Suspended Process – The
Need for Swapping
 The three principal states just described
(Ready, Running, Waiting/Blocked)
provide a systematic way of modeling
the behavior of processes and guide the
implementation of the OS.
 However, there is good justification for
adding other states to the model – the
need for swapping
19
Suspended Process – The
Need for Swapping
 Processor is faster than I/O so all processes
could be waiting for I/O
 Swap these processes to disk to free up more
memory
 Waiting(Blocked) state becomes suspend
state when swapped to disk
 Two new states
 Waiting(Blocked), suspend
 Ready, suspend

20
One Suspend State

21
Two Suspend States

22
Reasons for Process Suspension

23
Contents
 Process Definition
 Process Trace
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

24
Process Scheduling 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
 Processes migrate among the various queues

25
Representation of Process Scheduling
(Five-State Model)

26
Schedulers
 Long-term scheduler (or job scheduler) –
selects which processes should be brought
into the ready queue
 Short-term scheduler (or CPU scheduler)
– selects which process should be executed
next and allocates CPU
 Medium-term scheduler – corresponds to
suspended state (swapping out of the
memory)
27
Addition of Medium Term Scheduling

28
Schedulers (Cont.)
 Short-term scheduler is invoked very frequently
(milliseconds)  (must be fast)
 Long-term scheduler is invoked very infrequently
(seconds, minutes)  (may be slow)
 The long-term scheduler controls the degree of
multiprogramming
 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

29
Context Switch
 When CPU switches to another process, the
system must save the state of the old process
and load the saved state for the new process
 Context-switch time is overhead; the system
does no useful work while switching
 Time dependent on hardware support

30
Contents
 Process Definition
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

31
What information does the OS need to
control processes and manage resources
for them?

32
Memory Tables
 Used to keep track of both main(real) and
secondary memory.
 Must include the following information:
 Allocation of main memory to processes.
 Allocation of secondary memory to processes.
 Protection attributes of blocks of main or virtual
memory, such as which processes may access
certain shared memory regions.
 Information needed to manage virtual memory.

33
I/O Tables
 Used by the OS to manage the I/O
devices.
 May include the following information:
 I/O device is available or assigned
 Status of I/O operation
 Location in main memory being used as
the source or destination of the I/O
transfer
34
File Tables
 Provide information about the existence
of files:
 Existence of files
 Location on secondary memory
 Current Status
 Attributes
 Sometimes this information is maintained
by a file-management system
35
Process Tables
 Used to manage processes
 Include the following information:
 Where process is located
 Depend on the memory management scheme being
used.
 In the simplest case, the process image is maintained as
a contiguous block of memory. This block is maintained
in secondary memory, usually disk.
 Attributes necessary for its management
 Process ID
 Process state
 Location in memory

36
Typically Elements of a Process Image
 User Data
 The modifiable part of the user space.
 May include program data, a user stack area, and programs
that may be modified.
 User Program
 The program to be executed
 System Stack
 Each process has one or more system stacks associated with
it.
 A stack is used to store parameters and calling addresses for
procedure and system calls.
 Process Control Block
 Data needed by the OS to control the process.

37
Process Control Block
 Process Identification
 Processor State Information
 Process Control Information

38
Process Control Block
 Process Identification
 Processor State Information
 Process Control Information

39
Process identification
 Numeric identifiers that may be stored
with the process control block include
 Identifier of this process
 Identifier of the process that created this
process (parent process)
 User identifier

40
Process Control Block
 Process Identification
 Processor State Information
 Process Control Information

41
Processor State Information
 User-Visible Registers
 Control and Status Registers
 PC
 PSW
 Stack Pointers
 Each process has one or more system
stacks associated with it.

42
Process Control Block
 Process Identification
 Processor State Information
 Process Control Information

43
Process Control Information
 Scheduling and State Information:
 Process State (e.g. running, ready, waiting,
etc.)
 Priority
 Scheduling-related information
 Depend on the scheduling algorithm used.
 e.g. amount of time it has already run, how
long it has waited
 Event
 Identity of event the process is awaiting
44
Process Control Information (cont.)
 Data Structuring
 A process may be linked to other processes, e.g to
its parent
 Interprocess Communication
 Various flags, signals, and messages may be
associated with communication between two
independent processes.
 Process Privilege
 Processes are granted privileges in terms of the
memory that may be accessed and the types of
instructions that may be executed.

45
Process Control Information (cont.)
 Memory Management
 Including pointers to segment and/or page tables
that describe the virtual memory assigned to this
process.
 Resource Ownership and Utilization
 Resources controlled by the process may be
indicated, such as opened files.
 A history of utilization of the processor or other
resources may also be included; this information
may be needed by the scheduler.

46
47
Contents
 Process Definition
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

48
Process Creation
 When a new process is to be added to those
currently being managed, the OS builds the
date structures that are used to manage the
process and allocates address space in main
memory to the process. These actions
constitute the creation of a new process.

49
Reasons for Process Creation
 Submission of a new batch job
 The OS is provided with a batch job control stream usually a
tape or disk
 Interactive logon
 A user at a terminal logs on to the system
 Created by OS to provide a service such as printing
 The OS can create a process to perform a function on behalf
of a user program
 Spawned by existing process
 For purposes of modularity or to exploit parallalism, a user
program can dictate the creation of a number of processes.
 When one process spawns another process, the former is
called the parent and the spawned process as the child.

50
Procedure for Process Creation
 Once the OS decides to create a new
process, it can proceed as follows:
(a) Assign a unique process identifier to the new
process
(b) Allocate space for the process.
(c) Initialize the process control block
(d) Set the appropriate linkage
 e.g. if the OS maintains each scheduling queue as a
linked list, then the new process must be put in the
ready or ready/suspend list
(e) Create or expand other data structures
 e.g. the OS may maintain an accounting file on each
process to be used subsequently for billing and/or
performance assessment purpose.
51
Process Creation
 Parent process create children processes,
which, in turn create other processes, forming
a tree of processes
 Resource sharing
 Parent and children share all resources
 Children share subset of parent’s resources
 Parent and child share no resources
 Execution
 Parent and children execute concurrently
 Parent waits until children terminate
 Address space
 Child duplicate of parent
 Child has a program loaded into it
52
Process Creation Example for UNIX
UNIX examples:
fork system call creates new process
exec system call used after a fork to replace the process’
memory space with a new program

53
 Process Creation Example for UNIX -
C Program Forking Separate Process
int main()
{
Pid_t pid;
/* fork another process */
pid = fork();
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 the child to complete */
wait (NULL);
printf ("Child Complete");
exit(0);
}
} 54
A tree of processes on a typical Solaris

55
Process Termination
 A batch job should include a Halt
instruction or an explicit OS service call
for termination.
 User logs off
 For an interactive application, there are
commands to terminate a process.
Control C will terminate a process.
 Error and fault conditions

56
Reasons for Process
Termination
 Normal completion
 The process executes an OS service call to indicate that it
has completed running.
 Time limit exceeded
 The process has run longer than the specified total time
limit.
 Memory unavailable
 The process requires more memory than the system can
provide.
 Bounds violation
 The process tries to access a memory location that it is not
allowed to access.

57
Reasons for Process
Termination (cont.)
 Protection error
 The process attempts to use a resource or a file that it is not
allowed to use, or tries to use it in an improper fashion.
 Example: write to read-only file
 Arithmetic error
 The process tries a prohibited computation, such as division
by zero, or arithmetic overflow.
 Time overrun
 process waited longer than a specified maximum for an
event
 I/O failure
 An error occurs during input or output.
 Privileged instruction
 The process attempts to use an instruction reserved for the
OS
58
Reasons for Process
Termination (cont.)
 Invalid instruction
 The process attempts to execute a nonexistent instruction
(often as a result of branching into a data area and
attempting to execute the data)
 Data misuse
 Operating system intervention
 such as when deadlock occurs
 Parent terminates so child processes terminate
 When a parent process terminates, the OS may
automatically terminate all of the child processes.
 Parent request
 A parent process may terminate any of its child process.

59
Process Switching
 A running process is interrupted and the
OS assigns another process to the
Running state and turns control over to
that process

60
When to Switch a Process
 Interrupt
 Clock interrupt
 process has executed for the maximum allowable time slice
 I/O interrupt
 Memory fault
 memory address is in virtual memory so it must be brought into
main memory
 Trap
 error occurred
 may cause process to be moved to Exit state
 Supervisor call
 such as file open

61
Comparison between interrupt,
trap and supervisor call
Mechanism Cause Use
Interrupt External to the Reaction to an
execution of the asynchronous
current instruction external event
Trap Associated with the Handling of an
execution of the error or an
current instruction exception condition
Supervisor Explicit request Call to an OS
call function

62
Change of Process State
 Save context of processor including program counter
and other registers
 Update the process control block of the process that
is currently in the running state
 Change the state of the process to one of the other states
(Ready, waiting, or Exit, etc.)
 Other relevant fields must also be updated, including the
reason for leaving the Running state and accounting
information
 Move process control block to appropriate queue -
Ready, Waiting, etc.

63
Change of Process State (cont.)
 Select another process for execution
 Update the process control block of the process
selected
 Change the state of this process to Running
 Update memory-management data structures
 This may be required, depending on how address translation
is done
 Restore context of the selected process

64
Process Swapping
 May want to swap out entire process
 Thrashing if too many processes competing for resources
 To swap out a process
 Suspend all of its threads
 Must keep track of whether thread was blocked or ready
 Copy all of its information to backing store (except for PCB)
 To swap a process back in
 Copy needed information back into memory, e.g. page table,
thread control blocks
 Restore each thread to blocked or ready
 Must check whether event(s) has (have) already occurred

65
 Signals
 OS may need to “upcall” into user processes
 Signals
 UNIX mechanism to upcall when an event of interest occurs
 Potentially interesting events are predefined: e.g.,
segmentation violation, message arrival, kill, etc.
 When interested in “handling” a particular event (signal), a
process indicates its interest to the OS and gives the OS a
procedure that should be invoked in the upcall.

66
Signals (Cont’d)
 When an event of interest occurs the
kernel handles the event first, then
modifies the process’s stack to look
as if the process’s code made a Handler
procedure call to the signal handler.
 When the user process is scheduled B B
next it executes the handler first A A
 From the handler the user process
returns to where it was when the
event occurred

67
Contents
 Process Definition
 Process States
 Process Scheduling
 Process Description
 Process Control and Operations
 Interprocess Communication

68
Cooperating Processes
 Independent process cannot affect or be
affected by the execution of another process
 Cooperating process can affect or be
affected by the execution of another process
 Advantages of process cooperation
 Information sharing
 Computation speed-up
 Modularity
 Convenience
69
Two IPC Mechanisms
 Shared mamory
 A region of memory that is shared by cooperating
processes is established.
 Processes can then exchange information by
reading and writing date to the shared region.
 Message passing
 Communication takes place by means of
messages exchanged between the cooperating
processes.

70
Communications Models

71
Example for Shared mamory:
Producer-Consumer Problem
 Paradigm for cooperating processes, producer
process produces information that is
consumed by a consumer process
 unbounded-buffer places no practical limit on the
size of the buffer
 bounded-buffer assumes that there is a fixed
buffer size

72
Bounded-Buffer – Shared-Memory
Solution
 Shared data
#define BUFFER_SIZE 10
Typedef struct {
...
} item;

item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
 Solution is correct, but can only use
BUFFER_SIZE-1 elements
73
Bounded-Buffer – Insert() Method
while (true) {
/* Produce an item */
while (((in + 1) % BUFFER SIZE count) == out)
; /* do nothing -- no free buffers */
buffer[in] = item;
in = (in + 1) % BUFFER SIZE;
}

74
Bounded Buffer – Remove() Method
while (true) {
while (in == out)
; // do nothing -- nothing to consume

// remove an item from the buffer

75
Message-Passing
 Mechanism for processes to communicate and to
synchronize their actions
 Message system – processes communicate with each
other without resorting to shared variables
 providing two operations:
 send(message) – message size fixed or variable
 receive(message)
 If P and Q wish to communicate, they need to:
 establish a communication link between them
 exchange messages via send/receive
 Implementation of communication link
 physical (e.g., shared memory, hardware bus)
 logical (e.g., logical properties) 76
Direct Communication
 Processes must name each other explicitly:
 send (P, message) – send a message to process P
 receive(Q, message) – receive a message from process Q
 Properties of communication link
 Links are established automatically
 A link is associated with exactly one pair of communicating
processes
 Between each pair there exists exactly one link
 The link may be unidirectional, but is usually bi-directional

77
Indirect Communication
 Messages are directed and received from
mailboxes (also referred to as ports)
 Each mailbox has a unique id
 Processes can communicate only if they share a mailbox
 Properties of communication link
 Link established only if processes share a common
mailbox
 A link may be associated with many processes
 Each pair of processes may share several communication
links
 Link may be unidirectional or bi-directional

78
Indirect Communication (cont.)
 Operations
 create a new mailbox
 send and receive messages through mailbox
 destroy a mailbox
 Primitives are defined as:
send(A, message) – send a message to mailbox A
receive(A, message) – receive a message from
mailbox A

79
Indirect Communication (cont.)
 Mailbox sharing
 P1, P2, and P3 share mailbox A, P1 sends; P2 and P3
receive, who gets the message?
 Solutions
 Allow a link to be associated with at most two
processes
 Allow only one process at a time to execute a
receive operation
 Allow the system to select arbitrarily the receiver.
Sender is notified who the receiver was.

80
Synchronization
 Message passing may be either blocking or non-
blocking
 Blocking is considered synchronous
 Blocking send has the sender block until the message is
received
 Blocking receive has the receiver block until a message is
available
 Non-blocking is considered asynchronous
 Non-blocking send has the sender send the message and
continue
 Non-blocking receive has the receiver receive a valid
message or null

81
Buffering
 Queue of messages attached to the link;
implemented in one of three ways
1.Zero capacity – 0 messages
Sender must wait for receiver (rendezvous)
2.Bounded capacity – finite length of n messages
Sender must wait if link full
3.Unbounded capacity – infinite length
Sender never waits

82
Client-Server Communication
 Sockets
 Remote Procedure Calls
 Remote Method Invocation (Java)

83
Sockets
 A socket is defined as an endpoint for communication
 Concatenation of IP address and port
 The socket 161.25.19.8:1625 refers to port 1625
on host 161.25.19.8
 Communication consists between a pair of sockets

84
Socket Communication

85
Remote Procedure Calls
 Remote procedure call (RPC) abstracts procedure
calls between processes on networked systems.
 Stubs – client-side proxy for the actual procedure on
the server.
 The client-side stub locates the server and marshalls
the parameters.
 The server-side stub receives this message, unpacks
the marshalled parameters, and peforms the
procedure on the server.

86
Execution of RPC

87
Remote Method Invocation
 Remote Method Invocation (RMI) is a
Java mechanism similar to RPCs.
 RMI allows a Java program on one
machine to invoke a method on a
remote object.

88
Marshalling Parameters

89
End of lecture 3

Thank you!

90