1. Threads, SMP, and Microkernels

2. CS-550: Threads, SMP, and Microkernels
Processes vs. Threads
Traditional process characteristics:
Resource ownership
Has a virtual address space to hold the process image
Is allocated resources, as needed: I/O devices, files, etc.
Scheduling/execution
Follows an execution path through one or more programs
Has an execution state and a priority
Is the entity that is scheduled and dispatched by the OS
Modern OSs treat these characteristics independently
Unit of resource of ownership is referred to as a process or task
Unit of dispatching is referred to as a thread or lightweight process
CS-550: Threads, SMP, and Microkernels

3. CS-550: Threads, SMP, and Microkernels
Multithreading
The OS supports multiple threads of execution within a single process
A process in a multithreaded environment has:
A virtual address space that holds the process image
Protected access to processors, other processes, files, and I/O resources
Within a process, there may be one or more threads and each thread has:
A thread execution state (Running, Ready, etc.)
A saved thread context when not running
An execution stack
Per-thread static storage for local variables
Access to the memory and resources of its process, shared with other threads
Examples: W2K, Solaris, Linux, Mach, OS/2
MS-DOS supports a single thread
UNIX supports multiple user processes but only supports one thread per process
Windows 2000, Solaris, Linux, Mach, and OS/2 support multiple threads
CS-550: Threads, SMP, and Microkernels

6. Multithreading (Cont.)
Benefits of threads:
Takes less time to create a new thread in an existing process than a new process
Takes less time to terminate a thread than a process
Takes 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
Actions that affect all threads of a process
Suspending a process involves suspending all threads of the process (a suspended process is swapped out of main memory)
Termination of a process, terminates all threads within the process
CS-550: Threads, SMP, and Microkernels

7. Examples of use of Threads in a Single-User Multiprocessing System
Foreground and background work
Example: spreadsheet program
One thread displays menus and reads user input
Other thread executes user commands and updates spreadsheet
Asynchronous processing
Example: word processor that saves to disk once every minute
A second thread does periodic backups
Speed execution
Example:
One thread computes one batch of data
Other thread reads next batch from a device
Modular program structure
Example: programs that use a variety of sources and destinations
CS-550: Threads, SMP, and Microkernels

8. Thread States and Operations
Running, Ready, and Blocked
Operations associated with a change in thread state
Spawn
Spawn a thread for a new process
A thread in an existing process spawns another thread
Block
Thread blocks waiting on an event
Unblock
Event occurred, thread is unblocked
Finish
Thread completes, deallocate register context and stacks
CS-550: Threads, SMP, and Microkernels

9. Remote Procedure Call Using Threads
CS-550: Threads, SMP, and Microkernels

10. Remote Procedure Call Using Threads (Cont.)
CS-550: Threads, SMP, and Microkernels

11. User-Level Threads (ULT)
All thread management is done by the application, the kernel is not aware of the existence of threads
An application is programmed by using a threads library, which contains code for:
Creating and destroying threads
Passing messages and data between the threads
Scheduling thread execution
Saving and restoring thread contexts
Operation:
Application starts as a single thread running within a process managed by kernel
Application spawns a new thread using Spawn in threads library
Threads library creates new thread and passes control to one of the threads in Ready state using some scheduling algorithm
CS-550: Threads, SMP, and Microkernels

12. User-Level Threads (Cont.)
Advantages of using User Level Threads instead of Kernel Level Threads
Thread switching does not require kernel mode privileges
Scheduling can be application specific
User Level Threads can run on any OS
Disadvantages of User Level Threads:
Many system calls are blocking: when a ULT executes a system call, all threads within the process are blocked
A multithreaded application cannot take advantage of multiprocessing: kernel assigns one processor to one process (I.e, all threads within that process)
CS-550: Threads, SMP, and Microkernels

13. Kernel-Level Threads (KLT)
In a pure Kernel-Level Thread implementation all thread management is done by the kernel
All the threads within an application are in a single process
Kernel maintains context information for the process and the threads
Scheduling is done on a thread basis
Advantages:
Kernel can simultaneously schedule multiple threads from the same process on multiple processors
If one thread is blocked, the kernel can schedule another thread of the same process
The kernel routines themselves can be multithreaded
Disadvantages:
Transfer of control between threads within same process requires switch to the kernel
Examples: W2K, Linux, and OS/2
CS-550: Threads, SMP, and Microkernels

14. CS-550: Threads, SMP, and Microkernels
Combined Approaches
Multiple ULTs from a single application are mapped onto some (smaller or equal) number of KLTs
Thread creation done in the user space
Most of scheduling and synchronization of threads within an application are done in the user space
Advantages:
Multiple threads within the same application can run in parallel on multiple processors
A blocking system call does not block the entire process
Example: Solaris
CS-550: Threads, SMP, and Microkernels

16. Relationship Between Threads and Processes
Threads:Process
Description
Example Systems
Each thread of execution is a
unique process with its own
address space and resources.
1:1
Traditional UNIX implementations
A process defines an address
space and dynamic resource
ownership. Multiple threads
may be created and executed
within that process.
Windows NT, Solaris, OS/2,
OS/390, MACH
M:1
1:M
A thread may migrate from one process environment to another. This allows a thread to be easily moved among distinct systems.
Ra (Clouds), Emerald
M:M
Combines attributes of M:1 and 1:M cases
TRIX
CS-550: Threads, SMP, and Microkernels

17. Symmetric MultiProcessing (SMP)
Categories of Computer Systems
Single Instruction Single Data (SISD)
Single processor executes a single instruction stream to operate on data stored in a single memory
Single Instruction Multiple Data (SIMD)
Each instruction is executed on a different set of data by the different processors
Multiple Instruction Single Data (MISD)
A sequence of data is transmitted to a set of processors, each of which executes a different instruction sequence. Never implemented
Multiple Instruction Multiple Data (MIMD)
A set of processors simultaneously execute different instruction sequences on different data sets
CS-550: Threads, SMP, and Microkernels

19. Symmetric MultiProcessing (Cont.)
OS implementation
Kernel can execute on any processor
Typically each processor does self-scheduling from the pool of available processes or threads
Kernel can be constructed as multiple processes or multiple threads that can execute in parallel
OS must prevent
Two processors choosing the same process
A process getting lost from the queue
CS-550: Threads, SMP, and Microkernels

21. Multiprocessor Operating System Design Issues
Simultaneous concurrent processes or threads
Several processors can execute the same kernel code simultaneously: kernel routines must be reentrant
Management of kernel tables must avoid deadlock
Scheduling
With scheduling done by each processor, kernel-level multithreading must avoid conflicts in scheduling multiple threads from the same process simultaneously
Synchronization
Mutual exclusion and event ordering must by provided for multiple active processes accessing shared memory and I/O
Memory Management
Paging on different processors must be coordinated when several processors share a page or segment and decide on page replacement
Reliability and Fault Tolerance
Graceful degradation in case of processor failure
CS-550: Threads, SMP, and Microkernels

22. CS-550: Threads, SMP, and Microkernels
Microkernel is a small operating system core containing only essential operating systems functions
All other OS services are implemented as server processes, execute in user mode, and communicate through messages (device drivers, file systems, virtual memory manager, windowing system, and security services)
The microkernel architecture replaces the traditional vertical layered architecture and leads to a client/server architecture within a single computer
Example:
An application opens a file by sending a message to the file system server, creates a process or thread by sending a message to the process server
Each of the servers can send messages to other servers (through the kernel) and can invoke the primitive operations in the kernel
CS-550: Threads, SMP, and Microkernels

23. Benefits of a Microkernel Organization
Uniform interface on requests made by a process
Both kernel-level and user-level services are provided by means of message passing
Extensibility
Allows the addition of new services and provision of multiple services in the same functional area
Flexibility
New features added, existing features can be subtracted
Portability
Most of the processor-specific code is in the microkernel
Reliability
A small microkernel can be rigorously tested
Distributed system support, including clusters controlled by a distributed operating system
The client/server architecture within a single computer maps easily into a distributed architecture
CS-550: Threads, SMP, and Microkernels

24. Windows 2000 (W2K) Thread and SMP Management
Process design driven by the need to provide support for a variety of operating system environments
Native process structures and services are relatively simple and general purpose, allowing each operating system subsystem to emulate a particular process structure and functionality
Process characteristics
Processes implemented as objects
An executable process may contain one or more threads
Both process and thread objects have built-in synchronization capabilities
CS-550: Threads, SMP, and Microkernels

26. CS-550: Threads, SMP, and Microkernels
W2K Process Object
CS-550: Threads, SMP, and Microkernels

27. CS-550: Threads, SMP, and Microkernels
W2K Thread Object
CS-550: Threads, SMP, and Microkernels

28. CS-550: Threads, SMP, and Microkernels
W2K Thread States
Ready:
May be scheduled for execution
Standby:
Has been selected to run on a particular processor and waits until processor is available
Running
Has been allocated a processor and is executing
Waiting
Blocked on an event or waits for synchronization purposes
Transition
Ready to run but resources not available
Terminated
Terminated by itself, by another thread, or when the parent process terminates
CS-550: Threads, SMP, and Microkernels

30. CS-550: Threads, SMP, and Microkernels
W2K SMP Support
The threads of any process, including those of the executive, can run on any processor
Microkernel assigns a ready thread to the next available processor, except for
Soft affinity: dispatcher tries to assign a ready thread to the same processor it last ran on
Hard affinity: application can restrict its thread execution to certain processors
Benefits
No processor is idle or is executing a lower-priority thread when a higher priority thread is ready
Multiple threads from the same process can be executing simultaneously on multiple processors
CS-550: Threads, SMP, and Microkernels

31. Solaris Thread Management
Four separate thread-related concepts:
Process:
Normal UNIX process, includes the user’s address space, stack, and process control block
User-Level Threads (ULTs)
Implemented through a threads library in the address space of a process
Invisible to the OS
Lightweight processes (LWPs)
A mapping between ULTs and kernel threads
Each LWP supports one or more ULTs and maps to one kernel thread
Scheduled by the kernel independently
May execute in parallel on multiprocessors
Kernel threads
Fundamental entities that can be scheduled and dispatched to run on one of the system processors
CS-550: Threads, SMP, and Microkernels

35. Linux Process and Thread Management
A process or task in Linux is represented by a task_struct data structure. It contains the following information about the process:
State: executing, ready, suspended, stopped, and zombie
Scheduling information: a process can be normal or real-time and has a priority
Identifiers: unique process identifier, and user and group identifiers
Interprocess communication: IPC mechanisms
Links: a link to its parent process, links to its siblings, and links to all its children
Times and timers: process creation time and the amount of processor time so far consumed by the process
File system: pointers to any files open by this process
Virtual memory: virtual memory assigned to this process
Processor-specific context: registers and stack information that represent the context of this process
CS-550: Threads, SMP, and Microkernels