Scene 1

Scene 2

Process Concept Process Scheduling Operations on Processes Interprocess Communication IPC in Shared-Memory Systems IPC in Message-Passing Systems Examples of IPC Systems Communication in Client-Server Systems

Scene 3

Identify the separate components of a process and illustrate how they are represented and scheduled in an operating system. Describe how processes are created and terminated in an operating system, including developing programs using the appropriate system calls that perform these operations. Describe and contrast interprocess communication using shared memory and message passing. Design programs that uses pipes and POSIX shared memory to perform interprocess communication. Describe client-server communication using sockets and remote procedure calls. Design kernel modules that interact with the Linux operating system.

Scene 4

An operating system executes a variety of programs that run as a process. Process  – a program in execution; process execution must progress in sequential fashion 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

Scene 5

Program is  passive  entity stored on disk ( executable file ); process is  active  Program becomes process when executable file 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

Scene 6

Scene 7

high
argc, agrv
memory
stack
heap
uninitialized
data
initialized
data
low
text
memory
#include <stdio .
#include <stdlib .
int x;
int Y = 15
int main
int argc,
int *values ;
int i;
values —
char *argv C]
(int * ) malloc (sizeof (int) *5)
for (i = O; i < 5; i + + )
values [i] —
i;
return 0;

Scene 8

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

Scene 9

new
admitted
ready
interrupt
exit
running
terminated
scheduler dispatch
1/0 or event completion
1/0 or event wait
waiting

Scene 10

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

process state
process number
program counter
registers
memory limits
list of open files

Scene 11

So far, process has a single thread of execution Consider having multiple program counters per process Multiple locations can execute at once Multiple threads of control ->  threads Must then have storage for thread details, multiple program counters in PCB Explore in detail in Chapter 4

Scene 12

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 */

struct task_struct
process information
struct task_struct
process information
current
(currently executing proccess)
struct task_struct
process information

Scene 13

Maximize CPU use, quickly switch processes onto CPU core Process scheduler  selects among available processes for next execution on 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

Scene 14

ready
queue
wait
queue
queue header
head
tail
head
tail
PCB
7
registers
PCB3
PCB14
PCB 2
registers
PCB6

Scene 15

ready queue
1/0
child
terminates
interrupt
occurs
1/0 wait queue
ci
termination
wait ueue
interrupt
wait queue
CPU
1/0 request
time slice
expired
create child
process
wait for an
interrupt

Scene 16

A  context switch  occurs when the CPU  switches from one process to another.

process Po
executing
idle
executing
operating system
interrupt or system call
save state into PCBo
reload state from PCBI
interrupt or system call
save state into PCBI
reload state from PCBo
process Pl
idle
executing
idle

Scene 17

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   the  longer the context switch Time dependent on hardware support Some hardware provides multiple sets of registers per CPU    multiple contexts loaded at once

Scene 18

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

Scene 19

System must provide mechanisms for:  process creation  process termination

Scene 20

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

Scene 21

systemd
pid= 1
python
pid = 2808
logind
pid = 8415
bash
pid = 8416
ps
pid = 9298
vim
pid = 9204
sshd
pid = 3028
sshd
pid = 3610
tcsh
pid = 4005

Scene 22

Address space Child duplicate of parent Child has a program loaded into it 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()  for the child to terminate

rent
pid = fork()
child (pid = O)
parent (pid > O)
wait()
parent resumes
exec( )
exit()

Scene 23

#include <sys/types .h>
#include <stdio
#include <unistd.h>
int main()
pid-t pid;
fork a child process */
pid = fork() ;
if (pid < 0) { error occurred */
fprintf (stderr, "Fork Failed") •
return 1;
else if (pid 0) { /* child process */
, "Is" NULL) ;
else { /* parent process
parent vill wait for the child to complete
wait (NULL) ;
printf("Chi1d Complete") ;
return 0;

Scene 24

Creating a Separate Process via Windows API

#include <stdio
#include <windows .h>
int main (VOID)
STARTUPINFO si;
PROCESS-INFORMATION pi;
allocate memory
ZeroMemory (&si, sizeof (si));
si.cb = sizeof(si) ;
ZeroMemory (&pi, sizeof (pl));
create child process */
if (!CreateProcess(NULL, use command line
command
NULL, don't inherit process handle
NULL, /* don't inherit thread handle
FALSE, /* disable handle inheritance
0, no creation flags
NULL, /* use parent's environment block */
NULL, use parent's existing directory
&pi))
fprintf (stderr, "Create Process Failed") ;
return -1;
parent will wait for the child to complete
WaitForSingIeObject(pi .hProcess, INFINITE) ;
printf ("Child Complete") ;
close handles
CloseHandIe (pi. hProcess) ;
CloseHand1e (pi. hThread) ;

Scene 25

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

Scene 26

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

Scene 27

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.

Scene 28

Multiprocess 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 multiprocess 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

Chrome Browser
C https:/
chrome
os-B00K.coM
r/desktop/
DOWNLOAD
Wiley: Operating System C x
SET
c
- Hornepage
MEBOOKS
CHROMECAST
Each tab represents a separate process.

Scene 29

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

Scene 30

(a) Shared memory.  		(b) Message passing.

process A
shared memory
process B
kernel
(a)
process A
process B
message queue
kernel
(b)

Scene 31

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

Scene 32

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

Scene 33

Interprocess Communication –  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.  Synchronization is discussed in great details in Chapters 6 & 7.

Scene 34

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

Scene 35

Scene 36

Scene 37

Interprocess Communication – Message Passing

Mechanism for processes to communicate and to synchronize their actions Message system – 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

Scene 38

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?

Scene 39

Implementation of communication link Physical: Shared memory Hardware bus Network Logical:  Direct or indirect  Synchronous or asynchronous  Automatic or explicit buffering

Scene 40

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

Scene 41

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

Scene 42

Operations create a new mailbox (port) 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

Scene 43

Mailbox sharing P 1 , P 2 ,  and  P 3  share mailbox A P 1 , sends;  P 2   and  P 3  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.

Scene 44

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 If both send and receive are blocking, we have a  rendezvous

Scene 45

Scene 46

Scene 47

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

Scene 48

POSIX Shared Memory Process first creates shared memory segment shm_fd = shm_open(name, O CREAT | O RDWR, 0666); Also used to open an existing segment Set the size of the object 	 ftruncate(shm_fd, 4096);  Use  mmap()  to memory-map a file pointer to the shared memory object Reading and writing to shared memory is done by using the pointer returned by  mmap() .

Scene 49

#include
#include
#include
#include
#include
#include
<stdio.
cntl .
<sys/shm.
<sys/stat.
int main()
the size (in bytes) of shared memory object
const int SIZE = 4096;
name of the shared memory object
const char *name =
strings written to shared memory
const char *message-O = "Hello" •
const char *message-I "World! ";
shared memory file descriptor */
int shm-fd;
pointer to shared memory obect
void *Ptr;
create the shared memory object
shm_fd - O_CREAT I ORDWR, 0666);
/* configure the size of the shared memory object */
SIZE) ;
memory map the shared memory object
ptr = mmap(O, SIZE, PROT_WRITE, MAPSHARED, shm_fd, 0);
write to the shared memory object
sprintf (ptr , " , message-0) ;
ptr str1en(message-O);
sprintf (ptr , " ,message-l) ;
ptr strlen(message-l);
return 0;

Scene 50

#include
#include
#include
#include
#include
<stdio. h>
<stdlib.
<fcntl
<sys/shm
<sys/stat.
int main()
the size (in bytes) of shared memory object
const int SIZE = 4096;
name of the shared memory object
const char *name = "OS" •
shared memory file descriptor
int shm-fd;
pointer to shared memory obect
void *Ptr;
open the shared memory object
shmÆd = shm-open(name, O-RDONLY, 0666) ;
memory map the shared memory object
ptr = mmap(O, SIZE, PROTÆiEAD, MAPSHARED, shmåd,
read from the shared memory object
, (char *)ptr) ;
remove the shared memory object
shm-unlink(name) ;
return 0;

Chapter 3: Processes

Scene 1 (0s)

Scene 2 (13s)

Scene 3 (1m 18s)

Scene 4 (1m 53s)

Scene 5 (5m 37s)

Scene 6 (6m 55s)

Scene 7 (7m 48s)

Scene 8 (9m 8s)

Scene 9 (10m 57s)

Scene 10 (12m 55s)

Scene 11 (17m 55s)

Scene 12 (19m 43s)

Scene 13 (21m 4s)

Scene 14 (23m 49s)

Scene 15 (24m 6s)

Scene 16 (25m 20s)

Scene 17 (26m 42s)

Scene 18 (28m 1s)

Scene 19 (29m 58s)

Scene 20 (30m 17s)

Scene 21 (33m 17s)

Scene 22 (33m 50s)

Scene 23 (35m 48s)

Scene 24 (37m 43s)

Scene 25 (38m 47s)

Scene 26 (39m 35s)

Scene 27 (41m 8s)

Scene 28 (42m 5s)

Scene 29 (43m 1s)

Scene 30 (45m 15s)

Scene 31 (45m 51s)

Scene 32 (46m 3s)

Scene 33 (47m 54s)

Scene 34 (49m 11s)

Scene 35 (49m 34s)

Scene 36 (49m 52s)

Scene 37 (49m 59s)

Scene 38 (50m 49s)

Scene 39 (52m 16s)

Scene 40 (53m 6s)

Scene 41 (54m 2s)

Scene 42 (54m 50s)

Scene 43 (55m 19s)

Scene 44 (56m 15s)

Scene 45 (56m 53s)

Scene 46 (57m 8s)

Scene 47 (57m 11s)

Scene 48 (58m 1s)

Scene 49 (58m 53s)

Scene 50 (59m 12s)