Operating systems
Sponsored Links
This presentation is the property of its rightful owner.
1 / 30

Operating Systems PowerPoint PPT Presentation

  • Uploaded on
  • Presentation posted in: General

Operating Systems. Threads. Overview Multithreading Models Threading Issues. Overview. A thread is a basic unit of CPU utilization A traditional (or heavyweight) process has a single thread of control Single-threaded applications Simple implementations e.g. assignments

Download Presentation

Operating Systems

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

Operating Systems

NUST Institute of Information Technology, Pakistanhttp://www.niit.edu.pk


  • Overview

  • Multithreading Models

  • Threading Issues


  • A thread is a basic unit of CPU utilization

  • A traditional (or heavyweight) process has a single thread of control

  • Single-threaded applications

    • Simple implementations e.g. assignments

  • Multi-threaded applications

    • Web browser

    • Web server

Single and Multithreaded Processes


Program counter



Relationship between threads and processes

  • The operating system creates a process for the purpose of running a program.

    • Every process has at least one thread.

      • On some operating systems, a process can have more than one thread.

    • Some programs like word processors are designed to have only one instance of themselves running at the same time.

      • Sometimes, such programs just open up more windows to accommodate multiple simultaneous use.

      • After all, you can go back and forth between five documents, but you can only edit one of them at a given instance.

    • Command line interpreters and multiple users ~ processes

      • Access rights

      • Protection of other users from failures

    • Graphical User Interface ~ threads

      • Multiple aspects at one instance, user input and painting

Processes and Threads

  • The concept of a process and thread are interrelated by a sense of ownership and of containment

  • Process

    • A process is the "heaviest" unit of kernel scheduling

    • Processes own resources allocated by the operating system

      • Resources include memory,

      • file handles,

      • sockets,

      • device handles, and user interfaces.

    • Processes do not share address spaces or file resources except through explicit methods

    • Processes are typically pre-emptively multitasked.

      • However, Windows 3.1 and older versions of Mac OS used co-operative or non-preemptive multitasking.

Processes and Threads

  • Thread

    • A thread is the "lightest" unit of kernel scheduling.

    • At least one thread exists within each process.

    • If multiple threads can exist within a process, then they share the same memory and file resources.

    • Threads are pre-emptively multitasked if the operating system's process scheduler is pre-emptive.

    • Threads do not own resources except for a stack and a copy of the registers including the program counter.


  • Responsiveness

    • blocking and non-blocking requests

  • Resource Sharing

    • same address space

  • Economy

    • Allocating resources to processes as compared to sharing resources via threads

  • Utilization of MP Architectures

    • Multi-threaded applications can utilize multiprocessor platforms by enhancing concurrency

Multi-threading and reality

  • In an ideal world, five processors would do five times the work of one processor

  • But we live in a world of contention for shared resources, of disk and memory bottlenecks, single-threaded applications, multithreaded applications that require synchronous processing, and poorly coordinated processors

Kernel threads

User level threads

Types of threads

NUST Institute of Information Technology, Pakistanhttp://www.niit.edu.pk

Kernel threads

  • A kernel thread is a kernel entity, like processes and interrupt handlers

  • It is the entity handled by the system scheduler.

  • Kernel threads consist of a set of registers, a stack, and a few corresponding kernel data structures.

    • The user structure contains process-related information

    • The uthread structure contains thread-related information.

  • Unlike processes, all threads within a process share the same address space.

  • Similar to processes, when a kernel thread makes a blocking call, only that thread blocks.

  • All modern machines support kernel threads, most often via the POSIX threads interface ``pthreads''.

    • Some dedicated parallel machines support kernel threads poorly or not at all. For example, the Blue Gene/L microkernel does not support pthreads.

Kernel threads

  • The advantage of kernel threads over processes is faster creation and context switching compared with processes.

  • Parallel programming

  • Kernel threads cannot be accessed from the user mode environment, except through the threads library.

Kernel Threads

  • Supported by the Kernel

  • Examples

    • Windows XP/2000

    • Solaris

    • Linux

    • Tru64 UNIX

    • Mac OS X

User level threads

  • Like a kernel thread, a user-level thread includes a set of registers and a stack, and shares the entire address space with the other threads in the enclosing process

  • Unlike a kernel thread, however, a user-level thread is handled entirely in user code

  • OS is unaware of a user-level thread's existence

  • The primary advantages of user-level threads are efficiency and flexibility

    • Because the operating system is not involved, user-level threads can be made to use very little memory

    • User-level threads are also more flexible because the thread scheduler is in user code,

      • for example, the application's priority structure can be directly used by the thread scheduler

User level threads

  • The primary disadvantage of user-level threads compared to kernel threads is the lack of operating system support.

    • For example, when a user-level thread makes a blocking call, the kernel does not start running another user-level thread. Instead, the kernel suspends the entire calling kernel thread or process, even though another user-level thread might be ready to run.

User Threads

  • User threads are mapped to kernel threads by the threads library, in an implementation dependent manner.

    • The threads library uses a proprietary interface to handle kernel threads.

  • Three primary thread libraries:

    • POSIX Pthreads

    • Win32 threads

    • Java threads


NUST Institute of Information Technology, Pakistanhttp://www.niit.edu.pk

Multithreading Models

  • Many-to-One

  • One-to-One

  • Many-to-Many

Many user-level threads mapped to single kernel thread

Entire process will block if a thread makes a blocking call


Solaris Green Threads

GNU Portable Threads



  • Each user-level thread maps to kernel thread

  • Examples

    • Windows NT/XP/2000

    • Linux

    • Solaris 9 and later

Many-to-Many Model

  • Allows many user level threads to be mapped to many kernel threads

  • Allows the operating system to create a sufficient number of kernel threads

  • Solaris prior to version 9

  • Windows NT/2000 with the ThreadFiber package

Many-to-Many Model

Two-level Model

  • Similar to M:M, except that it allows a user thread to be bound to kernel thread

  • Examples

    • IRIX

    • HP-UX

    • Tru64 UNIX

    • Solaris 8 and earlier

Two-level Model

Threading Issues

  • Semantics of fork() and exec() system calls

  • Thread cancellation

  • Signal handling

  • Thread pools

  • Thread specific data

  • Scheduler activations

Semantics of fork() and exec()

  • Does fork() duplicate only the calling thread or all threads?

Thread Cancellation

  • Terminating a thread before it has finished

    • E.g. Multiple threads searching in a DB, if one thread finds the result, cancel the others

  • Two general approaches:

    • Asynchronous cancellation terminates the target thread immediately

      • Cancellation during data update ~ consistency issues

    • Deferred cancellation allows the target thread to periodically check if it should be cancelled

      • Cancellation points

Signal Handling

  • Signals are used in UNIX systems to notify a process that a particular event has occurred

    • Synchronous ~ same process, divide by zero

    • Asynchronous ~ external event, terminate process

  • A signal handler is used to process signals

    • Signal is generated by particular event

    • Signal is delivered to a process

    • Signal is handled

  • Handlers

    • Default

    • User defined

  • Options

    • Deliver the signal to the thread to which the signal applies

    • Deliver the signal to every thread in the process

    • Deliver the signal to certain threads in the process

    • Assign a specific thread to receive all signals for the process

Thread Pools

  • Create a number of threads in a pool where they await work

    • Web server

  • Advantages:

    • Usually slightly faster to service a request with an existing thread than create a new thread

    • Allows the number of threads in the application(s) to be bound to the size of the pool

Recommended Reading:

Book ~ 143 - 146



Reading list @ http://www.niit.edu.pk/~umarkalim/courses/fall2006/os.html


NUST Institute of Information Technology, Pakistanhttp://www.niit.edu.pk

  • Login