Process Management

Instructor
Mr. S. Christalin Nelson
Process Management

Overview (1/8)
• Program
– Passive entity
• E.g. Executable file stored on disk (Contains a list of instructions)
• Process
– Active entity
• A program in execution (Executable file loaded into memory)
• E.g. Word-processing program run by an user on PC, System Task
(Sending output to printer)
– Alternatively called as a Job or time-shared program
• Batch Systems => Jobs
• Time-shared Systems => User program or tasks
– Single user System runs processes concurrently (Word, Browser, etc)
• Embedded Device with no multitasking -> OS performs its
internal activities
4/1/2022 Instructor: Mr.S.Christalin Nelson 3 of 66

Overview (2/8)
• Unit of work in modern systems
– Early Computers
• Execute one process at a time
• Process has access to all system resources
– Contemporary Computer Systems
• Allow multi-programing - Execute processes concurrently (switch
CPU between processes)
• Processes share the system resources
• System consists of collection of processes
– OS processes (Executes system code)
– User processes (Executes user code)

Overview (3/8)
• Processes need
– Resources (physical/logical) to accomplish a task
• Example: CPU time, memory, files, I/O devices
• Resource allocation
– During process creation (OR) Execution
– Initialization data (inputs)
• Example of a Process: “Display file status on screen”
– Gets file name (I/P) -> Executes appropriate instructions &
system calls -> Displays desired information -> Terminate -> OS
reclaims the reusable resources

Overview (4/8)
• A process can be executed by one or many threads
– Thread
• A component of a process (light-weight process)
• Example:
– MS Word as a process has Spell checker within it as thread
– Multithreaded Server Architecture

Overview (5/8)
• Program – Process – Thread
– efficient to use one process that contains multiple threads
since process creation is time consuming and resource
intensive

Overview (6/8)
• Single-threaded process
– No. of Program Counters: 1
– Sequentially execute the instructions in the process
• Multi-threaded process
– It is efficient to use one process that contains multiple threads
as process creation is time consuming and resource intensive
– No. of Program Counters: 1 per thread
4/1/2022 Instructor: Mr.S.Christalin Nelson
What is use of a PC?
Store Address of
next instruction to
be executed
8 of 66

Overview (7/8)
• Single & Multicore Systems
– Single-core systems – Concurrent execution of threads
– Multi-core systems – Parallel execution of threads
– Example: Consider an application with 4 threads
– Note: Parallelism vs. Concurrency
• Concurrency – Allow all the tasks to make progress
• Parallelism – Perform more than one task simultaneously

Overview (8/8)
• OS Activities related to Process management
– CPU Scheduling (processes & threads)
– Create and delete processes
– Suspend and resume processes
– Process synchronization mechanisms
– Process communication mechanisms

Process Structure in Memory (1/5)

• Text or Code Segment
– Stores executable instructions of a program (machine
instructions that CPU executes).
– ‘Sharable’
• Only a single copy needs to be in memory for frequently executed
programs (E.g. Text editors, C compiler).
– Often ‘Read-only’/Executable to prevent a program from
accidentally modifying its instructions.

• Data Segment or Initialized DS
– Stores static & global variables that are initialized by
programmer.
– Can be classified into ‘Read Only’ & ‘Read-Write’.
• BSS Segment or Uninitialized DS
– Stores static & global variables that are initialized to zero by
the system before program starts execution.
– Called “bss” segment for “block started by symbol”.

• Heap Segment
– Used for dynamic allocation when program runs.
– Shared by all shared libraries and dynamically loaded modules
in a process.
• Stack Segment
– Stores temporary data. i.e. Local (auto) variables, Stack frame
• Note: Stack frame
– Contains set of values pushed for one function call (function
parameters or at least caller’s return address)
– During each recursive function call a new stack frame is used
– Grows downward to lower addresses.
– ‘Stack pointer’ register points to top of stack.

• Methods for loading exe file into memory
– Double Click icon/app, Enter the name of executable (./a.out)
• Two processes associated with one program is considered as
2 separate execution sequences
– Text section –> Equivalent
– Data, Heap & Stack section –> Different
• A process can spawn many processes as it runs
• Process can be an execution environment for other code
– Example: Java programming environment
• Java executable program is executed within JVM. JVM executes
as a process that interprets the loaded Java code & takes actions
(via native machine instructions) on behalf of that code
– In simulation code is written for a different instruction set

Process States (1/3)
• State is defined partly by current activity of a process
– i.e. During execution the state of a process changes
– Only 1 process runs on any processor
• Many processes may be ready & waiting

• Different states
– New: Process is being created
– Ready: Process is waiting to be assigned to a processor
– Running: Instructions are being executed
– Waiting: Process is waiting for some event to occur
• E.g. For I/O completion or reception of a signal
– Terminated: Process has finished execution
• Note: Names can vary across OSs

• What comprises state of a process or task?
– If P2 is to be created & run -> state of P1 must be saved
• P1 can be later resumed with no side-effects
• Only one copy of registers exist -> Must be saved in memory

Process control block (1/6)
• Repository of information about a
specific process
• PCB contains
– (1) Process state
– (2) Process ID
– (3) Program counter
– (4) CPU registers (Vary in type/number)
• E.g. Accumulators, Index registers, Stack
pointers, & other General-purpose
registers, Condition-code register
– (5) CPU-scheduling information
• Includes process priority, pointers to
scheduling queues, & scheduling
parameters (if any)

• PCB has information associated with a specific process
– (6) Memory-management information
• Includes value of base & limit registers, value of page/segment
tables (depending on memory system used by OS)
– (7) Accounting information
• Includes amount of CPU & real time used, time limits, account
numbers, job or process numbers
– (8) I/O status information
• Includes list of I/O devices allocated to process, list of open files

• Context Switching (1/2)
– Process Context
• Machine environment during the time the process is actively
using the CPU
– i.e. Context includes PC, general purpose registers, etc.
– CPU switches between processes
• The OS must
– Save context of currently executing process (if any) &
– Restore context of that process being resumed
• Time taken depends on hardware support
21 of 66

• Context Switching (2/2)
22 of 66

• Paging

• Segmentation

Process scheduler
• Objectives of MP & timesharing systems
– Multiprogramming systems
• Maximize CPU utilization
• Have some process running at all times
– Time sharing systems
• Switch CPU among processes
• Process Scheduler?
– Meets the objectives by selecting an available process

Scheduling Queues (1/5)
• Job Queue
– All processes in the system awaiting admission
• Ready Queue
– Set of all processes residing in main memory, ready to execute
• New process, Parent process return back to ready Queue after a
wait for its child process to complete
– Structure of Ready Queue

• Device Queue(s)
– Set of processes waiting for an I/O device (or for other
processes)
– Each device has its own device queue

• Queuing Diagram
– A common representation of process scheduling
• Notation used
– Rectangular Boxes: Queues
– Circles: Resources that serve the queues
– Arrows: Flow of processes in the system
Job Queue
29 of 66

• After allocation of CPU, a Process can
– Execute
– Create new child process & Wait for child’s termination
• Eventually enters Ready Queue
– Get interrupted & Process removed from CPU
• Put back in Ready Queue
– Wait for event occurrence (e.g. Completion of an I/O request)
• Issue an I/O request & placed in I/O Queue -> eventually enters
Ready Queue.
– Finally Quit
• Removed from all queues, PCB & resources are deallocated.

• Process migration among various scheduling queues
throughout its lifetime

Schedulers
• System software used by OS to select processes from Queue
• Long-term, Short-term & Medium-term schedulers
– Job scheduler (also known as Long-term scheduler)
• Selects processes from Job pool in secondary into Ready Queue
– Careful mixture of I/O bound & CPU bound processes to yield
optimum system throughput
• Controls Degree of Multiprogramming
– CPU scheduler (also known as Short-term scheduler)
• Selects processes to be executed next & allocates CPU to it
– Process with a long burst time can lead to starvation
• Executes at least once every 100 milliseconds
– Medium-term Scheduler
• Swapping out a process from main memory (Suspension)
– Swapping in or Resumption could occur later from the point it
stopped executing

Operations of Processes (1/3)
• Process Creation
– fork()
• Parent & child process competes for CPU
with all other processes in system
• OS decides
– Which process to execute
– When to execute
– How long to execute

• Process Creation (contd.)
– Orphans
• Process whose parent process has terminated,
though it remains running itself
• It will be immediately adopted by special “init”
system process with PID 1
• wait()
– Blocks caller until one of its child process terminates
– Parent can obtain exit status of terminated child
» Success: returns PID of child
» Failure (no child): returns -1
– Zombies

• Process Creation (contd.)
– exec() family
• Process Termination

Cooperating Processes (1/2)
• Types of Concurrent processes
– Independent Processes
• Cannot affect or be affected by other processes executing in
system
• Does not share data with any other process
– Cooperating Processes
• Can affect or be affected by other processes executing in system
• Shares data with any other process
• Requires IPC mechanisms for data & information exchange
– IPC Models
» Shared Memory Model, Message Passing Model
» Note: Many systems implement both

Cooperating Processes (2/2)
• Advantages of Process Cooperation
– Information sharing
• Concurrent access
– Computation speedup
• Subtasks execute in parallel with others multicore systems
– Modularity
• Dividing system functions into separate processes/threads
– Convenience
• Working with many processes at the same time

Shared-memory model
• Establish a region of memory that can be shared
– Processes can exchange information by
reading/writing data (not simultaneously)
– Processes determine form of data & location
• Not under OS’s control
• Faster than message passing model
– System calls are required only to establish shared
memory region
– Does not require kernel intervention
• Difficult to implement in a distributed system
• Suffers from cache coherency issues in multicore
systems

Producer-Consumer Problem
• Producer & Consumer processes should run concurrently
– Producer process produces information & Consumer process
consumes this information
– Examples
Compiler Assembler Loader
Assembly Code Object Modules
Web Server Client
HTML files & images
• Solution: Use shared memory
– Types of Buffers
• Unbounded-buffer: No practical limit on buffer size
• Bounded-buffer: Assume a fixed buffer size
– Producer & Consumer must be synchronized
• Producer produces an item & Consumer consumes another item
• Code to access/manipulate shared memory - written by
application programmer
Who
waits?
41 of 66

Message-passing model (1/2)
• Processes can exchange messages (smaller amounts of data)
• Slower than Shared memory model
– Implemented using system calls
– Require kernel intervention (more time)
• Easier to implement in a distributed system
– Example: Internet Chat
• Better performance in multicore systems
• Min. 2 operations
– Send & Receive message
• Message Size
– Fixed (or) Variable
42 of 66

Message-passing model (2/2)
• Requirements of two communicating processes
– Establish Communication link between them
– Exchange messages via send/receive
• Implementation of communication link
– Physical (e.g., shared memory, hardware bus, network)
– Logical (e.g., logical properties)
• Methods (with Logical implementation & communication)
– Direct or Indirect communication
– Synchronous or Asynchronous communication
– Automatic or Explicit buffering
43 of 66

Naming (1/4)
• Identify communicating processes (say P & Q)
• Direct Communication
– Hard coded: Identifiers should be explicitly stated
• Symmetric Scheme of Addressing
– P: Send (Q, message)
– Q: Receive (P, message)
• Asymmetric Scheme of Addressing
– P: Send (Q, message)
– Q: Receive (id, message) – Receive from any process
– Properties of communication link
• Links are established automatically
• One link associated with exactly one pair of processes
• Between each pair there exists exactly one link
• Link may be unidirectional (usually bi-directional)

Naming (2/4)
• Indirect Communication
– Each mailbox or port has a unique ID (say A). Mailbox is shared.
• Send (A, message)
• Receive (A, message)
– 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
(each link corresponds to a mailbox)
• Link may be unidirectional or bi-directional

Naming (3/4)
• Indirect Communication (Contd.)
– Who owns the mailbox?
• Process owns mailbox (part of process’s address space)
– Receives messages only through this mailbox
– On process termination, the mailbox disappears
• OS owns mailbox (Independent & not attached to any particular
process). Process operations include
– Create a new mailbox
» Ownership & receiving privilege may be passed to other
processes through appropriate system calls
– Send & Receive messages through mailbox
– Destroy a mailbox

Naming (4/4)
• Indirect Communication (Contd.)
– Mailbox sharing: Who gets the message?
• Consider P, Q, and R share mailbox A. P sends. R & Q receive
• Solutions
– Associate a link with at most two processes
– Only one process can execute a receive operation at a time
– System arbitrarily selects receiver & notifies Sender
» May use Round Robin

Synchronization
• Message passing can be either synchronous (blocking) or
Asynchronous (non-blocking)
– Blocking send
• Sender blocked until receiver process or mailbox gets message
– Non-blocking send
• Sender can send message & continue
– Blocking receive
• Receiver blocked until message is available
– Non-blocking receive
• Receiver receives a valid message or null
• Different combinations are possible
– Rendezvous between sender & receiver -> Blocking Send &
Receive

Buffering
• Direct or indirect communication – exchanged messages
reside in a temporary queue
– Queue Implementation
• Zero capacity – 0 waiting messages
– Blocking Send
• Bounded capacity – finite length of n messages
– If link not full: Non-Blocking Send
» Place message (copy entire message or pointer to it)
– If link full: Blocking Send
• Unbounded capacity – infinite length
– Non-Blocking Send (Sender never waits)

Additional communication strategies
• Low level method
– Sockets
• Allow only unstructured stream of bytes exchanged between
communicating threads – Client/Server application could impose
a structure on the data
• High-level methods
– Remote Procedure Calls (RPCs)
– Pipes

Sockets (1/2)
• Endpoint for communication between distributed processes
– Identified by concatenation of IP address & Port
• i.e. Computer & Software/Service (Port vs. Socket ?)
• Communication consists between a pair of sockets
– Use Client-Server Architecture
• Server socket waits by listening to specified port
– IP: 161.25.19.8, Port: 80 => 161.25.19.8:80
• Client initiates request for connection -> System allocates unique
port (>1024) for each client process
– IP: 146.86.5.20, Port: 1625 => 146.86.5.20:1625
• Client request from client socket
• Server receives in server socket
• Server accepts a connection
52 of 66

Sockets (2/2)
• Ports
– 0 to 1023: Well known ports
• Assigned by IANA (common protocols & services)
– 1024 to 49151: Registered ports
• Assigned by ICANN to a specific service
– 49152 to 65535: Ephemeral or dynamic (private, high) ports
• Ephemeral ports: Used for shorter duration by client applications
– Persistent ports: Used for longer duration by server applications

RPC (1/6)
• Used
– Between systems with network connections
– Implementing a distributed file system
• Message-based communication scheme to provide remote
service
– (Vs. IPC messages) Well structured & not just data packets
– RPC daemon listens to a port on Remote system
– Client send message to RPC daemon in the correct port
• Contains identifier (specifying function to execute) & fn.
parameters
– Function is executed as requested & Output is sent back to
requester in separate message

RPC (2/6)
• RPC Semantics allows client to invoke procedure on remote
host as it would invoke a procedure locally
– Separate client-side Stub for each remote procedure
• Locates remote port -> Parameter marshalling (packaging) ->
Send message to server
– Server-side Stub
• Receives message -> Invokes procedure -> Returns value (if any)
• Note: Stub code in Windows
– Compiled from a specification written in Microsoft Interface
Definition Language (MIDL)

RPC (3/6)
• Issues
– (1) Differences in data representation on client & server (Little-
Endian, Big-Endian)
• Solution: RPC systems have machine-independent data rep.
– E.g. External data rep. (XDR) used during parameter marshalling
– (2) Semantics of a call: Due to common network errors RPCs
can fail, duplicated & executed more than once (vs. Local call)
• Solution: OS ensures messages are acted on “exactly once”,
rather than “at most once”
– At most once
» Attach Timestamp with message -> Ignore incoming messages
that have a timestamp already in history
– Exactly once
» “At most once” protocol + Send acknowledgement to client
» Client resends each RPC call periodically until it receives ACK

RPC (4/6)
• Issues (contd.)
– (3) Binding of client & server port (None have full information)
• Standard calls: Binding replaces procedure call’s name by its
memory address during link, load, or execution time
• Solutions
– Predetermine binding information (Fixed port no. for a service)
» (Compile time) Associate fixed server port no. with RPC ->
(After compilation) Server cannot change port no.
– Dynamic binding by rendezvous mechanism
» OS provides a rendezvous (called matchmaker) daemon on
fixed RPC port -> Client sends message to rendezvous daemon
contains RPC name & requests RPC port no. -> Port no. given ->
RPC sent to port no. until process terminates (or server crash)
» Requires extra overhead of initial request, More flexible

RPC (6/6)
• Implementing a distributed file system (DFS)
– Set of RPC daemons & clients
– Message sent to DFS port on a server with reqd. disk operation
(read, write, rename, delete, or status) -> Return message
contains data resulting from that call -> DFS daemon executes
on behalf of client
• Message might request whole file transfer or a simple block
– Whole file: several requests may be needed

Pipes (1/6)
• Conduit allowing two processes to communicate
• Issues
– Allows bidirectional or unidirectional communication?
• If 2-way communication is allowed, is it half duplex or full duplex
– Must a relationship (such as parent–child) exist between
communicating processes?
– Can pipes communicate over network or must communicating
processes reside on same machine?
• Types
– Ordinary Pipes
– Named Pipes

Pipe (2/6)
• Ordinary Pipe
– Unidirectional
• Producer (write-end) & Consumer (read-end)
• Bidirectional: Requires 2 pipes
– Requires parent–child relationship between communicating
processes (UNIX & Windows)
• Two processes communicate in producer-consumer fashion
• Cannot be accessed by other process
• Initially, parent & child process close their unused ends of pipe
– close()
– Used for communication between processes on same machine

Pipe (3/6)
• Ordinary Pipe (contd.)
– Unix
• Creation: pipe(int fd[])
• Access: read(), write() system calls
– Windows systems (referred as "Anonymous pipes”)
• Creation: CreatePipe()
• Access: ReadFile(), WriteFile()
• Programmer specifies the attributes to be inherited by child
Read
End
Write
End
62 of 66

Pipe (4/6)
• Named Pipes
– Communication can be bidirectional
– Parent–child relationship is not required
• Several processes can use a pipe (can have several writers)
– Pipe continue to exist after communicating processes have
finished
– Supported by UNIX & Windows systems

Pipe (5/6)
• Named Pipes (contd.)
– UNIX (referred as FIFOs)
• Appear as typical files in the file system
• FIFOs allow bidirectional communication (only half-duplex is
permitted)
– 2 FIFOs required
• Creation: mkfifo() system call
• Manipulation: open(), read(), write(), close() system calls
• Continue to exist until it is explicitly deleted from file system
• Communicating processes must reside on same machine
– Inter-machine communication requires use of sockets
• Transmits only byte-oriented data

Pipe (6/6)
• Named Pipes (contd.)
– Windows
• Full-duplex communication is allowed
• Creation: CreateNamedPipe()
• Communication: ReadFile(), WriteFile()
– Client connects to a named pipe using ConnectNamedPipe()
• Communicating processes can reside on same or different
machines
• Transmits either byte or message oriented data

Process Management

More Related Content

What's hot

Similar to Process Management

More from Christalin Nelson

Recently uploaded

Process Management