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 perthread 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

Single Threaded and Multithreaded
Process Models
9
Thread Control Block contains a register image, thread priority and thread state information

10
Benefits of Threads vs Processes
Take 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)

Example of inconsistent view
15






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
RPC
Using 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 ULT
Thread 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 Example
Processes Operation User-Level
Threads
Kernel-
Level
Threads
Null Fork 34 948 11,300
Signal-Wait 37 441 1,840

Review Quiz 4-1
True or False?
1.
2.
3.
Processes generally are faster than threads, because processes have all the resources.
Thread switching for user-level threads generally are faster than that of kernel-level threads.
Threads generally are more reliable than processes.
33
Which of the following programs could be higher performance using multiple threads?
Program 1 … read message 1 from server A; // blocking call read message 2 from server B; // blocking call compare message 1 and message 2
….

Review Quiz 4-1
Program 2:
….
} for (i = 0; i < 1000000; i++) { list [i] = i;
34
Program 3:
…
} for (i = 1; i < 1000000; i++) { list [i] = list [i – 1] + i;

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 selfscheduling 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 a
Microkernel 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