Download Threads, SMP, and Microkernels

Threads, SMP, and Microkernels
Chapter 4
1
2
Multithreading
• Operating system supports multiple
threads of execution within a single
process
• MS-DOS supports a single thread
• UNIX supports multiple user processes
but only supports one thread per process
• Windows, Solaris, Linux, Mach, and
OS/2 support multiple threads
3
4
Process
• Resource ownership - process includes a
virtual address space to hold the process
image and access to I/O
• Scheduling/execution- follows an
execution path that may be interleaved
with other processes
• These two characteristics are treated
independently by the operating system
5
Process
• Dispatching is referred to as a thread or
lightweight process
• Resource of ownership is referred to as a
process or task
6
Thread
•
•
•
•
An execution state (running, ready, etc.)
Saved thread context when not running
Has an execution stack
Some per-thread static storage for local
variables
• Access to the memory and resources of
its process
– all threads of a process share this
7
User-Level Threads
8
User-Level Threads
• All thread management is done by the
application
• The kernel is not aware of the existence
of threads
• I/O requests causes the whole process to
be blocked.
9
Kernel-Level Threads
10
Kernel-Level Threads
• Windows is an example of this approach
• Kernel maintains context information for
the process and the threads
• Scheduling is done on a thread basis
• I/O requests only cause the affect thread
to be blocked.
11
VAX Running UNIX-Like
Operating System
12
Combined Approaches
13
Combined Approaches
• Example is Solaris
• Thread creation done in the user space
and kernel space
• Bulk of scheduling and synchronization
of threads within application in both
kernel and user space
• Communication between threads can be
done in kernel or user space.
14
Benefits of Threads
• Takes less time to create a new thread than a
process
• Less time to terminate a thread than a process
• 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
15
Uses of Threads in a SingleUser Multiprocessing System
• Foreground to background work –
Managing different processes with
different levels of priority.
• Asynchronous processing – Threads
that can execute without care of what the
other threads are doing.
• Speed of execution – Faster to swap out
threads than processes.
16
Threads - Review
• Suspending a process involves
suspending all threads of the process
since all threads share the same address
space
• Termination of a process, terminates all
threads within the process
17
Thread States
• States associated with a change in thread
state
– Spawn
• Spawn another thread
– Block/Unblock
– Ready/Running
– Finish
• Deallocate register context and stacks
18
19
Processor Architectures
20
Categories of Computer
Systems
• 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 is executed on a different
set of data by the different processors
21
Categories of Computer
Systems
• Multiple Instruction Single Data (MISD)
stream
– 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
22
23
Symmetric Multiprocessing
(MIMD)
• Kernel can execute on any processor
• Typically each processor does selfscheduling form the pool of available
process or threads
24
25
Symmetric Multiprocessing
(MIMD)
• What new issues might we have to deal
with?
– Having to worry about proper sharing of
Memory
– Two processes executing the same code
either on purpose or by accident
– The Kernel can be running on multiple
processors at the same time.
26
Multiprocessor Operating
System Design Considerations
• Simultaneous concurrent processes or
threads
• Scheduling
• Synchronization
• Memory management
• Reliability and fault tolerance
27
Microkernels
28
Microkernels
• Small operating system core
• Contains only essential core operating systems
functions
• Many services traditionally included in the
operating system are now external subsystems
–
–
–
–
–
Device drivers
File systems
Virtual memory manager
Windowing system
Security services
29
30
Benefits of a Microkernel
Organization
• Uniform interface on request made by a
process
– Don’t distinguish between kernel-level and userlevel services (Where are all the services?)
– All services are provided by means of message
passing
• Extensibility
– Allows the addition of new services
• Flexibility
– New features added
– Existing features can be subtracted
31
Benefits of a Microkernel
Organization
• Portability
– Changes needed to port the system to a new
processor is changed in the microkernel not in the other services
• Reliability
– Modular design
– Small microkernel can be rigorously tested
32
Benefits of Microkernel
Organization
• Distributed system support
– Message are sent without knowing what the
target machine is
• Object-oriented operating system
– Components are objects with clearly
defined interfaces that can be
interconnected to form software
33
Microkernel Design
• Low-level memory management
– Mapping each virtual page to a physical page frame
(Kernel)
– Memory protection and allocation (User-Level)
34
Microkernel
• Supporting External Paging and Virtual
Memory Management:
– Grant : A User-Level process can
grant/assign memory to another process.
– Map : Placing one or more pages of
memory in overlapping space.
– Flush : The granter process can reclaim any
memory.
35
Microkernel Design
• Interprocess communication
– Uses messages that contains a header and a
body.
• I/O and interrupt management
– Interrupts recognized by the kernel, but
handed off to a user-level process.
36
Closer Look at Windows and
Solaris
37
Windows Processes
• Implemented as objects
• An executable process may contain one
or more threads
• Both processes and thread objects have
built-in synchronization capabilities
• Threads and Processes run in kernel
mode
38
39
Solaris
• User-level and Kernel-level Threads
• Process includes the user’s address
space, stack, and process control block
– Accessible by the Kernel Threads
• Lightweight processes (LWP)
– Shadow of the Process that allows the UserLevel threads to function without making
direct calls to the Kernel threads.
40
41
Windows 2000
Thread States
42
43
End
44
Remote Procedure Call Using
Single Thread
45
Remote Procedure Call Using
Threads
46
Multithreading
47
Adobe PageMaker
48
49
50
51
Closer Look at Solaris
52
Solaris Lightweight Data
Structure
•
•
•
•
•
•
•
•
Identifier
Priority
Signal mask
Saved values of user-level registers
Kernel stack
Resource usage and profiling data
Pointer to the corresponding kernel thread
Pointer to the process structure
53
54
Linux Task Data Structure
•
•
•
•
•
•
•
•
•
State
Scheduling information
Identifiers
Interprocess communication
Links
Times and timers
File system
Address space
Processor-specific context
55
56
Linux States of a Process
•
•
•
•
•
Running
Interruptable
Uninterruptable
Stopped
Zombie
57