OPERATING SYSTEMS

Chapter 3 - Processes

CS3104-Operating Systems
Syed Sherjeel Ahmad Gilani, F- 2019
Contents
 Process Concept
 Process Scheduling
 Operations on Processes
 Interprocess Communication
 Examples of IPC Systems
 Communication in Client-Server Systems

2 Operating Systems
Objectives
 To introduce the notion of a process -- a
program in execution, which forms the basis
of all computation

 To describe the various features of processes,

including scheduling, creation and
termination, and communication

 To describe communication in client-server

systems

3
Process Concept
 Process – a program in execution; process
execution progresses in sequential fashion
 An operating system executes a variety of
programs:
 Batch system – jobs
 Time-shared systems – user programs or tasks
 job and process used almost interchangeably
 Program is passive entity, process is active
 Program becomes process when executable file loaded into
memory
 One program can have several processes
 Consider multiple users executing the same program
 Execution of program is started via GUI mouse clicks,
4 command line entry, scripting, remote execution etc.
Creating a Process
Source Assembly Object Executable
Code Code Code
10101010
10101010
10101010
10101010
10101010
10101010

x.c cc x.s as x.o

∞ Stack
10101010 10101010
10101010 10101010
10101010
10101010
10101010
10101010
10101010
10101010
10101010
10101010
OS Data

y.c cc y.s as y.o ld a.ou 0

Code

t
10101010
10101010
10101010
10101010
10101010
10101010

z.c cc z.s as z.o

Compiler Assembler Linker Loader

5
Parts of the Process
 Process space have many parts
 Program code, also called text
section
 Current activity including program
counter, processor registers
 Stack containing temporary data
 Function parameters, return addresses,
local variables
 Data section containing global
variables
 Heap containing memory dynamically
allocated during run time

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

7
Process in a Queue

8
Process States
 As a process executes, it changes state
 new: The process is being created
 running: Instructions are being executed
 waiting: 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

9
Process State Diagram

10
Process Control Block (PCB)
 Information associated with
each process
 Process state
 Program counter
 CPU registers
 CPU scheduling information
 Memory-management information
 Accounting information
 I/O status information

11
CPU Switch From Process to Process

12
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 via a context switch.
 Context of a process represented in the
PCB
 Context-switch time is overhead; the
system does no useful work while
switching
 The more complex the OS and the PCB -> longer
the context switch

13
Time dependent on hardware support
Process Scheduling
 Maximize CPU usage, quickly switch processes
onto CPU for time sharing
 Process scheduler selects among available
processes for next execution on CPU
 Maintains scheduling queues of processes
 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

14
Process Scheduling in Linux

15
Process Representation in Linux
 Represented by the C structure
 task_struct
 pid t pid; /* process identifier */
 long state; /* state of the process */
 unsigned int times lice /* scheduling
information */
 struct task struct *parent; /* this process’s
parent */
 struct list head children; /* this process’s
children */
 struct files struct *files; /* list of open files
*/
 struct mm struct *mm; /* address space of this
pro */
16
Ready Queue And Various I/O Device Queues

17
Representation of Process Scheduling

18
Schedulers
 Long-term scheduler (or job scheduler) –
selects which processes should be brought
into the ready queue
 select good process mix of I/O-bound and CPU-
bound processes
 Short-term scheduler (or CPU scheduler) –
selects which process should be executed
next and allocates CPU
 Sometimes the only scheduler in a system

19
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

20
Addition of Medium Term Scheduling

21
Levels of
Scheduling

22
Process Creation
 Parent process create children processes,
which, in turn create other processes, forming a
tree of processes
 Generally, process identified and managed via a
process identifier (pid)
 Resource sharing techniques
 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
23
Process Creation (Cont.)
 Address space
 Child duplicate of parent
 Child has a program loaded into it

 UNIX examples
 fork system call creates new process
 exec system call is used after a fork to replace
the process memory space with a new program

24
Process Creation

25
C Program Forking Separate Process
#include <sys/types.h>
#include <studio.h>
#include <unistd.h>
int main()
{
pid_t pid; /* fork another process */
pid = fork(); /* fork is returned twice, once in parent, second in child */
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
return 1;
}
else if (pid == 0) { /* child process */
execlp("/bin/ls", "ls", NULL); /* child executes another process */
}
else { /* parent process */
wait (NULL); /* parent will wait for the child */
printf ("Child Complete");
}
return 0;
}
26
A Tree of Processes on Solaris

27
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 are terminated.
 Zombie processes
 A zombie process or defunct process is a process that has
completed execution but still has an entry in the process table
 This entry is still needed to allow the parent process to read its
28
child's exit status
Suspended Processes

 Problem: all processes in memory might

be waiting for I/O (CPU much faster than
I/O).
 What to do?
 Swapping
 involves moving part or all of a
process from main memory to disk
 when none of the processes in main
memory is in Ready, OS swaps one of
the blocked processes out on to disk
29 into a suspend queue
One Suspend State

30
Process State Transition Diagram with Two
Suspend States - Seven-State Process Model
New

Admit Suspend
Admit

Activate Dispatch
Ready, Ready Running Exit
suspend
Suspend Time out

Event Event
Event
Occurs Wait
Occurs

Activate
Blocked, Blocked
suspend
31 Suspend
UNIX Process State Transition Diagram (1)

32
UNIX Process State Transition Diagram (2)
 User running: Executing in user mode.
 Kernel running: Executing in kernel model.
 Ready to run, in memory: Ready to run as
soon as the kernel schedules it.
 Asleep in memory: unable to execute until
an event occurs; process in main memory.
 Ready to run, swapped: process is ready to
run, but the swapper must swap the
process into main memory before the
kernel can schedule it to execute.

33
UNIX Process State Transition Diagram (3)

 Sleeping, swapped: The process is awaiting

an event and has been swapped to secondary
storage.
 Preempted: process is returning from kernel to
user mode, but the kernel preempts it and
does a process switch to schedule another
process.
 Created: process is newly created and not yet
ready to run.
 Zombie: process no longer exists, but it
leaves a record for its parent process to
collect.
34
Assignment
 Zombie Process:
 How Zombie processes are created,
 Do they occupy resources if yes what kind of
resources?,
 Advantage of Zombie process and to whom and
 How Zombie Processes are terminated

 Unix state transition:

 Write in your own words with understanding, all the
transition states. (To the point)
 Comparison with any other O.S’s process state
transition.

35
 Due: submission next week class.
Interprocess Communication
 Processes within a system may be independent
or cooperating
 Reasons for cooperating processes:
 Information sharing
 Computation speedup
 Modularity
 Convenience
 Cooperating processes need InterProcess
Communication (IPC)
 Two models of IPC
 Shared memory
 Message passing

36
Communications Models

Message Passing Shared Memory

37
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

38
IPC – Message Passing
 Mechanism for processes to communicate and to
synchronize their actions
 IPC facility provides 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)

39
IPC – 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

40
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

41
Indirect Communication
 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

42
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
43
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

44
Examples of IPC Systems – POSIX [1]
 POSIX Shared Memory
 Process first creates shared memory segment
segment id = shmget(IPC PRIVATE, size, S IRUSR | S
IWUSR);
 The first parameter specifies the key ( identifier )
of the segment. IPC_PRIVATE creates a new shared
memory segment.
 The second parameter indicates how big the
shared memory segment is to be, in bytes.
 The third parameter is a set of bitwise ORed flags.
In this case the segment is being created for
reading and writing.
 The return value of shmget is an integer identifier
45
Examples of IPC Systems – POSIX [2]
 Process wanting access to that shared
memory must attach to it
shared memory = (char *) shmat(id, NULL, 0);
 The first parameter specifies the key ( identifier )
of the segment that the process wishes to attach
to its address space
 The second parameter indicates where the
process wishes to have the segment attached.
NULL indicates that the system should decide.
 The third parameter is a flag for read-only
operation. Zero indicates read-write; One indicates
readonly.
 The return value of shmat is a void *, which the
46
process can use ( type cast ) as appropriate. In
this example it is being used as a character
Examples of IPC Systems – POSIX [3]
 Now the process could write to the shared
memory
sprintf(shared memory, "Writing to shared
memory");
 When done a process can detach the shared
memory from its address space
shmdt(shared memory);
 And finally the process that originally
allocated the shared memory can remove it
from the system suing shmctl.
shmctl( segment_id, IPC_RMID );

47
Examples of IPC Systems – Windows XP
 Message-passing centric via Local Procedure
Call (LPC) facility
 Only works between processes on the same system
 Uses ports (like mailboxes) to establish and maintain
communication channels
 Communication works as follows:
 The client opens a handle to the subsystem’s connection port
object.
 The client sends a connection request.
 The server creates two private communication ports and
returns the handle to one of them to the client.
 The client and server use the corresponding port handle to
send messages or callbacks and to listen for replies.

48
Communication in Client-Server Systems
 Sockets
 A socket is defined as an endpoint for
communication

 Concatenation of IP address and port

 A socket is identified by an IP address concatenated
with a port number, e.g. 200.100.50.5:80
 The socket 161.25.19.8:1625 refers to port 1625 on
host 161.25.19.8
 Port numbers are well-known - reserved for common
Internet services. For example, telnet servers listen to
port 23, ftp servers to port 21, and web servers to port
80
 Communication consists between a pair of sockets
50
Socket Communication

51
Communication in Client-Server Systems
 Remote Procedure Calls (RPC)
 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 performs the procedure
on the server

52
Communication in Client-Server Systems
 Pipes
 Acts as a conduit allowing two processes
to communicate

 Issues
 Is communication unidirectional or
bidirectional?
 In case of two-way communication, is it half
duplex or full-duplex?
 There must exist a relationship (i.e. parent-
child) between the communicating processes?
 Can the pipes be used over a network?
53
Ordinary Pipes
 Ordinary Pipes allow communication in
standard producer-consumer style
 Producer writes to one end (the write-end of the
pipe)
 Consumer reads from the other end (the read-
end of the pipe)
 Ordinary pipes are therefore
unidirectional
 Require parent-child relationship
between communicating processes

54
Creating Ordinary Pipes in Unix
#include <unistd.h>
int pipe(int fd[2]);

// fd[0] for read from pipe

// fd[1] for write to pipe

Pipes (Before Fork)

55
Ordinary Pipes after Fork()

Pipes
(After Fork and
appropriate closing)

56
Named Pipes
 Named Pipes are more powerful than ordinary
pipes
 Communication is bidirectional
 No parent-child relationship is necessary
between the communicating processes
 Several processes can use the named pipe for
communication
 Provided on both UNIX and Windows systems
 FIFO in Unix

57
References
1. http://www.stanford.edu/~ouster/cgi-bin/cs140-
winter13/lectures.php

58