Process Management

(PROCESS CREATION IN LINIX USING FORK)

Instructor: Asst Prof Mobeena Shahzad

BESE 24 (A,B,C)
2 Process Concept
 Process – a program in execution
 process execution must progress in sequential fashion.
 No parallel execution of instructions of a single process
 Process is the dynamic execution context of a program

 An operating system executes a variety of programs that run as a process.

 Multiple parts
 The 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
3 Process Concept (Cont.)
 Program is passive entity stored on disk (executable file); process is
active
 Program becomes process when an executable file is loaded into memory

 Execution of program started via GUI mouse clicks, command line

entry of its name, etc.

 One program can be several processes

 Consider multiple users executing the same program
4 Process in Memory
5 Memory Layout of a C Program
 6 Process Control Block (PCB)
Information associated with each process (also called task control block)

 Process state – running, waiting, etc.

 Program counter – location of instruction to next execute
 CPU registers – contents of all process-centric registers
 CPU scheduling information- priorities, scheduling
queue pointers
 Memory-management information – memory allocated
to the process
 Accounting information – CPU used, clock time elapsed
since start, time limits
 I/O status information – I/O devices allocated to process,
list of open files
7 Process Representation in Linux
Represented by the C structure task_struct

pid t_pid; /* process identifier */

long state; /* state of the process */
unsigned int time_slice /* 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 process */
8 Process State
 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 Diagram of Process State
10 Process Scheduling
 Process scheduler selects among available processes for next execution on
CPU core

 Goal -- Maximize CPU use, quickly switch processes onto CPU core

 Maintains scheduling queues of processes

 Ready queue – set of all processes residing in main memory, ready and waiting to
execute
 Wait queues – set of processes waiting for an event (i.e., I/O)
 Processes migrate among the various queues
11 Ready and Wait Queues
12 Representation of Process Scheduling
 13 CPU Switch From Process to Process
A context switch occurs when the CPU switches from one process to
another.
14 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 pure overhead; the system does no useful work while
switching
 The more complex the OS and the PCB  the longer the context switch
 Time dependent on hardware support
 Some hardware provides multiple sets of registers per CPU  multiple contexts
loaded at once
15 Multitasking in Mobile Systems
 Some mobile systems (e.g., early version of iOS) allow only one process to run,
others suspended
 Due to screen real estate, user interface limits iOS provides for a
 Single foreground process- controlled via user interface
 Multiple background processes– in memory, running, but not on the display, and with
limits
 Limits include single, short task, receiving notification of events, specific long-running
tasks like audio playback

 Android runs foreground and background, with fewer limits

 Background process uses a service to perform tasks
 Service can keep running even if background process is suspended
 Service has no user interface, small memory use
16 Operations on Processes

 System must provide mechanisms for:

 Process creation
 Process termination
17 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 options

 Parent and children share all resources
 Children share subset of parent’s resources
 Parent and child share no resources
 Execution options
 Parent and children execute concurrently
 Parent waits until children terminate
 Address space
 Child duplicate of parent
 Child has a program loaded into it
18 A Tree of Processes in Linux
19 Process Creation
 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
 Parent process calls wait()waiting for the child to terminate
20 Process Creation: Unix
 In Unix, subprocess is created by a call to system routine fork

 The variable values and program counter (PC) are copied from the parent to the
new child process

 The return value of fork is different in the parent and child process
 In the parent process, the return value is the child process Id
 In the child process, the return value is 0
 This is the only difference between the parent and the child process

 The parent can wait for the child to terminate by executing wait system call OR the
parent can continue to execute

 The child often starts a new and different program within itself, via a call to exec
 #include <sys/types.h>
#include <studio.h> C Program
21 #include <unistd.h> Forking Separate
int main()
{ Process
pid_t retValue;

retValue = fork(); /* fork another process */

if (retValue < 0) { /* error occurred */

printf ("Fork Failed");
return 1;
} ild
Ch

else if (retValue == 0) { /* child process */

printf (“Child Process Created");
}

re nt
else if (retValue > 0) { /* parent process */ Pa
/* parent will wait for the child */
wait (NULL);
printf ("Child Complete");
}
return 0;
}
 int main()
{
22 pid_t retValue; C Program
Forking
retValue = fork(); /* fork another process */ Separate
Process
if (retValue < 0) { /* error occurred */
printf ("Fork Failed");
return 1;
}
else if (retValue == 0) { /* child process */
printf (“Child Process Created");
execlp ("/bin/ls", "ls", NULL);
}
else { /* parent process */
/* parent will wait for the child */
wait (NULL);
printf ("Child Complete");
}
return 0;
}
23
 Process Creation – Using fork()
 pid_t fork(); -- copy the current process
 New process has different pid

 Return value from fork(): pid (like an integer)

 When > 0:
 Running in (original) Parent process
 return value is pid of new child

 When = 0:
 Running in new Child process

 When < 0:
 Error! Must handle somehow
 Running in original process

 State of original process duplicated in both Parent and Child!

fork() + exec()
i ld
Ch

re nt
Pa
#include <stdlib.h>
#include <stdio.h> Example
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv[]) {

pid_t cpid, mypid;
pid_t pid = getpid(); /* get current processes PID
*/
printf("Parent pid: %d\n", pid);
cpid = fork();
if (cpid > 0) { /* Parent Process */
mypid = getpid();
printf("[%d] parent of [%d]\n", mypid, cpid);
} else if (cpid == 0) { /* Child Process */
mypid = getpid();
printf("[%d] child\n", mypid);
} else {
perror("Fork failed");
}
}
#include <stdlib.h>
#include
#include
<stdio.h>
<unistd.h>
Example
#include <sys/types.h>

int main(int argc, char *argv[]) {

pid_t cpid, mypid;
pid_t pid = getpid(); /* get current processes PID
*/
printf("Parent pid: %d\n", pid);
cpid = fork();
if (cpid > 0) { /* Parent Process */
mypid = getpid();
printf("[%d] parent of [%d]\n", mypid, cpid);
} else if (cpid == 0) { /* Child Process */
mypid = getpid();
printf("[%d] child\n", mypid);
} else {
perror("Fork failed");
}
}
#include <stdlib.h>
#include
#include
<stdio.h>
<unistd.h>
Example
#include <sys/types.h>

int main(int argc, char *argv[]) {

pid_t cpid, mypid;
pid_t pid = getpid(); /* get current processes PID
*/
printf("Parent pid: %d\n", pid);
cpid = fork();
if (cpid > 0) { /* Parent Process */
mypid = getpid();
printf("[%d] parent of [%d]\n", mypid, cpid);
} else if (cpid == 0) { /* Child Process */
mypid = getpid();
printf("[%d] child\n", mypid);
} else {
perror("Fork failed");
}
}
#include <stdlib.h>
#include
#include
<stdio.h>
<unistd.h>
Example
#include <sys/types.h>

int main(int argc, char *argv[]) {

pid_t cpid, mypid;
pid_t pid = getpid(); /* get current processes PID
*/
printf("Parent pid: %d\n", pid);
cpid = fork();
if (cpid > 0) { /* Parent Process */
mypid = getpid();
printf("[%d] parent of [%d]\n", mypid, cpid);
} else if (cpid == 0) { /* Child Process */
mypid = getpid();
printf("[%d] child\n", mypid);
} else {
perror("Fork failed");
}
}
30 Example 2
int i;
cpid = fork();

if (cpid > 0) {
for (i = 0; i < 5; i++) {
printf("Parent: %d\n", i);
}

} else if (cpid == 0) {
for (i = 0; i > -5; i--) {
printf("Child: %d\n", i);
}
}

What does this print?

 #include <windows.h>

int main( VOID ){

STARTUPINFO si;
PROCESS_INFORMATION pi; Process
31 ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
Creation
ZeroMemory( &pi, sizeof(pi) ); // Start the child process. using WIN32
if( !CreateProcess( NULL, // No module name (use command line).
API
"C:\\WINDOWS\\system32\\mspaint.exe", // Command line.
NULL, // Process handle not inheritable.
NULL, // Thread handle not inheritable.
FALSE, // Set handle inheritance to FALSE.
0, // No creation flags.
NULL, // Use parent's environment block.
NULL, // Use parent's starting directory.
&si, // Pointer to STARTUPINFO structure.
&pi ) // Pointer to PROCESS_INFORMATION structure.
)
{
printf( "CreateProcess failed (%d).\n", GetLastError() );
return -1;
}
WaitForSingleObject( pi.hProcess, INFINITE ); // Wait until child process exits.

CloseHandle( pi.hProcess ); // Close process and thread handles.

CloseHandle( pi.hThread );
}
 #include <windows.h>

int main( VOID ){

STARTUPINFO si;
PROCESS_INFORMATION pi;
32
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi) );

BOOL retValue;

retValue = CreateProcess( NULL, "C:\\WINDOWS\\system32\\mspaint.exe", NULL, NULL,

FALSE, 0, NULL, NULL, &si, &pi )

if( retValue == 0)
{
printf( "CreateProcess failed (%d).\n", GetLastError() );
return -1;
}

WaitForSingleObject( pi.hProcess, INFINITE ); // Wait until child process exits.

CloseHandle( pi.hProcess ); // Close process and thread handles.

CloseHandle( pi.hThread );
}
33 Process Termination
 Process executes last statement and then asks the operating system to delete it
using the exit() system call.
 Returns status data from child to parent (via wait())
 Process’ resources are deallocated by operating system

 Parent may terminate the execution of children processes using the abort()
system call. Some reasons for doing so:
 Child has exceeded allocated resources
 Task assigned to child is no longer required
 The parent is exiting, and the operating systems does not allow a child to continue if
its parent terminates
34 Process Termination

 Some operating systems do not allow child to exists if its parent has terminated.
If a process terminates, then all its children must also be terminated.
 cascading termination. All children, grandchildren, etc., are terminated.
 The termination is initiated by the operating system.

 The parent process may wait for termination of a child process by using the
wait()system call. The call returns status information and the pid of the
terminated process
pid = wait(&status);

 If no parent waiting (did not invoke wait()) process is a zombie

 If parent terminated without invoking wait(), process is an orphan
35 Android Process Importance Hierarchy

 Mobile operating systems often have to terminate processes to reclaim

system resources such as memory. From most to least important:
 Foreground process
 Visible process
 Service process
 Background process
 Empty process

 Android will begin terminating processes that are least important.

36 Multi-process Architecture – Chrome Browser
 Many web browsers ran as single process (some still do)
 If one web site causes trouble, entire browser can hang or crash

 Google Chrome Browser is multi-process with 3 different types of processes:

 Browser process manages user interface, disk and network I/O
 Renderer process renders web pages, deals with HTML, Javascript. A new renderer
created for each website opened
 Runs in sandbox restricting disk and network I/O, minimizing effect of security exploits

 Plug-in process for each type of plug-in

37 Interprocess Communication
 Processes within a system may be independent or cooperating

 Cooperating process can affect or be affected by other processes, including sharing data
 Reasons for cooperating processes:
 Information sharing
 Computation speedup
 Modularity
 Convenience

 Cooperating processes need interprocess communication (IPC)

 Two models of IPC

 Shared memory
 Message passing
38 Communications Models
(a) Shared memory. (b) Message passing.
39 Producer-Consumer Problem
 Paradigm for cooperating processes:
 producer process produces information that is consumed by a consumer
process

 Two variations:
 unbounded-buffer places no practical limit on the size of the buffer:
 Producer never waits
 Consumer waits if there is no buffer to consume
 bounded-buffer assumes that there is a fixed buffer size
 Producer must wait if all buffers are full
 Consumer waits if there is no buffer to consume
40 IPC – Shared Memory

 An area of memory shared among the processes that wish to communicate

 The communication is under the control of the users processes not the
operating system.

 Major issues is to provide mechanism that will allow the user processes to
synchronize their actions when they access shared memory.
41 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

while (true) {
/* Produce an item */
42
while (( (in+1) % BUFFER SIZE) == out)
; /* do nothing -- no free buffers */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER SIZE;
}

Producer while (true) {

& while (in == out)
Consumer ; /* do nothing -- nothing to consume
*/
// remove an item from the buffer
nextConsumed= buffer[out];
out = (out + 1) % BUFFER SIZE;
}
43 IPC – Message Passing

 Processes communicate with each other without resorting to shared

variables

 IPC facility provides two operations:

 send(message)
 receive(message)

 The message size is either fixed or variable

44 Message Passing (Cont.)

 If processes P and Q wish to communicate, they need to:

 Establish a communication link between them
 Exchange messages via send/receive

 Implementation issues:
 How are links established?
 Can a link be associated with more than two processes?
 How many links can there be between every pair of communicating processes?
 What is the capacity of a link?
 Is the size of a message that the link can accommodate fixed or variable?
 Is a link unidirectional or bi-directional?
45 Implementation of Communication Link

 Physical:
 Shared memory
 Hardware bus
 Network

 Logical:
 Direct or indirect
 Synchronous or asynchronous
 Automatic or explicit buffering
46 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
47 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
48 Indirect Communication (Cont.)
 Operations
 Create a new mailbox (port)
 Send and receive messages through mailbox
 Delete a mailbox

 Primitives are defined as:

 send(A, message) – send a message to mailbox A
 receive(A, message) – receive a message from mailbox A
 Indirect Communication (Cont.)
49

 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.
50 Synchronization
Message passing may be either blocking or non-blocking

 Blocking is considered synchronous

 Blocking send -- the sender is blocked until the message is received
 Blocking receive -- the receiver is blocked until a message is available

 Non-blocking is considered asynchronous

 Non-blocking send -- the sender sends the message and continue
 Non-blocking receive -- the receiver receives:
 A valid message, or
 Null message

 Different combinations possible

51 Producer-Consumer: Message Passing
 Producer
message next_produced;
while (true) {
/* produce an item in next_produced */

send(next_produced);
}

 Consumer
message next_consumed;
while (true) {
receive(next_consumed)

/* consume the item in next_consumed */

}
52 Buffering

 Queue of messages attached to the link.

 Implemented in one of three ways

1. Zero capacity – no messages are queued on a link.
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
End of Lecture 3

“Process Management”