Chapter 2 discusses processes and threads, highlighting key concepts such as process states, scheduling mechanisms, and the role of process control blocks (PCBs) in managing process information. It describes how processes are created and terminated, as well as the advantages of multithreading in operating systems. The chapter also explains thread scheduling and the differences between processes and threads, emphasizing their relationship within the context of resource allocation and execution within an operating system.

1. Chapter 2:
Processes and Threads

2. Chapter 2: Processes and Threads
Process Concept – The processes, Process
states, Process control block.
Process Scheduling – Scheduling queues,
Schedulers, context switch
Operations on Process – Process creation with
program using fork(), Process termination
Thread Scheduling- Threads, benefits,
Multithreading Models, Thread Libraries.

3. Introduction
 A process is a smallest unit of work that is scheduled by
O.S
 A Process needs resources such as CPU time, memory, files
and I/O devices, to accomplish its task. These resources are
allocated either when the program is created, or when it is
executing.
 In multiprogramming environment many processes are
present in memory
 To select the process for execution some management is
required . Hence process management is done by O.S
 It Includes switching the CPU between the processes, select
process for running and so on.

4. Process Concept
 An operating system executes a variety of programs:
 Batch system – jobs
 Time-shared systems – user programs or tasks
 Textbook uses the terms job and process almost
interchangeably
 Process is a program in execution; process execution
must progress in sequential fashion
 A process includes following section:
 program counter – includes current activity
 Stack –Which contains temporary data (e.g function
parameters, return addresses and local variables
 data section – contains global variables, static variable
 Text – program code

5. Process in Memory
Code Segment-
Instruction of
program
Global variable /
static variable
Dynamic Memory
allocated variable
Function stack –
Contains temporary
data ,
function parameter,
Local variable,
Return variable
- Heap grow upside
- stack grow downside

6. Process Concept
 Program by itself is not a process. A program is a passive
entity such as a file containing a list of instructions stored
on a disk also called as executable file.
 Whereas a process is an active entity with a program
counter specifying the next instruction to execute and a set
of associated resources.
 A program written in any language in execution state is
called process
 A program becomes a process when an executable file
is loaded into memory

7. Process Concept
 Two common technique for loading executable file are
1) Double-clicking an icon representing the executable file
2) Entering the name of the executable file on the
command line.
 Although two processes may be associated with the same
program, they are nevertheless considered two separate
executed sequence
e.g - Several user may be running different copies of the
mail program, or the same user may invoke many copies
of the web browser program. Each of these is a separate
process and although the text sections are equivalent the
data, heap, and stack sections vary.

8. Process State
 As a process executes, it changes state.
 The state of a process is defined in part by the current
activity of that process.
 Each process in an OS under goes change in state during its
lifetime.
 The change in a state of a process is known as state
transition of a process.
 A state diagram represents the different states in which a
process can be at different times, along with the transitions
from one state to another that are possible in the Os

9. Process State
 Each process may be in one of the following state
 new: The process is being created
 running: Instructions are being executed
 waiting: The process is waiting for some event to
occur
Such as I/O completion or reception of a signal.
 ready: The process is waiting to be assigned to a
processor
 terminated: The process has finished execution

10. Secondary
Memory
Main
Memory
CPU
I/O
Device
New
Ready
P1 P4 P7
Ready Queue
running
I/O Queue
P1 P2 P3
P4 P5 P6
P7 P8 P9
Waiting
exit
Terminate

11. Diagram of Process State

12. Process Control Block (PCB)
 In order to execute instructions the OS has to create
processes. Each process is represented in the OS by the PCB
also called as task control block
 The OS groups all information that needs about a particular
process into a data structure called a PCB or Process
Descriptor.
 When a process is created, OS creates a corresponding PCB
and released whenever the process terminates.
 PCB stores descriptive information pertaining to a process,
 The Basic Purpose of PCB is to indicate the so far progress
of a process.
 In simple words, the OS maintains the information about
each process in a record or a data structure called PCB.

13. Process Control Block (PCB)

14. Process Control Block (PCB)
It is a DS to keep information of Process
Information associated with each process. Each process has its own PCB
 Process state
The state may be new, ready, waiting, halted and so on. This information is
kept in a codified fashion in the PCB. That means it assigns some numbers to each state
and it stores that number so it requires very less space.
 Process number
At the time of process creation O.S allocates a number to the process called
process ID / number
 Program counter
It indicates the address of the next instruction to be executed for this process.
 CPU registers
It vary in no of type depending on the computer architecture. They include
accumulators, index registers, stack pointers, any condition code information. Along with
the program counter the state information must be saved when an interrupt occurs, to
allow the process to be continued correctly afterward

15. Process Control Block (PCB)
 CPU scheduling information
It includes a process priority, pointer to scheduling queues and any other
scheduling parameters.
 Memory-management information
It includes information as the value of the base and limit registers, the page
tables or the segment tables, depending on the memory system used by the O.S
 Accounting information
It includes the amount real of CPU and time used time limits, account numbers,
job or process numbers and so on.
 I/O status information
It includes list of I/O devices allocated to the process, a list of open files and so
on.
 File Management
 Pointer
 Priority

16. Process Scheduling
 The objective of multiprogramming is to keep CPU busy
for maximum time and achieve maximum CPU Utilization
 In uni-processor system only one process is there and
any time it may get the attention of the CPU
 But in multiprogramming as only one process may get
attention of the CPU at a time other processes have to
wait.
 So the process scheduling is necessary and it is
done by O.S

17. Scheduling Queues
 As processes enter the system they are put into a job queue, which
consists of all processes in the system
 The processes that are residing in Main Memory(MM) and are ready and
waiting to execute are kept in a list called the ready queue.
 This queue is stored as a linked list
 A ready queue header contains pointers to the first and final PCB’s in the
list
 Each PCB includes a pointer field that points to the next PCB in the ready
queue.
 A ready queue need not behave (FIFO) always as a queue in the data
structures. A ready queue may be maintained as a priority queue, stack,
tree or linked list
Header
Tail
PCB 2 PCB 9
PCB 7

18. Ready Queue And Various I/O Device Queues

19. Scheduling Queues
 In the system , the processes waiting for CPU are kept in ready queue and
the processes waiting for a device are kept in the device queue.
 A process may have an I/O request and the device requested may be busy
 In such case the I/O request is maintained in the device queue.
 Each device has its own device queue.
 In case of dedicated devices the device queue will never have more
process in it
 In case of sharable devices several processes may be in the ready queue.
 Different types of 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
Processes migrate among the various queues

20. Representation of Process Scheduling
Queuing Diagram

21. Scheduling Queues
 CPU scheduling is represented by a queuing diagram
 Each rectangular box represents a queue.
 Two types of queue are present – the ready queue and
device queue
 Circles represents the resources that serves the queue and
the arrow indicated the flow of processes in the system
 A process that enters the system from outside
world is placed in ready queue. There it waits for CPU
 After the CPU is utilized by the process it may finish its
execution and leave the system or it may need more of
I/O and for that may be placed in the device queue.

22. Scheduling Queues
 Once the process is allocated the CPU and is executing,
one of several events could occur.
1. The process could issue an I/O request and then be
placed in an I/O queue
2. The process could create a new sub-process and wait for
the sub-processes termination(fork())
3. The process could be removed forcibly from the CPU as a
result of an interrupt and be put back in the ready
queue. (interrupt)

23. Functions of Process Scheduling
 Process Scheduling must perform the following
function-
1.Keep track of the status (running, ready or waiting)
of all the process. This is done by traffic controller
2.The process is selected from ready queue and decided
by the scheduler how long it executes
3.When running process requires any I/O resources or
an interrupt occurs or it exceeds its time quantum the
processor de-allocates the process

24. Schedulers
 A process migrates among the various scheduling queues
throughout its lifetime.
 The O.S must select processes from these queue in some way.
 The selected process is carried out by the appropriate
scheduler
 There are 3 different types of scheduler.
1. Long-term scheduler (or job scheduler/Admission
Scheduler) – selects which processes should be brought into
the ready queue
2.Short-term scheduler (or CPU scheduler/Process
Scheduler) – selects which process should be executed next
and allocates CPU
3.Medium term scheduling (Swapper) which determines
when processes are to be suspended and resumed;

25. Addition of Medium Term Scheduling
Medium term scheduler
Short term
scheduler
Long term
scheduler
Job
finishes
with I/O
Job Needs
I/O
New Job

26. Long term Schedulers
 It selects the batch job or process to be executed from a secondary
storage device and loads them into memory for execution.
 It is invoked when the process leaves the system.
 Because of the longer duration between executions LTS can afford to
take more time to decide which process should be selected for
execution.
 It also provide good process mix of I/O bound and CPU bound
processes to the Short term scheduler
 The I/O bound process means the process require more I/O than
CPU
 The CPU bound process means the process require more CPU then
I/O
 System with the best performance will have a combination of CPU
bound and I/O bound processes.

27. Long term Schedulers
 Functions of long term scheduler
1. It communicates directly with the job pool
2. It selects number of jobs from the pool and loads them in
the memory for execution. (degree of
multiprogramming is no. of programs, that can reside
in the memory of the computer at a time)
3. It need to be invoked only when a job leaves the system.
Therefore it is invoked less frequently as compared to
short term scheduler
4. It has the responsibility of selecting proper mix of I/O
bound and CPU bound jobs so that CPU utilization is
good.

28. Short term Schedulers
 It is supposed to select a job from ready queue and submit
it to CPU
 As the STS selects only one job at a time , it is invoked
very frequently
 In case of I/O bound jobs as the ready queue is almost
empty, Short term scheduler has very less work to do.
 The system like time sharing do not have long term
scheduler.
 The jobs are placed directly in the ready queue for the STS
 The dispatcher is the actual component that gives
control of the CPU to the process selected by STS.

29. Medium term Schedulers
 Following are the situations in which medium term
scheduler is required
1. Sometimes it is required to remove some number of
jobs from memory temporarily and reduce degree of
multiprogramming.
2. Sometimes while executing the program, it is found
that memory requirements of the program are changed.
Therefore the job is to be removed from the memory
temporarily.
Swapping is the process associated with the medium
term scheduler by which processes and temporarily
removed and then brought back to the ready queue.

30. Context Switch
 Interrupt cause the O.S to change a CPU from its current task to run a kernel
routine.
 The process of switching the CPU from an old process to an new
process is called context switch.
 When interrupt occurs, the system needs to save the current context of the
process currently running on the CPU so that it can restore that context when
its processing is done, essentially suspending the process and then
resuming it.
 When a context switch occurs, the kernel saves the context of the old process
in its PCB and loads the saved context of the new process scheduled to run.
 It speed varies from M/C to M/C depending on the memory speed, the no. of
registers that must be copied and the existence of special instruction.
 Typical speeds are a few milliseconds.
 Its times are highly dependent on H/W support.

31. Context Switch
Process P0
CPU Execution
Save its state
into PCB’s
CPU Execution
Interrupt or
System call
occurs
Process P2

32. CPU Switch From Process to Process

33. Operations on Process
 Process creation with program using fork(),
Process termination
In the system , the process are created and
deleted dynamically . There are two operations provided
by O.S on processes:
1) Process creation
2) Process termination

34. Process Creation
 A process may create several new process through create process system
call during the course of execution
 The creating process is called a parent process and the new process are
called the children of that process.
 Each of these new processes in turn create other processes, forming a tree of
processes
 Generally, process identified and managed via a process identifier (pid)
 In Unix a listing of process can be obtained using ps command
 A process will need certain resources (CPU time, memory, files, I/O devices)
to accomplish its task. When a process creates a sub process that sub process
may be able to obtain its resources directly from the O.S
 When a process creates new process two possibility exist in terms of
execution.
1. The parent continues to execute concurrently with its children
2. The parent waits until some or all of its children terminated

35. A tree of processes on a typical Solaris

36. Process Creation
 UNIX examples
 fork system call creates new process
 If the child process is created the return code of fork call
is zero and when the child is returned to parent the
return code is non-zero.
 fork usually returns the identification of the child to the
parent
 execlp system call used after a fork to replace the
process’ memory space with a new program

37. Process Creation

38. C Program Forking Separate Process
int 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", NULL);
}
else { /* parent process */
/* parent will wait for the child to complete */
wait (NULL);
printf ("Child Complete");
exit(0);
}
}

39. Process Termination
 A process terminates when it finishes executing its final
statement and ask the O.S to delete it by using the exit()
system call.
 At that point , the process may return a status values to
its parent process ( through the wait system call)
 All the resources of the process including physical and
virtual memory open files and I/O buffers are
deallocated by the O.S
 The another system call is ABORT usually this call can
be invoked by only the parent of the process that is to be
terminated

40. Process Termination
 There are many reasons for terminating the execution
of child process by parent process such as:-
1. The child has crossed the limit of usage of the resources
it has been allocated
2. The child process no longer required.
3. If the parent terminates then O.S does not allows a child
to continue execution
 A process may terminates normally or abnormally .
When the process terminates then all its child must be
terminated. This is called cascading termination

41. Thread Scheduling-
 Threads, benefits,
 Multithreading Models,
 Thread Libraries.

42. Threads
Smallest unit of processing that can be
performed in an O.S.
It always exits within a process that means single
process may contain multiple threads.
Thread is a basic unit of CPU utilization, which
consists of thread Id, Program Counter , Registers
Set and Stack

43. □ A full process includes numerous things:
■ an address space (defining all the
code and data pages)
■ OS resources and accounting
information
■ a “thread of control”,
□ defines where the process is
currently executing
□ PC, registers, and stack
□ Creating a new process is costly
■ all of the structures (e.g., page tables)
that must be allocated
□ Communicating between processes is costly
■ most communication goes through the
OS

44. Threads and Processes
□ Most operating systems therefore support two entities:
 the process,
□ which defines the address space and general
process attributes
 the thread,
□ which defines a sequential execution stream
within a process
□ A thread is bound to a single process.
 For each process, however, there may be many
threads.
□ Threads are the unit of scheduling
□ Processes are containers in which threads execute

45. Benefits of Multithreading Programming
□ Responsiveness
□ Resource Sharing
□ Economy
□ Utilization Multiprocessor Architecture

47. Single and Multithreaded Processes

48. Threads vs. Processes
1. A thread has no data segment
or heap
2. A thread cannot live on its own,
it must live within a process
3. Threads within a process share
code/data/heap, share I/O, but
each has its own stack &
registers
4. Inexpensive creation
5. Inexpensive context switching
6. If a thread dies, its stack
is reclaimed
7. No System call
1. A process has code/data/heap
& other segments
2. A process has at least one
thread
3. There can be more than one
thread in a process, the first
thread calls main & has the
process’s stack
4. Expensive creation
5. Expensive context switching
6. If a process dies, its resources
are reclaimed & all threads die
7. System Call involved in process

49. Types of thread
1) User level threads-Supported above the
kernel and are managed without kernel support
2) Kernel level threads-Supported and managed
directly by the operating system.
There must exists a relationship between user
threads and kernel threads

50. User-Level vs. Kernel Threads
4.1
User-Level
□ Managed by application
□ Kernel not aware of thread
□ Context switching cheap
□ Can create many more
□ Must be used with care
Kernel-Level
□ Managed by kernel
□ Consumes kernel resources
□ Context switching expensive
□ Number limited by kernel
resources
□ Simpler to use
Key issue: kernel threads provide virtual processors to user-level threads,
but if all of kernel threads block, then all user-level threads will
block even if the program logic allows them to proceed

51. Multithreading Models
4.1
Multithreading allows the application to divide its task
into individual threads.
In multi-threads, the same process or task can be
done by the number of threads, or we can say that
there is more than one thread to perform the task in
multithreading.
With the use of multithreading, multitasking can be
achieved.
Mapping user threads to kernel threads:
□ Many-to-One
□ One-to-One
□ Many-to-Many

52. Many-to-One
□ Many user-level threads mapped to single kernel
thread
□ Threads Management is done by the thread library
in user space so it is efficient
Advantage
■ Fast - no system calls required
■ Few system dependencies;
■ portable
■Efficient : thread management is
done on the user level
Disadvantage:
 The entire process will block if a thread makes a
blocking system call
 Because only one thread can access the kernel at a
time multiple threads are unable to run in parallel on
multiprocessors
□ Examples:
■ Solaris Green Threads
■ GNU Portable Threads
4.1

53. One-to-One
□ Each user-level thread maps to kernel thread
□ Advantage
■ Provides More concurrency than the many to one models : As each user thread is
connected to different kernel , if any user thread makes a blocking system call,
the other user threads won’t be blocked
■ Better multiprocessor performance – allows multiple threads to run
in parallel on multiprocessors
• disadvantage
■ Each user thread requires creation of kernel thread
■ Because the overhead of creating kernel threads can burden the
performance of an application (most implementation of the model
restrict the number of threads supported by the system
■ Each thread requires kernel resources;
■ limits number of total threads
□ Examples
■ Windows NT/XP/2000 4.1

54. Many-to-Many Model
□ Allows many user level threads to be
mapped to many kernel threads
□ The number of kernel threads may be
specific to either a particular application
or particular machine
□ When a thread performs a blocking
system call, the kernel can schedule
another thread for execution.
■ Allows the operating system to create a
sufficient number of kernel threads
■ If U < L, no benefits of multithreading
■ If U > L, some threads may have to wait
for an LWP to run
□ Examples:
■ Solaris prior to version 9
■ Windows NT/2000 with the ThreadFiber
package

55. Two-level Model
□ Similar to M:M, except
that a user thread
may be bound to
kernel thread
□ Examples
■ IRIX
■ HP-UX
■ Tru64 UNIX
■ Solaris 8 and
earlier
4.1