Ch03 - Processes.ppt

8/12/2019 Ch03 - Processes.ppt

1/90

Silberschatz, Galvin and Gagne 2009Operating System Concepts 8thEdition,

Processes

Modified by M.Rebaudengo - 2010


2/90

3.2 Silberschatz, Galvin and Gagne 2009Operating System Concepts 8thEdition

Process Concept

!An Operating Systemexecutes a variety of programs:

" Batch system jobs" Time-shared systems user programs or tasks.


3/90


Definitions of process

!A program in execution

! An istance of a program running on a computer! A unit of activity characterized by the execution of a sequence of

instructions, a current state and an associated set of system resources.

!The termsjoband processcan be used almost interchangeably


4/90


A process includes

!text section (program code)

! program counter! stack (temporary data: function parameters, return addresses and

local variables)! data section (global variables)! heap (dynamically allocated memory).


5/90


Process in Memory


6/90


Processes and programs

! The program is a passiveentity; whereas the process is the activeentity! Two processes may be associated to the same programs

" e.g., two users may be running two copies of the Web browser program" each of these is a separate process" the text sections are equivalent" the data, heap, stack sections vary.


7/90


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.

! Only one process may be runningon any processor at any instant.! Many processes may be readyand waiting.


8/90


Diagram of Process State

5-state model

timeout


9/90


Process Control Block (PCB)

! The most important data structure in an OS! Information associated with each process:

"Process identifier: unique numeric identifier of theprocess

"Process state: new, ready, running, waiting,terminated

"Program counter: the address of the next instructionto be executed

"CPU registers: along with the program counter, thisstate information must be saved when an interrupt

occurs


10/90



" CPU scheduling information: needed by the OS to perform itsscheduling function!process priority!scheduling-related information (e.g., the amount of time that the

process has been waiting and the amount of time that the processexecuted the last time it was running)

!pointers to scheduling queues" Memory-management information:

!mapping between virtual and physical memory locations." Accounting information: used for billing purposes and performance

measurements!the amount of CPU and real time used!main memory storage occupancy

" I/O status information: resources allocated to the process!HW units: the list of I/O devices allocated to the process!the list of open files.


11/90




12/90


CPU Switch From Process to Process


13/90


Process Scheduling

! The objective of multiprogramming is to have some processrunning at all times, to maximize the CPU utilization

! The objective of time sharing is to switch the CPU amongprocesses so frequently that users can interact with eachprogram while it is running

! To meet these objectives, the process scheduler selects anavailable process for program executionon the CPU.


14/90


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! Each device has its own device queue! Processes migrate among the various queues.


15/90


16/90


Representation of Process Scheduling

! Queueing diagram:" each rectangular box represents a queue

!two types of queues are present: the ready queue a set of device queues

" the circles represent the resources that serve the queues" the arrows represent the flow of processes in the system.


17/90


Representation of Process Scheduling


18/90


Schedulers

! Long-term scheduler (or job scheduler) selects which processes shouldbe brought into the ready queue" in a batch system active processes are spooledto a mass-storage

device, where they are kept for later execution" the long-term scheduler selects processes from this pool and loads

them into memory for execution!

Short-term scheduler (or CPU scheduler) selects which process shouldbe executed next and allocates CPU:" it selects from processes that are ready to execute.


19/90


Schedulers (cont.)

! Frequency of execution:" Short-term scheduler is invoked very frequently (once ever 100

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

(the number of processes in memory)

" The long-term scheduler may need to be invoked only when aprocess leaves the system. Because of the longer intervalbetween executions, the long-term scheduler can afford to take

more time to decide which process should be selected forexecution.


20/90


21/90


OSs without long-term scheduler

! The long-term scheduler may be absent or minimal" Time-sharing systems often have no long-term scheduler but simply put

every new process in memory for the short-term scheduler" the stability of these systems depends either on a physical limitation

(the number of available terminals) or on the self-adjusting nature of

users (if the performance declines to unacceptable levels on amultiusers system, some user will simply quit, or on a multitasking

system, some tasks will be killed).


22/90


Addition of Medium Term Scheduling

! Some OSs may introduce an additional, intermediate level of scheduling: amedium-term scheduler:" it could be advantageous to remove processes from memory and thus

reduce the level of multiprogramming" later, the process could be reintroduced in memory, and its execution

can be continued where it left off."

This scheme is called swapping.


23/90


24/90


25/90


Operations on processes

! Most systems provide a mechanism to create and terminate processes.


26/90


Process Creation

! A process may create several new processes, via a create-process systemcall, during the course of execution:" the creating process is called a parentprocess" the new processes are called the childrenprocesses of that parent.

! Parent process create children processes, which, in turn create otherprocesses, forming a treeof processes

! Generally, process is identified and managed via a uniqueprocessidentifier (pid), which is an integer number.


27/90


A tree of processes on a typical Solaris


28/90


Process Creation (cont.)

! When a process creates a new process the following possibilitiesexist in terms of:" Resource sharing

!Parent and children share all resources!Children share subset of parents resources!Parent and child share no resources

" Execution!Parent and children execute concurrently!Parent waits until all of its children have terminated.


29/90


Process Termination

! Process executes last statement and asks the operating system todelete it (exit)" Output data from child to parent (via wait)" Processresources 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 itsparent terminates All children terminated - cascading termination


30/90


UNIX examples

! Process creation:" forksystem call creates new process" execsystem call used after a forkto replace the processmemory

space with a new program


31/90


fork()

! int fork(void);" the return code is zero for the new (child) process" the nonzero and positive process identifier of the child is returned to the

parent process" a negative value represents an error in the process creation

! The two processes share the same program code! The new process consists of a copy of the address space of the original

process! Both processes share the same value of the Program Counter Register:

" Both processes continue the execution at the instruction after thefork()


32/90


Example

int main()

{pid_t pid, fork_return;

/* fork another process */

fork_return = fork();

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

printf("Fork Failed");

}

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

pid = getpid();

printf("I'm the children! pid: %d\n", pid);

/* system call getpid() returns the pid of the calling process */

}

}

else { /* parent process */

printf("I'm the father! the child pid is %d\n", fork_return);

}

}


33/90


Exercise

! Including the initial parent process, how many processes are created by thefollowing program?

int main()

{

/* fork a child process */

fork();

/* fork another process */

fork();

/* and fork another */

fork();

}


34/90


Exercise

! What is the output of this program?

int main()

{

pid_t pid;

/* fork a child process */

pid = fork();

if (pid==0)

while (1)

printf (1);

else

while (1)

printf (2);

}


35/90


exec()

! Typically the exec()system call is used after a fork()system call by one of thetwo processes to replace the process's memory space with a new program.

! The exec()system call loads a binary file into memory (destroying the memoryimage of the program containing the exec()system call) and starts its execution.

! As a new process is not created, the PID does not change across an exec(), but thedata, heap and stack of the calling program are replaced by those of the newprogram

! There is a family of different exec functions! Syntax:

" int execlp(char * path, char *arg0, char *arg1, ..., char*argN, (char *) 0);

" The pathargument specifies the path name of the file to execute as the newprocess image.

" Arguments arg0through argnare a list of pointers to arguments to be passedto the new process image.

" The execfunctions do not normally return to the calling process. If an execfunction returns, an error occurred and the return value is 1.


36/90


wait()

! wait()is a system call that suspends the execution of the parent processwhile the child executes

! When the child process terminates, it returns an exit statusto the operatingsystem, which is then returned to the waiting parent process. The parentprocess then resumes execution.

! Syntax:"

int wait (int *status);" statusis the address of the variable containing the exit status of the

child process" the return value is the pid of the terminated process (or a negative

number in case of error).


37/90


Exercise

! Using the following program, what is the output at line A and line B?int value = 5;

int main()

{

pid_t pid;

pid = fork();

if (pid == 0) { /* child process */

{ value += 15;

printf (CHILD: value =%d\n, value); /* LINE A */

return 0;

}


wait (NULL);

printf (PARENT: value =%d\n, value); /* LINE B */

}

}


38/90


exit()

! exit()is a system call that terminates the process, asking the operatingsystem to delete the process

! The process may return an exit status value to its parent process (via thewait system call)

! All the resources of the process are deallocated by the operating system.! Syntax:

" void exit(int status);" the exit()function causes normal process termination and the value

of status & 0377is returned to the parent process" the exit()function does not return.


39/90


40/90


C Program Forking Separate Processint 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", "-l", NULL);

printf("Failed Exec \n");

exit(-1);

}


/* parent will wait for the child to complete */

wait (NULL);

printf ("Child Complete");

exit(0);

}

}


41/90


Parent termination

! In Unix, if the parent terminates, all its children have assigned as their newparent the initprocess.

! Thus the children still have a parent to collect their status and executionstatistics.


42/90


Independent vs. cooperating processes

! A process is independentif it cannot be affected by the other processesexecuting in the system

! A process is cooperatingif it can affect or be affected by the otherprocesses executing in the systems" any process that shares data with other processes is a cooperating

process.


43/90


Cooperating processes

! Reasons for cooperating processes:" Information sharing" Computation speedup" Modularity" Convenience


44/90


Interprocess Communication

! Cooperating processes need interprocess communication(IPC) mechanism that will allow them to exchange data and

information! Two models of IPC

" Shared memory:!a region of memory that is shared by cooperating

processes is established!processes can exchange information by reading and

writing data to the shared region" Message passing:

!communication takes place by means of messagesexchanged between the cooperating processes.


45/90


Communications Models

Shared memoryMessage passing


46/90


Examples of IPC Systems - POSIX

! POSIX Shared Memory" Process first creates shared memory segmentid = shmget(IPC PRIVATE, size, S IRUSR | S IWUSR);

" Process wanting access to that shared memory must attach to itshared_memory = (char *) shmat(id, NULL, 0);

" Now the process could write to the shared memorysprintf(shared_memory, "Writing to shared memory");

" When done a process can detach the shared memory from its addressspace

shmdt(shared_memory);

" destroy a segment (only after that all the attached processes aredetached)

shmctl(id, IPC_RMID, 0);


47/90


Shared memory and fork/exec/exit

! After a fork()the child inherits all the attached shared memory segments! After an exec()all the attached shared memory segments are detached

(not destroyed)! When exit()all attached shared memory are detached (not destroyed)


48/90


49/90


Example (cont.)

if (pid < 0) exit(-1);

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

while (shm[SHMSZ-2] != 'z')

sleep(1);

for (s = shm; *s != NULL ; s++)

putchar(*s);

putchar('\n');

*shm = '*';

exit (0);

}

else { /* parent process */s = shm;

for (c = 'a' ; c


50/90


Shared memory vs. Message Passing

! Message Passing is useful for exchanging smaller amounts of data! Message Passing is easier to implement for intercomputer communication! Shared memory is faster than message passing, as ...

" message passing systems are typically implemented using system callsand thus require the kernel intervention

" in shared-memory systems, systems calls are required only to establishshared-memory regions and all accesses are treated as classicalmemoy accesses and no assistance from the kernel is required.


51/90


Producer-Consumer Problem

! Paradigm for cooperating processes! producerprocess produces information that is consumed

by a consumerprocess later! Since a producer and a consumer can work at different

speeds, a buffer is needed where the producer can

temporarily store data that can be retrieved by the consumer

at a more appropriate speed

bufferProducer Consumer


52/90


Producer-Consumer Problem

! Unbounded-bufferplaces no practical limit on the size of thebuffer" the consumer may have to wait for new items," the producer can always produce new items

! Bounded-bufferassumes that there is a fixed buffer size" the consumer must wait if the buffer is empty" the producer must wait if the buffer is full.


53/90


Bounded-Buffer Shared-Memory Solution

! Data shared by the producer and the consumer#define BUFFER_SIZE 10typedef struct {

. . .

} item;

item buffer[BUFFER_SIZE];

int in = 0;

int out = 0;

! Circular Array:"in

points to the next freeposition in the buffer" outpoints to the first full position in the buffer" the buffer is empty if in== out" the buffer is full if ((in+1)%BUFFER_SIZE) == out)


54/90


Bounded-Buffer Producer

item nextProduced;

while (true) {/* Produce an item */

while ((in + 1) % BUFFER_SIZE) == out)

; /* do nothing -- no free buffers */

buffer[in] = nextProduced;

in = (in + 1) % BUFFER SIZE;

}


55/90


Bounded Buffer Consumer

item nextConsumed;

while (true) {

while (in == out)

; /* do nothing -- nothing to consume */

/* remove an item from the buffer */

nextConsumed = buffer[out];

out = (out + 1) % BUFFER SIZE;

return nextConsumed;

}


56/90


Interprocess Communication Message Passing

! Message Passing provides a mechanism for processes to communicateand to synchronize their actions without sharing the same address space

! IPC facility provides two operations:" send(message)" receive(message)

! If Pand Qwish to communicate, they need to:" establish a communicationlinkbetween them" exchange messages via send/receive

! Implementation of communication link" physical (e.g., shared memory, hardware bus)" logical (e.g., logical properties)


57/90


Direct Communication

! Each process that wants to communicate must explicitly name the recipientor 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


58/90


59/90


Mailbox

! A mailbox can be owned either by a process or by the operating system.


60/90


Mailbox owned by a process

! If the mailbox is owned by a process (that is the mailbox is part of theaddress space of the process) then we distinguish between the owner(which can only receive messages through this mailbox) and the user(which can only send messages to the mailbox)

! Since each mailbox has a unique owner, there can be no confusion aboutwhich process should receive a message sent to this mailbox

! When a process that owns a mailbox terminates, the mailbox dissapearsand any process that subsequently sends a message to this mailbox mustbe notified that the mailbox no longer exists.


61/90


Mailbox owned by the OS

! A mailbox that is owned by the operating system is independent and is notattached to any particular process. The operaring system must provide amechanism that allows a process to do the following operations:" create a new mailbox" send and receive messages through mailbox" destroy a mailbox.

!The process that creates a new mailbox is the initial owner of the mailboxthat can receive messages through this mailbox

! The ownership and receiving privilege may be passed to other processesthrough appropriate system calls. This provision could result in multiplereceivers for each mailbox.


62/90


63/90


Synchronization

! Message passing may be either blocking or non-blocking! Blockingis considered synchronous

" Blocking send: the sender blocks until the message isreceived

" Blocking receive: the receiver blocks until a message isavailable

!Non-blockingis considered asynchronous

" Non-blocking send: the sender sends the message and

continues" Non-blocking receive: the receiver receives a valid message

or null


64/90


Possible combinations

! blocking send and blocking receive (rendez-vous)! non blocking send and blocking receive! non blockind send and non blocking receive.


65/90


Buffering

! Queue of messages attached to the link; implemented in one of threeways1. Zero capacity 0 messages#

Sender must wait for receiver (rendez-vous)2. Bounded capacity finite length of nmessages#

Sender must wait if link full3. Unbounded capacity infinite length

Sender never waits


66/90


Message queue in UNIX

! A message queue is an ordered list of messages held in the kernel, whichprocesses can access.

! A process can create a new message queue, or it can connect to anexisting one.

msgrcv()

msgsnd()7 2 4

data

data

data

message queuekey = 1841


67/90


Queue Properties

! A queue has a unique key, fixed size, ownership, and access modes.

! It must be explicitly deleted.! A message consists of a type (a positive integer), and data (characters).


68/90


Create/access a queue

! A process can createa new Message Queue (MQ), or it can connectto an existingone

! int msgget(key_t key, int msgflg)

" key:! unique key (name) of the message queue. Every other process that wants to

connect to this queue will have to use the same key.! IPC_PRIVATE: special value for key: it ignores msgflg and returns ID of

message queue on success" msgflg:

! IPC_CREAT: create a new MQ unless it already exists! IPC_EXCL: call of msgget()will fail if MQ already exists

" returns:! ID of message queue (on success)! -1 (otherwise)


69/90


msgsnd()

! To send a message" int msgsnd(int msqid, const void *msgp, size_t msgsz,

int msgflg);

! Arguments" msqidis the message queue identifier returned by msgget()" msgpis a pointer to the data to put on the queue" msgszis the size in bytes of the data to add to the queue" msgflgset to IPC_WAIT to avoid blocking; 0 otherwise.


70/90


71/90


Data Structure

! ptrmust point to a structof the form:#define MSGLEN 100/* any positive integer */

struct msg {long mtype; /* positive message type */char mtext[MSGLEN]; /* for message data */

};

! Cast it to struct msgbuf in msgsnd()" struct msgbuf {

long mtype;char mtext[1];

};

" msgsnd(msqID, (struct msgbuf *) ptr, nbytes, flag);


72/90


Blocking

! When IPC_WAITis not set.! If the queue is full, then msgsnd()will block until:

1. the queue gets less full (i.e. a message is removed)2. the queue is deleted

3. a signal is raised.


73/90


Non-blocking

! IPC_WAITis set

! If the queue is full then msgsnd()returns immediately


74/90


Receiving from the Queue

! int msgrcv(int msqid, void *msgp, size_t msgsz,long msgtyp, int msgflg);

" msgtypcorresponds to the mtypeset in the msgsnd()! msgtypeffect on msgrcv()

" Zero - Retrieve the next message on the queue, regardless of itsmtype.

" Positive - Get the next message with a mtypeequal to thespecified msgtyp

" Negative - Retrieve the first message on the queue whosemtypefield is less than or equal to the absolute value of themsgtypargument.


75/90


sz= msgrcv(msqID, ptr, nbytes, type, flag);

message

queue ID

total no. of bytes

of message field

set to IPC_WAIT

to avoid blocking;

MSG_NOERRORalso possible

type

size of

actual data

type of

message wanted

Receiving from the Queue


76/90


Message Data Length

! If the message data length > nbytesthen:" if MSG_NOERRORis set then the message is removed but

truncated." if MSG_NOERRORis not set then the message is left on the

queue


77/90


type Values

Typevalue Message returned#0 first message#> 0 first message whose type == type< 0 first message whose type is the

lowest value


78/90


Examples

! if type== 5, remove second message! if type== -100 then three calls to msgrcv()remove messages 1, 5, 79

" can use this to code priorities" 1 is highest, ... 100 is lowest

79 5 1

data

data

data


79/90


Blocking

! When IPC_WAITis not set.! If the queue is empty, then msgrcv()will block until:

1. the queue gets some messages#2. the queue is deleted3. a signal is raised


80/90


Non-blocking

! IPC_WAITis set! If the queue is empty then msgrcv()returns immediately, and errnois

assigned ENOMSG


81/90


Destroying a message queue

! There are two ways of destroying a queue:" Use the Unix command ipcsto get a list of defined message queues,

then use the command ipcrmto delete the queue." Write a program.


82/90


! Message Control Operation! int msgctl(int msqid, int cmd, struct msqid_ds *buf);! Arguments

" msqidis the queue identifier obtained from msgget()" cmdtells msgctl()how to behave: IPC_RMID is used to destroy the

message queue" Buf argument can be set to NULL for the purposes of IPC_RMID.

msgctl()


83/90


Communication in Client-Server systems

! Sockets! RPC (Remote Procedure Calls)


84/90


Sockets

! Two processes communicating over a network employ a pair of sockets.! A socket is an IP ADDRSS + a PORT NUMBER! They usually work as a client server connection: server listens for

connections from clients! Specific services have specific ports (telnet: port 23, ftp: port 21, web: port

80)! All ports below 1024 are used for standard services

S


85/90


Sockets

! Client initiates a connection request on a known port (e.g. 80)! The server assigns the client a port (> 1024)

S k t C i ti


86/90


Socket Communication

R t P d C ll


87/90


Remote Procedure Calls

! Remote procedure call (RPC) abstracts procedure calls between processeson networked systems.

! Stubs client-side proxy for the actual procedure on the server.! The client-side stub locates the server and marshallsthe parameters.! The server-side stub receives this message, unpacks the marshalled

parameters, and peforms the procedure on the server.

M h lli P t


88/90


Marshalling Parameters

Marshalling(similar to serialization) is the process of transforming thememory representation of an object to a data format suitable for storage or

transmission.

E ti f RPC


89/90


Execution of RPC

R t M th d I ti


90/90

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.

Ch03 - Processes.ppt

Documents

Transcript of Ch03 - Processes.ppt