Ch2_Processes_and_process_management_1.ppt

1
Processes and process management
College of Technology and Engineering
Computer science department
Jimma university
•The process concept
•The threads concept
•Inter-process communication
• Process scheduling
•Scheduling Algorithms
• Deadlocks

2
2.1 process concept
Process is program in execution
Process need resources like
 CPU times
 Memory
 Files
 I/O devices
Resources are allocated to processes either
 When it created
 While it executed
Process can be –
 operating system process –execute system code
 User process – execute user code
The os responsible (process management)
 Creation and deletion of process
 Scheduling of process
 Provision of mechanism for synchronization communication
 Dead lock handling for the process

3
2.1.1 the process
A process is more than program – b/c it
 Include the current activity – represent by the value of
program counter
 A content of processor register
A process also has process
 Stack (contain temporary data like subroutine variables) ,
return address and temporary variables )
 Data section containing global variables
Two process may be associated with the same program – are
considered two separate execution sequences
 Eg a user may invoke many copies of the editor program
 Each are separate process , but their text section are
equivalent ,data section will vary

5
2.1.2 process state
As process execute , it will changes state
Each process may be in one of the following state
 New – a process is being created
 Running – instruction are executed
 Waiting – waiting for some event to occur (like I/O
completion )
 Ready – a process is waiting to be assigned to processor
 Terminated – a process has finished execution

6
New
Ready
Running
terminated
Waiting
admitted
exit
Scheduler dispatch
Interrupt
I/O event
compilation
I/o or event wait
N.B : Only one process running at a time
Many process are in ready or waiting state
Fig. Diagram for Process state

7
2.1.3 Process control Block
Each process is represented in os by process control
block (PCB)
Pointer Process
state
Process number
Program counter
Register
Memory limit
List of open files
.
.
Fig process control block

8
A PCB contain specific information for each process like
 Process state
 Program counter – the counter indicates the address of the
next instruction to be executed for this process
 CPU registers – (vary in number and in type depends on the
computer architecture ) like AC , general purpose register -
this state must be saved when an interrupt occurs
 CPU scheduling info : info like process priority , pointer to
scheduling queues
 Memory management info : info like the values of base and limit
register , page tables
 I/O status info : list of I/O devices allocated to this peocess

9
Save state info PCB0
Reload state from PCB1
Save state info PCB1
Reload state from PCB0
Process p0
Idle Executing
Idle
Idle
Process p1
Interrupt or system call
Interrupt or system call
Fig diagram showing CPU switch from process to process

10
2.2 Process scheduling
Objective of multi programming – is to have
process running at all times – maximize CPU
utilization
Objective of time sharing – to switch CPU among
process – user can interact with each program

11
2.2.1 Scheduling queues
Processes that are in main memory are ready to
execute are kept on a list called ready queue (in
linked list )
A ready queue header will contain pointer to the
first and last PCBs in the list.
Each PCB has a pointer field that point to the next
process in the ready queue
A list of process waiting for the particular I/O
devices is called a device queue
Each device has its own device queue.

12
Fig Ready Queue And Various I/O Device Queues

13
2.2.2 Scheduler
An OS select process from the queues in some
fashion
The selection process is carried out by the
appropriate scheduler.

14
Ready queue CPU
I/O request
Time slice expired
Fork a child
Wait for an interrupts
Interrupt
occurs
Child execute
I/O
Fig Queuing diagram representation of process scheduling

15
Long term scheduling – select job from the pool (disk) and
load in the memory for the execution
 Execute less frequently
 Control the degree of multi programming
Short term scheduler (CPU scheduler ) – select from the
ready process to execute
 Execute so frequently
Most process can be either I/O bound or CPU bound
I/O bound process is a process that spends more of the
time doing I/O than it spends doing execution
A CPU bound process – is one generates I/O requests
infrequently (most of its time is computation )

16
A long term scheduler select a good process mix
of I/O bound and CPU bound process
OS like time sharing system – introduce
intermediate level of scheduling
Partially executed
Swapped out process
Ready queue
CPU
I/O waiting
queue
I/O
End
Swap out
Fig medium term scheduler – scheduling to the queues

17
2.2.3 Context switch
Switching the CPU to other process – require
saving the state of old process and loading the
saved state for the new process
It is pure overhead = > means the system does not
do useful work while switching
Context switch speed varies from machine to
machine – depending on the memory speed ,
number of register
Speed range from 1micro second to 1000
microsecond

18
2.3 Operation on process
The processes in the system can execute
concurrently, and must be created and deleted
dynamically.
So an operating system must provide a mechanism
for process creation and termination.

19
Process Creation
A process may create several new processes, via a
createprocess system call, during the course of execution.
Parent process create children processes, child create
other processes, forming a tree of processes
When a process creates a sub process, the sub process may
be able to obtain
 its resources directly from the operating system, or
 it may be constrained to a subset of the resources of the
parent process.
 Parent and children share all resources

20
A tree of processes on a typical Solaris

21
When a process creates a new process, two
possibilities exist in terms of execution:
 The parent continues to execute concurrently with its
children.
 The parent waits until some or all of its children have
terminated.
Two possibilities in terms of the address space of
the new process:
 The child process is a duplicate of the parent process.
 The child process has a program loaded into it.

22
Example UNIX
In UNIX, each process is identified by its process
identifier( unique integer).
A new process is created by the fork system call.
The new process consists of a copy of the address space of
the original process.
This mechanism allows the parent process to communicate
easily with its child process.
Both processes (the parent and the child) continue execution
at the instruction after the fork with one difference:
 The return code for the fork is zero for the new (child)
process,
 whereas the (nonzero) process identifier of the child is
returned to the parent.

23
The exec system call is used after a fork by one of the two
processes to replace the process memory space with a new
program.
The exec system call loads a binary file into memory
(destroying the memory image of the program containing the
exec system call) and starts its execution.
The parent can then create more children, or, if it has
nothing else to do while the child runs, it can issue a wait
system call to move itself off the ready queue until the
termination of the child.

25
Process Termination
Process executes last statement and asks the operating
system to delete it (exit)
 Output data from child to parent (via wait)
 Process’ resources are deallocated by operating system
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 operating system do not allow child to continue
if its parent terminates
 All children terminated - cascading termination

26
2.4 Cooperating Processes
The concurrent processes executing in the operating system
may be either
 independent processes or
 cooperating processes.
A process is independent if it cannot affect or be affected
by the other processes executing in the system - any
process that does not share any data (temporary or
persistent) with any other process is independent.
A process is cooperating if it can affect or be affected by
the other processes executing in the system- any process
that shares data with other processes is a cooperating
process.

27
Reasons for providing an environment that allows process
cooperation:
 Information sharing: Since several users may be interested in the same
piece of information (for instance, a shared file), we must provide an
environment to allow concurrent access to these types of resources.
 Computation speedup: If we want a particular task to run faster, we
must break it into subtasks, each of which will be executing in parallel
with the others. Notice that such a speedup can be achieved only if the
computer has multiple processing elements (such as CPUs or I/O
channels).
 Modularity: We may want to construct the system in a modular fashion,
dividing the system functions into separate processes
 Convenience: Even an individual user may have many tasks to work on at
one time. For instance, a user may be editing, printing, and compiling in
parallel.

28
Concurrent execution( cooperation processes )
 Need process to communicate with each other
(Inter process communication )
 To synchronize their actions
(process synchronization )

29
producer-consumer problem
Paradigm for cooperating processes, producer process produces
information that is consumed by a consumer process
Eg
 a print program produces characters that are consumed by the printer
driver.
 A compiler produce assembly code, which is consumed by an assembler.
To allow producer and consumer processes to run concurrently, we
must have available a buffer of items that can be filled by the
producer and emptied by the consumer.
A producer can produce one item while the consumer is consuming
another item.
The producer and consumer must be synchronized, so that the
consumer does not try to consume an item that has not yet been
produced.

30
The unbounded-buffer producer-consumer
problem - no limit on the size of the buffer.
 The consumer may have to wait for new items, but the
producer can always produce new items.
The bounded-buffer producer consumer problem
assumes that there is a fixed buffer size.
 The consumer must wait if the buffer is empty and the
producer must wait if the buffer is full.

31
The buffer provided either
 by the operating system through the use of IPC
 by the application programmer with the use of shared
memory.

32
2.5 Inter process Communication
The previous example show how cooperating
processes can communicate in a shared-memory
environment- share a common buffer pool, and
that the code for implementing the buffer be
explicitly written by the application programmer.
Another way –an operating system to provide the
means for cooperating processes to communicate
with each other via an inter process-
communication (IPC) facility.

33
Con …
Inter process-communication is best provided by a message
system.
An IPC facility provides at least the 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, network )
 logical (e.g., logical properties)

35
Naming
Processes that want to communicate must have a
way to refer to each other.
 direct communication
 indirect communication,

36
Direct Communication
each process explicitly name the recipient or
sender of the communication.
 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

37
Example : Producer – consumer
The producer process is defined as
repeat
produce an item in nextp
send(consumer, nextp);
until false;
The consumer process is defined as
repeat
receive (producer, nextc);
consume the item in nextc
until false‘

38
The above example exhibit symmetric
asymmetric
 Send (P, message). Send a message to process P.
 Received (id , message). Receive a message from any
process; the variable id is set to the name of the process
with which communication has taken place.

39
Indirect Communication
The messages are sent to and received from
mailboxes ( 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

40
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

41
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.

42
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

43
In the nonzero-capacity cases, a process does not
know whether a message has arrived at its
destination after the send operation is completed.
If this information is crucial for the computation,
the sender must communicate explicitly with the
receiver to find out whether the latter received
the message.

44
E.g. process P sends a message to process Q and can
continue its execution only after the message is received.
Process P executes the sequence
send (Q, message);
receive (Q, message);
Process Q executes
receive (P, message);
send (P, "acknowledgment");
Such processes are said to communicate asynchronously.

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

46
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

48
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.

50
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.

53
Thread
In traditional OS, each process has an address
space and single thread of control.
But, it is desirable to have multiple threads of
control in the same address space running in
parallel
 as they are separate processes (except for shared
address space )

54
Single and Multithreaded Processes

55
Processes and Threads
Process abstraction combines two concepts
 Concurrency
 Each process is a sequential execution stream of
instructions
 Protection
 Each process defines an address space
 Address space identifies all addresses that can be touched
by the program
Threads
 Key idea: separate the concepts of concurrency from protection
 A thread is a sequential execution stream of instructions
 A process defines the address space that may be shared by multiple
threads
 Threads can execute on different cores on a multi core CPU
(parallelism for performance) and can communicate with other threads
by updating memory

56
A thread represents an abstract entity that executes a sequence
of instructions
 It has its own set of CPU registers
 It has its own stack
 There is no thread-specific heap or data segment (unlike process)
Threads are lightweight
 Creating a thread more efficient than creating a process.
 Communication between threads easier than btw. processes.
 Context switching between threads requires fewer CPU cycles and
memory references than switching processes.
 Threads only track a subset of process state (share list of open files,
pid, …)
Examples:
 OS-supported: Windows’ threads, Sun’s LWP, POSIX threads
 Language-supported: Modula-3, Java
 These are possibly going the way of the Dodo

57
Threads VS process
Threads
 A threads has no data segment
or heaps
 A thread cannot live on its own,
it must live within a process
 There can be more than one
thread in a process, the first
thread calls main & has the
process’s stack
 If a thread dies, its stack is
reclaimed
 Inter-thread communication via
 memory.
 Each thread can run on a
different physical processor
 Inexpensive creation and
context switch
Processes
 A process has code/data/heap
& other segments
 There must be at least one
thread in a process
 Threads within a process share
code/data/heap, share I/O, but
each has its own stack &
registers
 If a process dies, its resources
are reclaimed & all threads die
 Inter-process communication
via OS and data copying.
 Each process can run on a
different physical processor
 Expensive creation and context
switch

59
Fig (a) – 3 process – each has its own address
space, and single thread of control (thread)
Fig (b) – single process – with three thread of
control [share same address space ]
Like multi programming , CPU switch rapidly back
and forth among threads
Like process – thread can be in running , blocked ,
ready or terminated state

60
In multi threading , process start with as single threads has
a ability to create new threads by calling library procedure ,
thread_create .
When threads has finished its work , it can exit by calling ,
thread_exit .
If one threads can wait for specific thread to exit by calling
a procedure , thread_wait – block the calling thread until the
specific thread has exited.
Thread call, thread_yield , allows a thread to voluntarily give
up the CPU to let another thread run .
 This call is important , b/c there is no clock interrupts

Ch2_Processes_and_process_management_1.ppt

More Related Content

Similar to Ch2_Processes_and_process_management_1.ppt (20)

Recently uploaded (20)

Ch2_Processes_and_process_management_1.ppt