1
UNIX Process CreationUNIX Process Creation
Every process, except process 0, is created by the fork() system call fork() allocates entry in process table and
assigns a unique PID to the child process Child gets a copy of the parent process image
Both child and parent are executing the same code following fork()
Need to invoke execve to load new binary file fork() returns the PID of the child to the parent
process and returns 0 to the child process
2
UNIX System ProcessesUNIX System Processes
Process 0 is created at boot time and becomes the “swapper” after forking process 1 (the INIT process)
When a user logs in, process 1 creates a process for that user
3
UNIX Process ImageUNIX Process Image
User-level context Process Text (ie: code: read-only) Process Data User Stack (calls/returns in user mode) Shared memory (for IPC)
only one physical copy exists but, with virtual memory, it appears as it is in the process’s address space
Register context
4
UNIX Process ImageUNIX Process Image
System-level context Process table entry
the actual entry concerning this process in the Process Table maintained by OS
• Process state, UID, PID, priority, event awaiting, signals sent, pointers to memory holding text, data...
U (user) area additional process info needed by the kernel
when executing in the context of this process• effective UID, timers, limit fields, files in use ...
Kernel stack (calls/returns in kernel mode) Per Process Region Table (used by memory manager)
5
Process CharacteristicsProcess Characteristics
The two characteristics are treated independently by some recent OS
The unit of dispatching is usually referred to a thread or a lightweight process
The unit of resource ownership is usually referred to as a process or task
6
Multithreading vs. Single threadingMultithreading vs. Single threading
Multithreading: when the OS supports multiple threads of execution within a single process
Single threading: when the OS does not recognize the concept of thread
MS-DOS support a single user process and a single thread
UNIX supports multiple user processes but only supports one thread per process
Solaris supports multiple threads
7
ThreadsThreads
Has an execution state (running, ready, etc.) Context is saved when not running
Has an execution stack and some per-thread static storage for local variables
Has access to the memory address space and resources of its process All threads of a process share this When one thread alters a (non-private) memory
item, all other threads (of the process) sees that A file opened by one thread, is available to
others
8
Single Threaded and Multithreaded Single Threaded and Multithreaded Process ModelsProcess Models
Thread Control Block contains a register image, thread priority and thread state information
9
Benefits of Threads vs ProcessesBenefits of Threads vs Processes
Takes less time to create a new thread than a process
Less time to terminate a thread than a process
Less time to switch between two threads within the same process
10
Benefits of ThreadsBenefits of Threads
Client/Server paradigm Server may need to handle several file
requests over a short period of time More efficient to create (and destroy) a thread
for each request Multiple threads can execute
simultaneously on different processors
11
Application benefits of threadsApplication benefits of threads
Consider an application that consists of several independent parts that do not need to run in sequence
Each part can be implemented as a thread Whenever one thread is blocked waiting for
an I/O, execution could possibly switch to another thread of the same application (instead of switching to another process)
12
Benefits of ThreadsBenefits of Threads
Since threads within the same process share memory and files, they can communicate with each other without invoking the kernel
Therefore, it becomes necessary to synchronize the activities of various threads so that they do not obtain inconsistent views of the data
13
Threads StatesThreads States
Three key states: running, ready, blocked They have no suspend state because all
threads within the same process share the same address space Indeed: suspending (ie: swapping) a single
thread involves suspending all threads of the same process
Termination of a process, terminates all threads within the process
14
User-Level Threads (ULT)User-Level Threads (ULT)
The kernel is not aware of the existence of threads
All thread management is done by the application, using a thread library
Thread switching does not require kernel mode privileges
Scheduling is application specific
15
Threads libraryThreads library
Contains code for: Creating and destroying threads Passing messages and data between threads Scheduling thread executions Saving and restoring thread contexts
16
Kernel Activity for ULTsKernel Activity for ULTs
The kernel is not aware of thread activity but it is still managing process activity
When a thread makes a system call, the whole process will be blocked
For the thread library that thread is still in the running state
So thread states are independent of process states
17
Advantages and inconveniences of ULTAdvantages and inconveniences of ULT
Advantages Thread switching does
not involve the kernel: no mode switching
Scheduling can be application specific: choose the best algorithm.
ULTs can run on any OS. Only needs a thread library
Inconveniences Most system calls are
blocking and the kernel blocks processes. So all threads within the process will be blocked
The kernel can only assign processes to processors. Two threads within the same process cannot run simultaneously on two processors
18
Kernel-Level Threads (KLT)Kernel-Level Threads (KLT)
All thread management is done by kernel
No thread library but an API to the kernel thread facility
Kernel maintains context information for the process and the threads
Switching between threads requires the kernel
Scheduling occurs on a thread basis, usually
Ex: Windows NT and OS/2
19
Advantages and inconveniences of KLTAdvantages and inconveniences of KLT
Advantages the kernel can
simultaneously schedule many threads of the same process on many processors
blocking is done on a thread level
kernel routines can be multithreaded
Inconveniences thread switching within
the same process involves the kernel. We have 2 mode switches per thread switch
this results in a significant slow down
20
Combined ULT/KLT ApproachesCombined ULT/KLT Approaches
Thread creation done in the user space
Bulk of scheduling and synchronization of threads done in the user space
The programmer may adjust the number of KLTs
May combine the best of both approaches
Example: Solaris
21
SolarisSolaris
Process includes the user’s address space, stack, and process control block
User-level threads (threads library) Invisible to the OS Form the interface for application parallelism
Kernel threads The unit that can be dispatched on a processor and
its structures are maintain by the kernel Lightweight processes (LWP)
Each LWP supports one or more ULTs and maps to exactly one KLT
Each LWP is visible to the application
22
Process 2 is equivalent to a pure ULT approachProcess 4 is equivalent to a pure KLT approachWe can specify a different degree of parallelism (process 3 and 5)
23
Solaris: versatilitySolaris: versatility
We can use ULTs when logical parallelism does not need to be supported by hardware parallelism (we save mode switching) Ex: Multiple windows but only one is active at
any one time If threads may block then we can specify
two or more LWPs to avoid blocking the whole application
24
Solaris: user-level thread executionSolaris: user-level thread execution
Transitions among these states is under the exclusive control of the application A transition can occur only when a call is made to a
function of the thread library It’s only when a ULT is in the active state that it is
attached to a LWP (so that it will run when the kernel level thread runs) A thread may transfer to the sleeping state by
invoking a synchronization primitive (chap 5) and later transfer to the runnable state when the event waited for occurs
A thread may force another thread to go to the stop state...
25
Solaris: user-level thread statesSolaris: user-level thread states
(attached to a LWP)
26
Decomposition of user-level Decomposition of user-level ActiveActive state state
When a ULT is Active, it is associated to a LWP and, thus, to a KLT
Transitions among the LWP states is under the exclusive control of the kernel
A LWP can be in the following states: running: when the KLT is executing blocked: because the KLT issued a blocking
system call (but the ULT remains bound to that LWP and remains active)
runnable: waiting to be dispatched to CPU
27
Solaris: Lightweight Process StatesSolaris: Lightweight Process States
LWP states are independent of ULT states(except for bound ULTs)
28
Operating System Control StructuresOperating System Control Structures
The OS maintains the following tables for managing processes and resources: Memory tables I/O tables File tables Process tables
29
Process images in virtual memoryProcess images in virtual memory
30
Location of the Process ImageLocation of the Process Image
Each process image is in virtual memory May not occupy a contiguous range of
addresses (depending on the memory management scheme used)
Both a private and shared memory address space is used
Location if each process image is pointed to by an entry in the Primary Process Table
For the OS to manage the process, at least part of its image must be brounght into main memory
31
Process Control BlockProcess Control Block
pointer processstate
process number
program counter
registers
memory limits
list of open files
.
.
.
32
PCBPCBProcess IdentificationProcess Identification
A few numeric identifiers may be used Unique process identifier (always)
Indexes, directly or indirectly, into the primary process table
User identifier The user who is responsible for the job
Identifier of the parent process that created this process
33
PCBPCBProcessor State InformationProcessor State Information
Contents of processor registers User-visible registers Control and status registers Stack pointers
Program status word (PSW) Contains status information Example: the EFLAGS register on Pentium
machines
34
PCBPCBProcess Control InformationProcess Control Information
Scheduling and state information Process state ( i.e: running, ready, blocked...) Priority of the process Event for which the process is waiting (if
blocked) Data structuring information
May hold pointers to other PCBs for process queues, parent-child relationships and other structures
35
Execution ModesExecution Modes
To protect PCBs, and other OS data, most processors support at least 2 execution modes: Privileged mode (a.k.a. system mode, kernel
mode, supervisor mode, control mode ) manipulating control registers, primitive I/O
instructions, memory management... User mode
Proper mode is set via a mode bit which can only be set by an interrupt, a trap or OS call
36
CPU Context SwitchCPU Context Switch
process P0operating system process P1
save state into PCB1
reload state into PCB0
reload state into PCB1
save state into PCB0
idle
executing
executing
executing
idle
idle
interrupt or system call
interrupt or system call
37
Context SwitchingContext SwitchingBasic StepsBasic Steps
Save context of processor including program counter and other registers
Update the PCB of the running process with its new state and other associate info
Move PCB to appropriate queue - ready, blocked
Select another process for execution Update PCB of the selected process Restore CPU context from that of the
selected process
38
Process SchedulingProcess Scheduling
Differential responsiveness Discriminate between different classes of jobs
Fairness Give equal and fair access to all processes of
the same class Efficiency
Maximize throughput, minimize response time, and accommodate as many users as possible
39
Scheduling QueuesScheduling Queues
OS maintains queues of processes waiting for resources Short term queue of processes in memory
ready to execute The dispatcher decides who goes next
Long term queue of new jobs waiting to use the system OS must not admit too many processes on
short-term queue A queue for each I/O device consisting of
processes that want to use that I/O device
40
Ready and I/O Device QueuesReady and I/O Device Queues
queue header
headtail
headtail
headtail
headtail
headtail
registers registersreadyqueue
magtape
unit 0
magtape
unit 1
diskunit 0
terminalunit 0
PCB7
PCB5
PCB6PCB14PCB3
PCB2
41
Process SchedulingProcess SchedulingQueueing DiagramQueueing Diagram
42
SchedulersSchedulers
Short-term Scheduler Also, referred to as dispatcher
Long-term Scheduler Mid-term Scheduler
Also, referred to as the swapper
43
Short-term Scheduler Short-term Scheduler DispatcherDispatcher
Dispatcher selects from among ready processes and allocate the CPU to one of them It selects the next process according to a
scheduling algorithm It prevents a single process from
monopolizing CPU CPU always executes instructions from the
dispatcher when switching from one process to another
44
Long-term SchedulerLong-term Scheduler
This scheduler controls the degree of multiprogramming The number of processes in memory
It strives to select a good process mix of I/O bound and CPU-bound processes
If the degree of multiprogramming is stable, the average process arrival rate must be equal to the average process departure rate Thus, long-term scheduler usually gets invoked when a
process leaves the system
45
The need for swappingThe need for swapping
Even with virtual memory, keeping too many processes in main memory may deteriorate the system’s performance
The OS may need to suspend some processes, ie: to swap them out to disk.
Two new states are added states: Blocked Suspended: blocked processes which
have been swapped out to disk Ready Suspended: ready processes which
have been swapped out to disk