computer notes - Real time operating systems and microkernels
1 Threads, SMP, and Microkernels Chapter 4. 2 Focus and Subtopics Focus: More advanced concepts...
-
Upload
mary-greene -
Category
Documents
-
view
219 -
download
2
Transcript of 1 Threads, SMP, and Microkernels Chapter 4. 2 Focus and Subtopics Focus: More advanced concepts...
1
Threads, SMP, and Microkernels
Chapter 4
2
Focus and Subtopics
Focus: More advanced concepts related to process management : Resource ownership vs execution
Processes and threads Symmetric Multiprocessing Microkernels Discussions on threads for contemporary OS
Windows Solaris Linux
3
Characteristics that embody a Process Resource ownership - process includes a
virtual address space to hold the process image. Process are allocated resources from time to time.
Scheduling/execution- Process execution follows an execution path that may be interleaved with other processes
These two characteristics are treated independently by the operating system
4
Process
Dispatching is referred to as a thread or lightweight process
Resource of ownership is referred to as a process or task
5
Multithreading
The ability of an OS to support multiple threads of execution
There are 4 different approaches to usage of threads. One Process, one thread of execution (thread as
an entity is not recognize – thread of execution is within process)
One Process, multiple threads Multiple Process, one thread per process Multiple Process, multiple threads.
6
Multithreading
Most operating systems support multiple threads of execution within a single process: MS-DOS only supports a single thread Java runtime environment is a one process
environment which supports multiple threads. UNIX supports multiple user processes but only
supports one thread per process Windows, Solaris, Linux, Mach, and OS/2 support
multiple threads per process
7
MSDOSJava Virtual Environment
UNIX
Windows, Solaris,
Mach, OS/2
8
A Process within multithreaded environment Have a virtual address space which holds the
process image Protected access to
Processors other processes (interprocess communication) Files I/O resources (devices and channels)
9
Threads - within a process :
An execution state (running, ready, etc.) A saved thread context when not running
(can view it as an independent program counter within a process)
Has an execution stack Some per-thread static storage for local
variables Access to the memory and resources of its
process, shared by all threads of a process.
10
Code/Text
Data
Code/Text and Data (share by all threads)
Thread1 Thread2 Thread3
Single Thread vs multiple threads
No thread
One process, Multiple threads
• Thread keeps different PCs because they are running different parts of the code in the process
• All threads share state and resources of the process
11
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
12
Example benefits of usage of threads An application have multiple functionality:
Use threads for each functionality – better than a single process with many functionality
A file server: Each new file request means a thread is created
for file management for each request Many threads can be created and destroyed. In multi CPU machine, a CPU can handle one
thread. Resources are shared
13
Example Uses of Threads
In a Single-User Multiprocessing System Foreground and background work:
Each thread perform a specific function Asynchronous processing:
Each asynchronous element implemented as thread – backup
Speed of execution: Simultaneous thread execution
Modular program structure: Easier to design
14
Actions that effect all threads
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
15
Thread Functionality
Thread States: Threads have execution states like process
Thread Synchronization Threads may need to synchronize with one
another
16
Thread States Key States for thread
Running Ready Blocked
What about Suspend? Does not make sense. This is a process concept. If a process is swapped out, all its threads are also swapped out.
Basic thread operations associated with a change in thread state Spawn
A spawned process with threads also spawn a process with threads Block
A thread that is waiting for an event is blocked, allowing OS to pick up another thread to run.
Unblock When a thread that is waiting for an event had the event occurs, it is
unblocked and moved to ready queue. Finish
When a thread completes, OS deallocate its register context and stacks
17
Remote Procedure Call Using Process (Single Thread of execution)
18
Benefit of threads:Remote Procedure Call Using 2 Threads
19
Benefit of threads:Multithreading
20
Thread Synchronization
Threads share same address space (Code, data etc)
If a thread alter something in the address space, it will effect other threads.
Thus the need to synchronize activities of various threads
Issues in process synchronization is the same in thread synchronization
21
Example use of thread inAdobe PageMaker• Writing, design, production for desktop
publishing
• Thread structure for Adobe Pagemaker in OS/2 operating System
• Three active threads:
• Event-handling
• Screen-redraw
• Service
• Each thread perform certain functions
• For synchronization between threads, the software use message passing.
22
Threads Implementation
User Level threads (ULT) Kernel-level threads (KLT)
or kernel supported threads or lightweight processes
23
User-Level Threads
All thread management is done by the application
The kernel is not aware of the existence of threads
Application can use thread library to Create thread Destroy thread Message passing between
thread Save/restore thread context
etc.
Process
(a) Pure User-level
24
User-Level Threads
All the above takes place within the process, within user address space. As far as the kernel is concerned, it is scheduling a process .
An application (a process) can start with a single thread, at any time another thread can be spawned using the utility in the thread library. Thread library is responsible to create approriate thread data structure for the new thread, pass control to ready thread in the process.
25
User-Level Threads
26
Process B Running
Thread 2 Running
Process B Blocked
Thread 2 percieved as running
Process B Ready
Thread 2 percieved as running
Process B Running Again
Thread 1 runningThread 2 blocked
27
Kernel-Level Threads Windows is an example of this
approach Kernel maintains context
information for the process and the threads
In this case, thread is managed by the OS kernel. There is no kernel management code in the application itself.
Scheduling is done on a thread basis ie: kernel schedule thread as well as process.
Process
28
Kernel-Level Threads
29
User Level thread vs Kernel Level Thread : Advantages and disadvantages
User Level Thread Kernel Level Thread
Advantages thread switching does not require switching to kernel mode.
scheduling is based on application
program of this type can run on any OS.
kernel can schedule multiple thread from the same process on different processor.
if a thread is blocked, kernel can schedule another thread of the same process.
kernel routine itself can be multithreaded.
Disdvantages a system call cause all thread in the process to be blocked.
the whole process is assigned to one processor, thus threads executes alternately.
switching thread require mode switch to kernel mode. This means it is slower due to overheads..
30
Comparing ULT, KLT and Processes
Time to create, schedule, execute and complete in microseconds
Comparison in VAX Running UNIX-Like OS
31
Combined Approaches
Example is Solaris thread creation is done in user
space scheduling and synchronization
in user space multiple ULT combined into a
number of KLT multiple threads within the same
application can run on multiple processors.
a thread that make a system call can be blocked, but the whole process cannot be blocked.
32
Relationship Between Threads and Processes
33
Other Thread Implementations Multiple process Multiple threads :
multiple processes running and each process have many threads. The threads can move from one process to another process.
There is one OS using this implementation, called TRIX. TRIX uses concepts of domain and threads.
Domain consists of address space and ports which messages can be sent and received between domain.
A thread is as the normal definition. Multiple threads can be executing in a single domain. But a thread from a domain can also execute in another domain. Thus the multiple domain multiple thread.
Kernel manages different address space related to the domain independently. There is no overhead in process creation when moving thread from one domain to another.
Multiple process Single threads : Here a thread can move among processes addresses spaces. An
OS called clouds is using this method. The kernel of clouds is called Ra. The processes can also be on different machines.
34
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
35
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
36
37
Symmetric Multiprocessing
Kernel can execute on any processor Typically each processor does self-
scheduling form the pool of available process or threads
38
39
Multiprocessor Operating System Design Considerations Simultaneous concurrent processes or
threads Scheduling Synchronization Memory management Reliability and fault tolerance
40
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
41
42
Benefits of a Microkernel Organization Uniform interface on request made by a process
Don’t distinguish between kernel-level and user-level 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
43
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
44
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
45
Microkernel Design – Functions to include in Kernel Low-level memory management Interprocess communication I/O and interrupt management
46
Microkernel Design - Function1. Low-level memory management
Mapping each virtual page to a physical page frame
47
Microkernel Design
2. Interprocess communication Using Message –> header + body Port –> queue of messages
3. I/O and interrupt management Handle hardware interrupt using messages Microkernel recognizes interrupt, generate
messages for user-level processes to cater foir the interrupt.
48
How OS Processes are supported How processes are named Are threads being used How are process represented How are process protected How IPC and synchronization are done How processes are related to each other
49
Microsoft Windows Processes Implemented as objects An executable process may contain one or
more threads Both processes and thread objects have
built-in synchronization capabilities
50
51
Windows Process Object
52
Windows Thread Object
53
Windows 2000Thread States Ready Standby Running Waiting Transition Terminated
54
55
Solaris
Process includes the user’s address space, stack, and process control block
User-level threads Lightweight processes (LWP) Kernel threads
56
57
58
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
59
60
Linux Task Data Structure
State Scheduling information Identifiers Interprocess communication Links Times and timers File system Address space Processor-specific context
61
Linux States of a Process
Running Interruptable Uninterruptable Stopped Zombie
62