Module 2 0 processes and threads
1 / 43

Module 2.0: Processes and Threads - PowerPoint PPT Presentation

  • Uploaded on

Module 2.0: Processes and Threads. Process Concept Trace of Processes Process Context Context Switching Threads ULT KLT. Process. Also called a task. Useful and Important Concept: Process = program in execution

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Module 2.0: Processes and Threads' - chione

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Module 2 0 processes and threads
Module 2.0: Processes and Threads

  • Process Concept

  • Trace of Processes

  • Process Context

  • Context Switching

  • Threads

    • ULT

    • KLT

K. Salah


  • 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

Program creation
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

Process creation and termination
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

Two types
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


If parent chooses to wait until the child executes (but not always the case).

K. Salah

Multiprogramming timesharing 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

Multiprogramming multiple processes
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

Process context
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

The process control block pcb
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

Pcb cont
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

Process states transitions
Process States & Transitions

Zooming in

  • Running

    • User-running

    • Kernel-running

  • Ready

    • Ready, suspend

    • Ready

  • Waiting (or blocked)

    • Blocked

    • Blocked, suspend

Suspend may swap out all or part of the process. Shared regions/segments are not suspended.

K. Salah

When to context switch
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

Mechanics of a context switch
Mechanics of a Context Switch

  • copy contents of CPU registers (general-purpose, SP, PC, PSW, etc.) into a save area in the PCB of running process

  • change status of running process from “running” to “waiting” (or “ready”)

  • change a system variable running-process to point to the PCB of new process to run

  • 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

    Multiprogramming through context switching

    K. Salah

    Process creation
    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

    C program forking separate process
    C Program Forking Separate Process

    int main()


    Pid_t pid;

    /* fork another process */

    pid = fork();

    if (pid < 0) { /* error occurred */

    fprintf(stderr, "Fork Failed");



    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");




    K. Salah

    Introduction to threads
    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

    Processes and threads
    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

    Single threaded and multithreaded process models
    Single Threaded and Multithreaded Process Models

    • Thread Control Block contains a register image, thread priority and thread state information.

    K. Salah

    Benefits of threads vs processes
    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

    Threads states
    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

    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 by using a thread library

    • Thread switching does not require kernel mode privileges (no mode switch)

    • Scheduling is application specific

    K. Salah

    Threads library
    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

    Kernel activity for ults
    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

    Advantages and inconveniences of ult


    Thread switching does not involve the kernel: no mode switching


    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



    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

    Advantages and inconveniences of ULT

    K. Salah

    Improving blocking with ult advanced
    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

    Kernel level threads klt
    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

    Kernel multithreading models
    Kernel Multithreading Models

    • Many-to-One

    • One-to-One

    • Many-to-Many

    K. Salah

    Advantages and inconveniences of klt


    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


    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

    Advantages and inconveniences of KLT

    K. Salah

    Combined ult klt approaches
    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

    Module 2 0 processes and threads

    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

    Further readings
    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