Process Management

• 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

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

• 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. No parallel execution of instructions of a single 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

• 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

• 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
• Note: only 1 process can be running on any processor at any one time

• 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

• 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

O/S must select processes from various scheduling queues in some

ways- selection

is carried out by the appropriate scheduler.

• Long-term scheduler (or job scheduler) – selects which processes should be brought into the ready queue.
  • Is necessary when there are more processes submitted than can be stored in memory.
• Short-term scheduler (or CPU scheduler) – selects from among the processes that are ready to be executed and allocates CPU to 1 of them.
• Medium-term scheduler (swapper)
  • Temporarily removes process from memory and stores it on disk.
  • Later the process can be swapped back in.

• Short-term scheduler select a new process for the CPU very frequently
  • It execute every few 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.
• Medium-term scheduler has an intermediate frequency of execution.
• Processes can be described as either:
  • I/O-bound process – spends more time doing I/O than using the CPU.
  • CPU-bound process – generates I/O requests infrequently & spends more time doing computations.
• Process Mix:
  • Ideally we want a good balance between CPU & I/O bound processes to provide the system with best performance.
  • What happens if all processes are I/O bound?
  • What happens if all processes are CPU bound?

• 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

• System must provide mechanisms for:
  • Process creation
  • Process termination

• 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
• They are 2 possibilities in terms of execution, When a process creates a new process
  • Parent and children execute concurrently
  • Parent waits until children terminate

• 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

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

• 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

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

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

• 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

item next_produced; while (true) {

/* produce an item in next produced */ while (((in + 1) % BUFFER_SIZE) == out)

; /* do nothing */

buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE;

}

item next_consumed; while (true) {

while (in == out)

; /* do nothing */

next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; /* consume the item in next consumed */

}

• Suppose that we wanted to provide a solution to the consumer-producer problem that fills all the buffers.
• We can do so by having an integer counter that keeps track of the number of full buffers.
• Initially, counter is set to 0.
• The integer counter is incremented by the producer after it produces a new buffer.
• The integer counter is and is decremented by the consumer after it consumes a buffer.

while (true) {

/* produce an item in next produced */ while (counter == BUFFER_SIZE)

; /* do nothing */

buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++;

}

while (true) {

while (counter == 0)

; /* do nothing */

next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE;

counter--;

/* consume the item in next consumed */

}

• 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

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

• Physical:
  • Shared memory
  • Hardware bus
  • Network
• Logical:
  • Direct or indirect
  • Synchronous or asynchronous
  • Automatic or explicit buffering

• Processes must name each other explicitly: (P, message) – send a message to process P
  • send (Q, message) – receive a message from process Q
  • receive
• 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

• 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

• Operations
  • Create a new mailbox (port)
  • Send and receive messages through mailbox
  • Delete a mailbox
• Primitives are defined as: (A, message) – send a message to mailbox A
  • send
  • receive (A, message) – receive a message from mailbox A

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