Download 3 Threads SMP Microkernel

Threads, SMP, and Microkernels
1
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
2
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
CS-550: Threads, SMP, and Microkernels
3
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
6
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
7
Thread States and Operations
• Thread states:
– 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
8
Remote Procedure Call Using Threads
CS-550: Threads, SMP, and Microkernels
9
Remote Procedure Call Using Threads (Cont.)
CS-550: Threads, SMP, and Microkernels
10
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
11
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
12
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
13
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
14
Relationship Between Threads and Processes
Threads:Process
1:1
M:1
1:M
M:M
Description
Each thread of execution is a
unique process with its own
address space and resources.
Example Systems
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
A thread may migrate from one
process environment to another.
This allows a thread to be easily
moved among distinct systems.
Ra (Clouds), Emerald
Combines attributes of M:1 and
1:M cases
CS-550: Threads, SMP, and Microkernels
TRIX
16
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
17
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
19
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
21
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
22
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
23
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
24
W2K Process Object
CS-550: Threads, SMP, and Microkernels
26
W2K Thread Object
CS-550: Threads, SMP, and Microkernels
27
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
28
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
30
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
31
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
35