Threads, SMP, and Microkernels

Chapter 4

2

Outline

Threads Symmetric Multiprocessing (SMP) Microkernel Linux Threads

3

Process Characteristics Unit of resource ownership - process is

allocated: a virtual address space to hold the process

image control of some resources (files, I/O devices...)

Unit of scheduling/execution - process is an execution path through one or more programs execution may be interleaved with other

process(es) the process has an execution state and a

dispatching priority

4

Process Characteristics – New Concept These 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

5

Multithreading 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 supports a single user process and a single thread

Traditional UNIX supports multiple user processes but only supports one thread per process

Solaris supports multiple threads

6

Threads and Processes

7

Processes Have a virtual address space which holds

the process image Protected access to processors, other

processes, files, and I/O resources Have process-specific context

ID State Other attributes

8

Threads What properties do threads have? Have an execution state (running, ready,

etc.) Save thread context when not running Have an execution stack and some per-

thread static storage for local variables Have 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 open with one thread, is available to others

9

Single Threaded and Multithreaded Process Models

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

10

Benefits of Threads vs ProcessesTake less time to: create a new thread than a process terminate a thread than a process switch between two threads within the

same process communicate with each other (via shared

resources) without invoking the kernel

11

Thread use in a Single-User System

Foreground and background work Asynchronous processing Speed of execution Modular program structure

12

Applications of Threads Example: a file server on a LAN It needs to handle several file requests

over a short period Hence more efficient to create (and

destroy) a single thread for each request On a SMP machine: multiple threads can

possibly be executing simultaneously on different processors

Example 2: one thread displays menu and reads user input while the other thread executes user commands

13

Application 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) Thread switching is faster than process

switching

14

Benefits and Challenges of Threads

Since threads within the same process share memory and files, they can communicate with each other without invoking the kernel

Therefore necessary to synchronize the activities of various threads so that they do not obtain inconsistent views of the data (to be discussed later)

15

Example of inconsistent view 3 variables: A, B, C which are shared by thread T1 and

thread T2 T1 computes C = A+B T2 transfers amount X from A to B, e.g.,

T2 must do: A = A -X and B = B+X What are the possible execution scenarios? If T1 computes A+B after T2 has done A = A-X but

before B = B+X T1 will not obtain the correct result for C = A + B

Programmer’s responsibility to ensure program correctness Race conditions could be difficult to identify and debug

16

Threads States and Actions

Three key states: running, ready, blocked Several actions that affect all of the threads in a

process The OS must manage these at the process level.

They have no suspend state because all threads within the same process share the same address space

Suspending (i.e., swapping) a single thread involves suspending all threads of the same process (logically)

Termination of a process, terminates all threads within the process

17

Thread Operations

Operations associated with a change in thread state Spawn (create another thread) Block

Issue: will blocking a thread block other, or all, threads

Unblock Finish (thread)

Deallocate register context and stacks

18

Example: Remote Procedure Call

Consider: A program that performs two remote procedure

calls (RPCs) to two different hosts to obtain a combined result.

19

RPCUsing Single Thread

20

RPC Using One Thread per Server

21

Multithreading on a Uniprocessor

22

Adobe PageMaker

23

Categories of Thread Implementation

User Level Thread (ULT)

Kernel level Thread (KLT) also called: kernel-supported threads lightweight processes.

24

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 switching)

Scheduling is application specific

25

Threads library

Contains code for: creating and destroying threads passing messages and data between threads scheduling thread execution saving and restoring thread contexts

26

Relationships between ULTThread and Process Scheduling and States

27

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

28

Advantages 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 Many 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.

29

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 on a thread basis

Ex: Windows NT and OS/2

30

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

Inconveniences thread switching within

the same process involves the kernel. We have 2 mode switches per thread switch

this results in a slow down

31

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

Example is Solaris NOTE: modern threads

are “smart”

32

Thread and Process Operation Latencies: an ExampleOperation User-Level

ThreadsKernel-Level Threads

Processes

Null Fork 34 948 11,300

Signal-Wait 37 441 1,840

Review Quiz 4-1True or False?

1. Processes generally are faster than threads, because processes have all the resources.

2. Thread switching for user-level threads generally are faster than that of kernel-level threads.

3. Threads generally are more reliable than processes.Which of the following programs could be higher

performance using multiple threads?Program 1 …

read message 1 from server A; // blocking callread message 2 from server B; // blocking call compare message 1 and message 2….33

Review Quiz 4-1Program 2:

…. for (i = 0; i < 1000000; i++) {

list [i] = i; }

Program 3: … for (i = 1; i < 1000000; i++) {

list [i] = list [i – 1] + i; }

34

35

Outline

Threads Symmetric Multiprocessing (SMP) Microkernel Linux

36

Traditional View

Traditionally, the computer has been viewed as a sequential machine. A processor executes instructions one at a time in

sequence Each instruction is a sequence of operations

Two popular approaches to providing parallelism Symmetric MultiProcessors (SMPs) Clusters (ch 16)

37

Categories of Computer Systems Based on Instruction and data streams:

Single Instruction Single Data (SISD) stream Single processor executes a single instruction

stream to operate on data stored in a single memory

Single Instruction Multiple Data (SIMD) stream Each instruction (same instruction) is executed

on a different set of data by the different processors

38

Categories of Computer Systems

• Multiple Instruction Single Data (MISD) stream (Never implemented) A sequence of data is transmitted to a set of

processors, each of execute a different instruction sequence

Multiple Instruction Multiple Data (MIMD) A set of processors simultaneously execute different

instruction sequences on different data sets

39

Parallel Processor Architectures

40

Symmetric Multiprocessing Kernel can execute on any processor

Allowing portions of the kernel to execute in parallel

Typically each processor does self-scheduling from the pool of available process or threads

41

Typical SMP Organization

42

Multiprocessor OS Design Considerations

The key design issues include Simultaneous and concurrent processes or

threads Scheduling Synchronization Memory Management Reliability and Fault Tolerance

43

Windows SMP Support

Threads can run on any processor But an application can restrict affinity

Soft Affinity The dispatcher tries to assign a ready thread to the

same processor it last ran on. Why? This helps reuse data still in that processor’s memory

caches from the previous execution of the thread. Hard Affinity

An application restricts threads to certain processor

44

Outline

Threads Symmetric Multiprocessing (SMP) Microkernel Linux

45

Microkernel

A microkernel is a small OS core that provides the foundation for modular extensions.

Big question is how small must a kernel be to qualify as a microkernel Must drivers be in user space?

In theory, this approach provides a high degree of flexibility and modularity.

46

Kernel Architecture

47

Microkernel Design: Memory Management

Low-level memory management - Mapping each virtual page to a physical page frame Most memory management tasks occur in user

space

48

Microkernel Design:Interprocess Communication

Communication between processes or threads in a microkernel OS is via messages.

A message includes: A header that identifies the sending and

receiving process and A body that contains direct data, a pointer to a

block of data, or some control information about the process.

49

Microkernal Design:I/O and interrupt management

Within a microkernel it is possible to handle hardware interrupts as messages and to include I/O ports in address spaces. a particular user-level process is assigned to the

interrupt and the kernel maintains the mapping.

50

Benefits of aMicrokernel Organization

Uniform interfaces on requests made by a process.

Extensibility Flexibility Portability Reliability Distributed System Support Object Oriented Operating Systems

51

Outline

Threads Symmetric Multiprocessing (SMP) Microkernel Linux

52

Different Approaches to Processes

Differences between different OS’s support of processes include How processes are named Whether threads are provided How processes are represented How process resources are protected What mechanisms are used for inter-process

communication and synchronization How processes are related to each other

53

Linux Tasks

A process, or task, in Linux is represented by a task_struct data structure

This contains a number of categories including: State Scheduling information Identifiers Interprocess communication And others

54

Linux Process/Thread Model

55

Linux Threads

Traditional Unix: single thread Modern Unix: KLTs Linux: ULTs pthread (POSIX thread) libraries ULTs belonging to the same process are

mapped into kernel-level processes that share the same group ID.

Shared ID is used for resource sharing and to avoid context switching