Download Module 4: Processes

Module 2.0: Processes and Threads
•
•
•
•
•
Process Concept
Trace of Processes
Process Context
Context Switching
Threads
– ULT
– KLT
K. Salah
1
Operating Systems
Process
•
•
•
•
•
Also called a task.
Useful and Important Concept:
Process = program in execution
A process is not the same as a program. Program is a passive entity, whereas
process is active. Process consists of an executable program, associated data,
and execution context.
Modern (multiprogramming) operating systems are structured around the
concept of a process.
Multiprogramming OS supports execution of many concurrent processes. OS
issues tend to revolve around management of processes:
– How are processes created/destroyed?
– How to manage resource requirements of a process during its execution:
cpu time, memory, I/O, communication, ... ?
– How to avoid interference between processes?
– How to achieve cooperation and communication between processes?
K. Salah
2
Operating Systems
Program Creation
•
•
•
•
•
Program (say, C program) is edited
It is compiled into assembly language, which may consist of several
modules.
Assembly language modules are assembled into machine language.
External references (i.e., to procedures and data in another module) are
resolved. This is called linking, which creates a load module.
Load or image module is stored as a file in file system and may be
executed at a later time by loading into memory to be executed.
K. Salah
3
Operating Systems
Process creation and termination
•
•
•
•
•
•
•
Consider a simple disk operating system (like MS-DOS, typically
supports only one process at a time)
User types command like “run foo” at Keyboard (I/O device driver for
keyboard, screen)
Command is parsed by command shell
Executable program file (load module) “foo” is located on disk (file
system, I/O device driver for disk)
Contents are loaded into memory and control transferred ==>
process comes alive! (device driver for disk, relocating loader,
memory management)
During execution, process may call OS to perform I/O: console, disk,
printer, etc. (system call interface, I/O device drivers)
When process terminates, memory is reclaimed. (memory
management)
K. Salah
4
Operating Systems
Two Types
•
Processes can be described as either:
– I/O-bound process –
 spends more time doing I/O than computations
 many short CPU bursts
 Long I/O burst
 Ex: vi
– CPU-bound process
 spends more time doing computations
 Heavy number crunching
 few very long CPU bursts
 Ex: simulation
K. Salah
5
Operating Systems
Trace of Processes
K. Salah
6
Operating Systems
Trace of processes (cont.)
K. Salah
7
Operating Systems
Trace of processes (cont.)
K. Salah
8
Operating Systems
K. Salah
9
Operating Systems
Example
If parent
chooses to wait
until the child
executes (but
not always the
case).
K. Salah
10
Operating Systems
Multiprogramming/Timesharing Systems
•
•
•
They provide interleaved execution of several processes to give
an illusion of many simultaneously executing processes.
Computers can be a single-processor or multi-processor
machine.
The OS must keep track of the state for each active process
and make sure that the correct information is properly installed
when a process is given control of the CPU.
K. Salah
11
Operating Systems
Multiprogramming (multiple processes)
•
•
For each process, the O.S. maintains a data structure, called
the process control block (PCB). The PCB provides a way of
accessing all information relevant to a process:
– This data is either contained directly in the PCB, or else the
PCB contains pointers to other system tables.
Processes (PCBs) are manipulated by two main components of
the process subsystem in order to achieve the effects of
multiprogramming:
– Scheduler: determines the order by which processes will
gain access to the CPU. Efficiency and fair-play are issues
here.
– Dispatcher: actually allocates CPU to process next in line
as determined by the scheduler.
K. Salah
12
Operating Systems
Process Context
•
•
•
•
The context (or image) of a process can be described by
– contents of main memory
– contents of CPU registers
– other info (open files, I/O in progress, etc.)
Main memory -- three logically distinct regions of memory:
– code region: contains executable code (typically read-only)
– data region: storage area for dynamically allocated data structure,
e.g., lists, trees (typically heap data structure)
– stack region: run-time stack of activation records
CPU registers: general registers, PC, SP, PSW, segmentation registers
Other info:
– open files table, status of ongoing I/O
– process status (running, ready, blocked), user id, ...
K. Salah
13
Operating Systems
The Process Control Block (PCB)
•
•
The PCB typically contains the following types of
information:
Process status (or state): new, ready to run, user
running, kernel running, waiting, halted
– Program counter: where in program the
process is executing
– CPU registers: contents of general-purpose
register stack pointer, PSW, index registers
– Memory Management info: segment base and
limit registers, page table, location of pages on
disk, process size
– User ID, Group ID, Process ID, Parent PID, ...
– Event Descriptor: when process is in the
“sleep” or waiting state
– Scheduling info: process priority, size of CPU
quantum, length of current CPU burst
K. Salah
14
Operating Systems
PCB (cont.)
– List of pending signals
– Accounting info: process execution time, resource utilization
– Real and Effective User IDs: determine various privileges allowed
the process such as file access rights
– More timers: record time process has spent executing in user and
Kernel mode
– Array indicating how process wishes to react to signals
– System call info: arguments, return value, error field for current
system call
– Pending I/O operation info: amount of data to transfer, addr in user
memory, file offset, ...
– Current directory and root: file system environment of process
– Open file table: records files process has open
K. Salah
15
Operating Systems
Process States & Transitions
•
•
•
K. Salah
Zooming in
Running
–
User-running
–
Kernel-running
Ready
–
Ready, suspend
–
Ready
Suspend may swap
out all or part of the
process. Shared
regions/segments are
not suspended.
Waiting (or blocked)
–
Blocked
–
Blocked, suspend
16
Operating Systems
How queues are implemented?
K. Salah
17
Operating Systems
When to context switch
•
•
•
•
Typically, hardware automatically saves the user PC and PSW when interrupt
occurs, and takes new PC from interrupt vector.
Interrupt handler may simply perform its function and then return to the same
process that was interrupted (restoring the PC and PSW from the stack).
Alternatively, may no longer be appropriate to resume execution of process that
was running because:
 process has used up its current CPU quantum
 process has requested I/O and must wait for results
 process has asked to be suspended (sleep) for some amount of time
 a signal or error requires process be destroyed (killed)
 a “higher priority” process should be given the CPU
 E.g., pressing ctrl-alt-delete
In such a situation, a context switch is performed to install appropriate info for
running a new process.
K. Salah
18
Operating Systems
Mechanics of a Context Switch
1 copy contents of CPU registers (general-purpose, SP, PC, PSW, etc.) into a
save area in the PCB of running process
2 change status of running process from “running” to “waiting” (or “ready”)
3 change a system variable running-process to point to the PCB of new
process to run
4 copy info from register save area in PCB of new process into CPU registers
•
Note:
 context switching is pure overhead and should be done as fast as possible
 often hardware-assisted - special instructions for steps 1 and 4
 determining new process to run accomplished by consulting scheduler
queues
 step 4 will start execution of new process - known as dispatching.
K. Salah
19
Operating Systems
MULTIPROGRAMMING Through
CONTEXT SWITCHING
K. Salah
20
Operating Systems
Process Creation
•
•
•
•
Parent process creates children processes, which, in turn create
other processes, forming a tree of processes
Resource sharing models/types:
– Parent and children share all resources
– Children share subset of parent’s resources
– Parent and child share no resources
Execution
– Parent and children execute concurrently
– Parent waits until children terminate
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
K. Salah
21
Operating Systems
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);
}
}
K. Salah
22
Operating Systems
A tree of processes on a typical Solaris
K. Salah
23
Operating Systems
Introduction to Threads

Parallelism at different levels

Granularity of parallelism at processor level
 Coarse-grain – processes
 Fine-grain -- threads

Multitasking OS can do more than one thing concurrently by
running more than a single process

Processes can do several things concurrently be running more
than a single thread.

Each thread is a different stream of control that can execute its
instructions independently.
A program (e.g. Browser) may consist of the following threads:
 GUI thread
 I/O thread
 computation
K. Salah
24
Operating Systems
Processes and Threads

A typical process consists of

a running program

a bundle of resources (file descriptor table, address space)

A thread, called a lightweight process, has its own

stack

CPU Registers

state

All the other resources are shared by all threads of that process.
These include:
 open files
 virtual address space (code and data segments).
 child processes
K. Salah
25
Operating Systems
Processes vs. Threads
K. Salah
26
Operating Systems
Single and Multithreaded Processes
K. Salah
27
Operating Systems
Single Threaded and Multithreaded Process Models
 Thread Control Block contains a
register image, thread priority and
thread state information.
K. Salah
28
Operating Systems
Benefits 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
 Since threads within the same process share memory and files,
they can communicate with each other without invoking the
kernel. However, it is necessary to synchronize the activities of
various threads so that they do not obtain inconsistent views of
the data.
K. Salah
29
Operating Systems
Example I: Web Browser
K. Salah
30
Operating Systems
Example II: Web Server
K. Salah
31
Operating Systems
Threads States
Three key states: running, ready, blocked
Generally, it does not make sense to have a suspend state for
threads.
 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
K. Salah
32
Operating Systems
User-Level Threads (ULT)
•
•
•
•
The kernel is not aware of the
existence of threads
All thread management is done by the
application by using a thread library
Thread switching does not require
kernel mode privileges (no mode
switch)
Scheduling is application specific
K. Salah
33
Operating Systems
Threads library
•
•
Contains code for:
– creating and destroying threads
– passing messages and data between threads
– scheduling thread execution
– saving and restoring thread contexts
Three primary thread libraries:
– POSIX Pthreads. The P stands for POSIX and run on unix, linux,
and MS Windows.
– Cthreads
– Win32 threads
– Java threads
K. Salah
34
Operating Systems
Kernel 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
but for the thread library that thread is still in the running state
So thread states are independent of process states
K. Salah
35
Operating Systems
Advantages and inconveniences of ULT
•
Advantages
– Thread switching does not involve
the kernel: no mode switching
 thread_yield()
– Strong sharing of data with little
blocking
 No need for shared memory
system calls
 Excel sheets share a lot other
than files
– Scheduling can be application
specific: choose the best algorithm.
 Run a garbage collection thread
at convenient points
– ULTs can run on any OS. Only needs
a thread library
 Portable
K. Salah
36
•
Inconveniences
– Most system calls are blocking
and the kernel blocks
processes. So all threads within
the process will be unable to run
– The kernel can only assign
processes to processors. Two
threads within the same process
cannot run simultaneously on
two processors
For theads that run for too long (1 sec),
preemption is done using signals or alarms (e.g.,
ualarm). However this requires a lot more
overhead in switching. Signal delivery by kernel
to process is very complex. Kernel checks for
signal at termination of phase interrupts, if one is
pending:
save context of process,
K-U to handle signal,
U-K to restore context of process,
K-U to resume process.
Operating Systems
Improving blocking with ULT -- Advanced
•
•
•
Use nonblocking I/O system calls
– Returns quickly without need to complete the full I/O
operation
Use asynchronous I/O system calls
– Setup a callback function and returns quick
– When I/O is completed a function is called (part of signal
handling)
Identify blocking system calls, and place a jacket or wrapper
around them
– Needs to modify API or system call library
– If we know it will block, defer the thread and let other
threads run first
K. Salah
37
Operating Systems
Kernel-Level Threads (KLT)
•
•
•
•
•
•
All thread management is done by kernel
No thread library but an API (I.e. system
calls) to the kernel thread facility
Kernel maintains context information for
the process and the threads
Switching between threads requires the
kernel
Scheduling on a thread basis
Examples
– Windows XP/2000
– Solaris
– Linux
– Tru64 UNIX
– Mac OS X
K. Salah
38
Operating Systems
Kernel Multithreading Models
•
Many-to-One
•
One-to-One
•
Many-to-Many
K. Salah
39
Operating Systems
Advantages 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
K. Salah
40
•
Inconveniences
– thread switching within the
same process involves the
kernel. We have 2 mode
switches per thread switch:
user to kernel and kernel to
user.
– this results in a significant
slow down due to:
 Interrupt overhead due to
mode switch
 Updates to TCB info
 Cache pollution and
flushing to Process tables
and page tables
Operating Systems
Combined 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
Examples:
– Solaris prior to version 9
– Windows NT/2000 with the
ThreadFiber package
K. Salah
41
Operating Systems
Solaris: 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
– Excel sheet (sheet1, sheet2, etc)
– Power point
– Word processor
It is wise to have 2 KLTs under this situation. So if one window is blocked when
making a system call, use the other KLT to run the other selected window). If
the windows are doing a lot of blocking, use more KLTs.
– Reason is efficiency
 ULTs can be created, blocked, destroyed, without involving
the kernel
 Efficiency in terms of memory and data structure allocated in
kernel space
 Minimizing cache pollution and flushing
•
If threads may block then we can specify two or more LWPs (or KLTs)
to avoid blocking the whole application
K. Salah
42
Operating Systems
Further Readings
•
•
•
•
•
What is the difference between RPC and RMI?
What is meant by marshalling parameters?
What is the idea behind a thread pool?
What is hyperthreading?
Answer this:
– If you have CPU –bound application, when does it make sense to
use ULTs for them as opposed to KLTs?
 Example is a parallel array computation where you divide the
rows of its arrays among different threads
– Answer:
 use ULTs to minimize switching with uniprocessor
 Use KLTs for more concurrency with SMP
K. Salah
43
Operating Systems