Processes: program execution state

1

• Processes program execution state
• Pseudoparallelism
• Multiprogramming
• Many processes active at once
• With switching
• process execution is not repeatable
• processes should make no assumptions about timing
• Process consists of
• Process core image program, data, run-time
  stack
• Program counter, registers, stack pointer
• OS bookkeeping information

2
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 process.
• terminated The process has finished execution.

3
Diagram of Process State
4
Diagram of Process State
X
5
Diagram of Process State
X
X
6
Diagram of Process State
X
X
X
7
Process-Centered Operating System

• One way to view system a scheduler, with
  processes running on top
• Some of the processes are system processes

8
Process Table
One entry per process.
Pr 0 Pr 1 Pr 2 Pr 4 ..Pr N
9
PCB Process Management

• registers, program counter, program status word,
  stack pointer
• process state
• time process started, CPU time used, childrens
  CPU time used
• alarm clock setting
• pending signal bits
• pid
• message queue pointers, other flag bits

10
PCB Memory-Related Information

• pointers to
• text
• Data
• stack segments
• Pointer to page table

11
PCB File-Related Information

• root, working directory
• file descriptors
• User ID
• Group ID

12
Process Control Block (PCB)
13
Context Switch (or Process Switch)

• Currently executing process looses control of CPU
• Its context must be saved (if not terminated)
  into PCS.
• New process is chosen for execution.
• New process context is restored.
• New process is given control of the CPU.

14
CPU Switch From Process to Process
15
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.
• Process migration between the various queues.

16
Ready Queue And Various I/O Device Queues
17
Representation of Process Scheduling
18
Low Level Interrupt Processing

• Each HW device has slot in interrupt vector (IV).
• On interrupt, HW pushes PC, PSW, one or more
  registers.
• Loads in new PC from IV.
• END OF HW
• Assembly code to save registers and info on stack
  (to PCB).
• Assembly sets up new stack for handling process.
• Calls C interrupt handling routing to complete
  interrupt processing.
• Scheduler is called and determines next process
  to run.
• Assembly language restores registers and other
  necessary items (e.g., memory map) of selected
  process and begins its execution.

19
Schedulers

• Long-term scheduler (or job scheduler) selects
  which processes should be brought into the ready
  queue.
• Short-term scheduler (or CPU scheduler) selects
  which process should be executed next and
  allocates CPU.

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

21
Schedulers (Cont.)

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

22
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.
• Context-switch time is overhead the system does
  no useful work while switching.
• Time dependent on hardware support.

23
Process Creation

• Parent process create children processes, which,
  in turn create other processes, forming a tree of
  processes.
• 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 children terminate.

24
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 used after a fork to replace the
  process memory space with a new program.

25
Unix Fork()
include ltstdio.hgt main(int argc, char argv)
int pid, j j 10 pid fork()
if (pid 0) /I am the child/ Do child
things else / I am the parent
/ wait(NULL) / Block execution until
child terminates /
26
(No Transcript)
27
fork()
28
Processes Tree on a UNIX System
29
exec Function calls

• Used to begin a processes execution.
• Accomplished by overwriting process imaged of
  caller with that of called.
• Several flavors, use the one most suited to
  needs.
• int execv( char path, char argvec)

30
exec Function calls

• int execv( char path, char argvec)
• pathname Can be an executable program in your
  directory (application code) or a system program
  such as ls, cd, date, ..
• argvec Pointers to NULL terminated strings.
• First element should always be the name of the
  
• program, last element should always be NULL.
• Assume a.out b.out x.exe. By.by all in home
  directory.

31
main (int argc, argv) int pid char
args2 pid fork() if (pid 0)
args0 ./a.out All executed by
args1 NULL child process
execv(./aout, args) printf(OOOpppssss.\n)
else printf(Not a problem!\n)
Executed by parent
32
Process Termination

• Process executes last statement and asks the
  operating system to decide it (exit).
• Output data from child to parent (via wait).
• Process resources are deallocated by operating
  system.

33
Process Termination

• Parent may terminate execution of children
  processes (abort).
• Child has exceeded allocated resources.
• Task assigned to child is no longer required.
• Parent is exiting.
• Operating system does not allow child to continue
  if its parent terminates.
• Cascading termination.

34
TA

• Xiao Han
• Office Number 581-2260
• Consulting hours 200-400 pm Tuesday and
  Thursday
• Place Unix computer cluster at the first floor
  in Neville Hall

35
void setup(char inputBuffer, char args,int
background) int length, / of
characters in the command line / i,
/ loop index for accessing inputBuffer array /
start, / index where beginning of next
command parameter is / ct /
index of where to place the next parameter into
args / ct 0 / read
what the user enters on the command line /
length read(STDIN_FILENO, inputBuffer,
MAX_LINE) //ssize_t read(int fd, void buf,
size_t count) if (length 0)
exit(0) / d was entered, end of
user command stream if (length lt
0) perror("error reading the command")
exit(-1)
36
/ examine every character in the inputBuffer
/ for (i0iltlengthi)
switch (inputBufferi) case ' '
case '\t' / argument
separators / if (start ! -1)
argsct
inputBufferstart ct
inputBufferi '\0' / add a null char
make a C string / start -1 break

37
case '\n'
if (start ! -1)
argsct inputBufferstart
ct inputBufferi
'\0' argsct NULL
break default / some other
character / if (start -1) start i
if (inputBufferi '')
background 1
inputBufferi '\0'
argsct NULL / just in case the input line
was gt 80 /
38
Cooperating Processes

• 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

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

40
Constraints

• Do not over-write an item not yet consumed.
• Do not write to a full buffer
• Do not read from a previously read item.
• Do not read from an empty buffer.

41
Bounded-Buffer Shared-Memory Solution

• Shared data
• define BUFFER_SIZE 10
• typedef struct
• . . .
• item
• item bufferBUFFER_SIZE
• int in 0
• int out 0

42
Bounded-Buffer Producer Process

• item nextProduced
• while (1)
• while (((in 1) BUFFER_SIZE) out)
• / do nothing /
• bufferin nextProduced
• in (in 1) BUFFER_SIZE

43
Bounded-Buffer Consumer Process

• item nextConsumed
• while (1)
• while (in out)
• / do nothing /
• nextConsumed bufferout
• out (out 1) BUFFER_SIZE

44
Producer
while (((in 1) BUFFER_SIZE) out)
Consumer Blocked
while (in out)
out
in
45
Producer Blocked
while (((in 1) BUFFER_SIZE) out)
Consumer
while (in out)
O
O
O
O
O
46
Producer
while (((in 1) BUFFER_SIZE) out)
Consumer Blocked
while (in out)
X X X X X
47
Interprocess Communication (IPC)

• 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) message size fixed or variable
• receive(message)

48
Interprocess Communication (IPC)

• 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)

49
Implementation Questions

• 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?

50
Communications Models
51
Shared Memory in POSIX

• Requires allocating a shared memory region
• Attaching region to processes address space
• Read/write to memory as usual.
• Detach from address space
• Delete shared memory.

52
Message Passing

• Requires significantly less programming.
• Do not need to share address space (i.e., can be
  extended to processes executing on a different
  system when connected via some network).

53
Implementation Issues

• Must provide (at least)
• send(message) and
• receive(message)
• Communication link between processes that want to
  communicate.
• Several implementation options
• Communication may be
• Direct or indirect
• Synchronous or asynchronous
• Automatic or explicit buffering.

54
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 (only need to
  know other processes identity). Example?
• 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

55

• Communication may also be asymmetric
• send(P, message)
• Sender names receiver.
• receive(id, message)
• Receiver accepts any message and id filled with
  the id of the sender.

56
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

57
Indirect Communication

• 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, where each link corresponds
  to one mailbox

58
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

59
Indirect Communication

• Mailbox sharing
• P1, P2, and P3 share mailbox A
• P1, sends P2 and P3 receive
• Who gets the message?
• Solutions
• 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.

60
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 (rendezvous).
• 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 (can also post a receive
  request, continue, check for completion).

61
Buffering

• Queue of messages attached to the link
  implemented in one of three ways
• 1. Zero capacity 0 messagesSender must wait
  for receiver (rendezvous)
• 2. Bounded capacity finite length of n
  messagesSender must wait if link full
• 3. Unbounded capacity infinite length Sender
  never waits

62
Client-Server Communication

• Sockets
• Remote Procedure Calls
• Remote Method Invocation (Java)

63
Sockets

• A socket is defined as an endpoint for
  communication
• Concatenation of IP address and port
• The socket 161.25.19.81625 refers to port 1625
  on host 161.25.19.8
• Communication consists between a pair of sockets
• Low level Sends/receives a stream of bytes.
• Sockets are either connection-oriented (i.e.,
  TCP) or connectionless (i.e., UDP).

64
Socket Communication
65
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 performs
  the procedure on the server.
• Returns output of procedure (if applicable).

66
Execution of RPC
67
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.
• Can send objects to remote JVM