System Architecture - ITEC-OS Start2).pdf · System Architecture 4 Activities © 2008 Universität...
Transcript of System Architecture - ITEC-OS Start2).pdf · System Architecture 4 Activities © 2008 Universität...
System ArchitectureSystem Architecture
4 Activities4 Activities
1© 2008 Universität Karlsruhe(TH), System Architecture Group
Process, Task, Thread
November 3 2008Winter Term 2008/09
Gerd Liefländer
Agenda Review
Motivation & Introduction
Basic Terms
P M d l
Overview
© 2008 Universität Karlsruhe(TH), System Architecture Group 2
Process Model
Task Model
Thread Model
Nice paper: “Microsoft schrumpft Windows-Kernel”
http://www.golem.de/0710/55519.html
What happens during Execution?
FetchExec
R0…
R31F0…
F30IP(PC)
…Data1Data0
Inst237Inst236
Addr 232-1
HW Review
© 2008 Universität Karlsruhe(TH), System Architecture Group 3
…Inst5Inst4Inst3Inst2Inst1Inst0
Addr 0
Execution sequence: Fetch Instruction at IP Decode Execute (possibly using registers) Write results to registers/mem IP = Next Instruction(IP)
RepeatIPIPIPIP
Illusion of an SMP on a Uniprocessor?
How to provide the illusion of multiple processors?
CPU3CPU2CPU1
Shared MemoryCPU1 CPU2 CPU3 CPU1 CPU2
Time
HW Review
© 2008 Universität Karlsruhe(TH), System Architecture Group 4
Multiplex the CPU in time, i.e. virtualize the CPU
Each virtual CPU needs a structure to hold: Instruction Pointer (IP), Stack Pointer (SP) r>1 Registers (Integer, Floating point, others…?)
How to switch from one virtual CPU to the next? Save IP(PC), SP, and r’ registers in current context block Load IP(PC), SP, and r’ registers from new context block
What is triggering a virtual CPU switch?
Motivation & IntroductionMotivation & Introduction
5© 2008 Universität Karlsruhe(TH), System Architecture Group
Why Activities?
HW offers concurrent execution of programs, e.g. CPU(s) & I/O-devices can run in parallel
Suppose a chess program can be parallelized, a>1 activities search in different chess data bases, another activity calculates the next moves etc
Motivation
© 2008 Universität Karlsruhe(TH), System Architecture Group 6
another activity calculates the next moves etc.
Better response time of the chess program
OS has to offer appropriate concepts to enable concurrent activities: Process Task Thread
1. How to provide „information processing“, i.e. “when“ to execute “what” code?
thread (process*)
2 Main Abstractions of Systems
Introduction
© 2008 Universität Karlsruhe(TH), System Architecture Group 7
address space (AS)
*Note: “Process” “lat. procedere” = “voranschreiten”Notion “thread” ~ “Faden” abwickeln
2. How to provide „protected depositories“, i.e. ”where“ to store ”what” information entity?
Design Parameters: Activity
Number of activities Static systems, i.e. at run-time no new activities Dynamic
Grade of interactivity Foreground, i.e. many interactions between user and activity
Introduction
© 2008 Universität Karlsruhe(TH), System Architecture Group 8
Background activity, e.g. Daemons (Unix/Linux background services) Applications controlled by background shell
Urgency Real time
Hard real time Soft real time
Interactive Batch processing
Design Parameters: Address Spaces Number and placement of regions
1 versus n>1 regions Contiguous address space Non-contiguous address space With(out) boundary checks
Types of regions
Introduction
© 2008 Universität Karlsruhe(TH), System Architecture Group 9
Types of regions Stack Heap Code …
Duration of data entity Temporary Persistent
…
Basic TermsBasic Terms
10© 2008 Universität Karlsruhe(TH), System Architecture Group
ProcessProgram
Process Process ~ abstraction for a single sequential
activity within a protected environment It represents the “execution” of
an application program a system program (outside the kernel)
Basic Terms
© 2008 Universität Karlsruhe(TH), System Architecture Group 11
a system program (outside the kernel)
It consists of an AS, context, state, and resources
Process* has only one single thread of execution
The system entity consisting of multiple activities within one AS is a task*
*Note: This terminology is KIT specific
Program versus Process Same program can be executed concurrently by
multiple processes, e.g. the gcc program
Program is something static It has i>1 instructions These i instructions are placed somewhere in RAM(or disk)
Basic Terms
© 2008 Universität Karlsruhe(TH), System Architecture Group 12
Process is something dynamic (sometimes a process has to wait for an event, i.e. it does no real progress)
An executable program (e.g. file xyz.exe) has to be loaded1 before becoming a process
In order to control a process the OS needs a process descriptor, i.e. a process control block (PCB)
1 different ways of loading a program
Process
An executing instance of an executable program only one executable file gcc
During a C course, simultaneously multiple gcc-processes can be active on one computer (e.g. at your computer center)
Basic Terms
© 2008 Universität Karlsruhe(TH), System Architecture Group 13
your computer center)
Each process is separated from another executing gcc process If one gcc-process fails it should not bother another
concurrent gcc-process or any other concurrent application process
Processes can start (launch) other processes
gcc Example
Via a command you can launch a gcc process
It first launches cpp, cc1, as
Finally it launches ld
Basic Terms
© 2008 Universität Karlsruhe(TH), System Architecture Group 14
Finally it launches ld
Each instance is a process, and each of the above programs actually exists separately
Process ModelProcess Model
15© 2008 Universität Karlsruhe(TH), System Architecture Group
Process StateProcess Control BlockAbstract Process Switch
“Processing” Model Heavyweight processing (e.g. Unix process)
Activity instance and address space form a system unit Each “process switch” involves 2 AS switches:
ARx OSkernel ARy
Lightweight processing (Kernel Level Threads, KLTs))A ti it i t d dd d l d
Process Model
according to weight classes of boxers
© 2008 Universität Karlsruhe(TH), System Architecture Group 16
Activity instances and address space are decoupled A “KLT switch” can involve 1.5 or 2 AS switches:
ARx OSkernel ARy or x
Featherweight processing (Pure User Level Threads, PULTs) Activity instances and AS form a single system unit A “PULT switch” at user level involves no AS switch, i.e.
ARx Arx
Whenever a thread switch is done without the kernel, then it must be a switch between two PULTs of the same AS
Process Model
Process Model
4 Logical Instruction Pointers
1 HW-Instruction Pointer
© 2008 Universität Karlsruhe(TH), System Architecture Group 17
Multiprogramming of four applications: each application is implemented as a process, i.e. in an isolated AS
Conceptually: four independent, sequential processes
Only one process can run at any instant of time on a conventional single-processor system
Example: AS of a Linux Process
Logical address regions, that a process can access: Code Data
static variables
User Stack
0xFFFFFFFF
(Reserved for OS)
SP
Process Model
task_sizeKAS
Only one KAS, independent of
#UASes
© 2008 Universität Karlsruhe(TH), System Architecture Group 18
static variables heap
User stack Local variables, parameters etc.
( to be installed for each call)
Code(text segment) IP
Initialized Data(data segment)
Uninitialized Data(BSS segment)
Heap
0x00000000user address space = UASprivate
Multiple User Address Spaces
User Stack
0xFFFFFFFF
Process Model
KAS
User Stack
User Stack
Only one KAS, independent of #UASes
© 2008 Universität Karlsruhe(TH), System Architecture Group 19
Code(text segment)
Initialized Data(data segment)
Uninitialized Data(BSS segment)
Heap
0x00000000 Code
Initialized Data Code(text segment)
Initialized Data(data segment)
Uninitialized Data(BSS segment)
Heap
Process Creation
Principal events causing a creation of a process:
1. System initialization (e.g. sysinit)
2. System call by another process (e.g. fork)
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 20
3. User creates a new process via a
1. Command (e.g. sh forks and then loads a new program image via system call exec(ve))
2. Click on icon representing an executable
4. Initiation of a batch job
Process Termination
Conditions that can terminate a process:
1. Normal exit (voluntary)
2. Error exit (voluntary)
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 21
2. Error exit (voluntary) Programmer has provided an exception handler
3. Fatal error (involuntarry) System handles exception
4. Aborted by another process (involuntary) Scenarios leading to a process abortion?
Process Hierarchy
Parent process creates a child process, a child process can create further children From the perspective of the parent these new kids
are grand-children
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 22
…
Forms a rooted-tree-like process hierarchy UNIX calls it a "process group"
Windows: no concept of a process hierarchy All processes are created at the same level
What else can describe a Process?
Information about process hierarchy Who has launched the process What processes have been launched by it
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 23
Information about resources Where does it store its data What other resources does it use
Various kinds of mappings What address regions belong to which process
Creating a Unix Process
child
if (PID==0)/* PID == 0 */
parent
PID = fork()/* PID 0 */
if (PID==0)
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 24
( ){exec(„program“)
...};
if (PID 0){ ...
...};wait(PID) . . .
exit () };. . .
Hint: good introduction how to create Unix, Linux and XP processeshttp://www-106.ibm.com/developerworks/linux/library/l-rt7/?Open&t=grl,l=252,p=mgth
Fork Example
int value = 5; /* a global variable */int main() {pid_t pid;value = 7; /* parent */
pid = fork();
© 2008 Universität Karlsruhe(TH), System Architecture Group 25
if (pid ==0) { /* child */value = 15;
}else { /* parent */
wait(NULL) /* wait for child to terminate */printf(“PARENT: value = %d\n”, value);
}}
Exec versus Fork
So how do we start a new program, instead of just forking the old program? The systemcall exec()
int exec(char *prog, char ** argv)
© 2008 Universität Karlsruhe(TH), System Architecture Group 26
exec()
Stops the current process
Loads the executable program prog into AS of the caller
Initializes HW context, args for the new program
Note: exec()does not create a new process
Example: Unix SHELL
int main(int argc, char **argv) {while (1){char *cmd = get_next_command();int child_pid = fork();if (child pid ==0) {
© 2008 Universität Karlsruhe(TH), System Architecture Group 27
( _p ) {exec(cmd);panic(“exec failed!”);
} else {waitpid(child_pid);}}}
Process Creation in Unix/Linux
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 28
Potential problems that have to be solved in a robust OS
1. What happens when parent dies before child exits?
2. What happens when parent does not wait?
3. What happens when child does not exit?
Unix Processes
Process executes last statement and asks OS to finish it via system call exit() Output data from child to parent process waiting for the
result via wait()
Resources of child can be released if no longer used
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 29
Resources of child can be released if no longer used otherwise
Parent or OS can terminate execution of child process (abort) in case of Child has exceeded allocated resources
Job assigned to the child is no longer required
Child misbehaves (looping forever)
init
sh
Unix Process Hierarchy
Process Model
Can accept another command
© 2008 Universität Karlsruhe(TH), System Architecture Group 30
sh
ls -R wc$ ls –R | wc&
Background shell
Overhead to create a Process
Must construct a new PCB Quite cheap (as long as there is enough space for it)
Must set up new page tables or related data structures representing the new AS More expensive
© 2008 Universität Karlsruhe(TH), System Architecture Group 31
More expensive
Copy data from parent process? (Unix fork() ) Semantics of Unix fork(): the child process gets a
complete copy of the parent’s memory and I/O state In early Unix versions very expensive Today less expensive due to concept of “copy on write”
Copy I/O state (file handles, etc) More expensive
Preview: Process Switching Action of releasing one process from the CPU and
assigning another process to the CPU is named a voluntary process switch
Process Model
PID 0815State: ready
PID 4000State: ready
PID 4711State: running
© 2008 Universität Karlsruhe(TH), System Architecture Group 32
IP
Registers
y
IP
Registers
IP
Registers
g
IP
Registers
Currently running process Save current processor status
Process Switching
Intermediate state
Process Model
PID 0815State: ready
PID 4000State: ready
PID 4711State: ready
© 2008 Universität Karlsruhe(TH), System Architecture Group 33
IP
Registers
IP
Registers
IP
Registers
Previously running process
IP
Registers
Now you have to select a new process
to run, e.g. 0815
Process Switching
Loading context of the new process
Process Model
PID 0815State: ready
PID 4000State: ready
PID 4711State: ready
© 2008 Universität Karlsruhe(TH), System Architecture Group 34
IP
Registers
IP
Registers
IP
Registers
Previously running process
IP
Registers
Load context of 0815
Process Switching
Running the new process
Process Model
PID 0815State: running
PID 4000State: ready
PID 4711State: ready
© 2008 Universität Karlsruhe(TH), System Architecture Group 35
IP
Registers
IP
Registers
IP
Registers
Previously running process
IP
Registers
Currently running process
Cost of Process Switching In some systems, a process switch is expensive
Entering and exiting the kernel
CPU context has to be saved & restored
Storing & loading AS information
(Flushing TLB and) restoring TLB content
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 36
Scheduling next ready process to run can be expensive, especially when the OS designer is too lazy
Process switch overhead in Linux 2.4.21 ~ 5.4 µsec on a 2.4 GHz Pentium 4 Equivalent to ~ 13 200 CPU cycles !!! Not quite that many instructions since CPI* >1
*CPI = cycles per instruction
(External) Process States
Process Model
1. Process blocks for I/O2. Process leaves CPU voluntarily
or scheduler forces process to leave the CPU
3. Scheduler picks another process4. I/O has occurred, process no
© 2008 Universität Karlsruhe(TH), System Architecture Group 37
Possible process states- Blocked (waiting, sleeping)
- Ready- Running
Colors should remind you of the semantics of traffic lights
/ , plonger has to wait
Process States
During its life a process can change its external process state several times
new: Process has being created
running: Its instructions are executed
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 38
waiting: It is waiting for some internal or external event to occur
ready: It is ready to run, however it is still waiting to be assigned to a processor
terminated: It has finished
Unix “Process State Model”Why is preempted
a distinct state? Lazy versus eager loading
?
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 39
Potential Attributes of a PCB
ContextContext
SchedulingScheduling
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 40
FamilyFamily
Time &Time &EventsEvents
Shortcomings of Process Model
Sufficient for all sequential applications e.g. only one activity per process
However, what to do if your application can profit from internal concurrency?
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 41
Multiple application processes Protection is guaranteed by different AS, but
solution can be expensive Collaboration takes time
Better use a multi-threaded task different thread models
Example Parallel Applications
Web browser: Download web pages, read cache files, accept user
input,…
W b
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 42
Web server: Handle incoming connections from multiple clients
Scientific programs: Process different parts of a data set on different
CPUs, e.g. calculate a numerical difference equation
Parallel Applications
Share memory across multiple activities Web browser: share buffer for HTML pages
Web server: share memory cache of recently accessed pages
Process Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 43
p g
Scientific programs: share memory of global data set being processed
Can we do this with multiple processes? Yes, as long as OS offers shared memory
If not, we must use IPC which might be inefficient
Task ModelTask Model
44© 2008 Universität Karlsruhe(TH), System Architecture Group
Example: Linux T(ask)CB
Linux Task Descriptor TaskCB
Process Model
Located in a 8 KB kernel memory block
esp register points to kernel stack if task has switched to kernel mode ?
Example TaskCB
kernelstack
© 2008 Universität Karlsruhe(TH), System Architecture Group 45
switched to kernel mode
The macros current & esp deliver the task-descriptor address
TaskDescriptor
?
Content of Task Desciptor (1)
Task Model
State:
current task state
Macros for changing the task-state by the kernel:
set task state(TID) = set the state of
© 2008 Universität Karlsruhe(TH), System Architecture Group 46
_ _ ( )a certain task with TID
set_current_state = set the state of a the running task
Flags:
part of PSW or Statusregister
Content of Task Descriptor (2)counter: Time in ticks (10 ms) till next scheduling
Used to select next running task (thread)
Dynamic priority
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 47
nice(priority): Static priority
Scheduler uses priority to set counter
need_resched: Indicates that scheduling has to be done (sooner or later)
Content of Task Descriptor (3)
Next_task: next taskPrev_task: previous task Run_list: list of ready tasks
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 48
Content of Task Descriptor (4)
p_opptr, p_pptr, p_cptr,
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 49
p_ysptr; p_osptr:: e.g. old or current parent etc.
Content of Task Descriptor (5)
TTY:Information concerning the current console
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 50
Content of Task Descriptor (6)
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 51
Thread: Information about CPU state for last
mode switch
Save all CPU registers
Content of Task Descriptor (7)File System contains file specific information:
current directory
root directory
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 52
Content of Task Descriptor (8)
Files: file-descriptor referencing an open file
fd contains file pointer
i l # f fd
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 53
maximal # of fd
Content of Task Descr. (7,8 a)
filesfs
inode
inode
inode
task_struct fs_struct
count
umask
*root
*pwd
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 54
f_modef_posf_flagsf_countf_ownerf_inodef_opf_version
file
inode
File operation routines
countclose_on_execopen_fsfd[0]
fd[255]
fd[1]
. . .
file_struct
Content of Task Descriptor (9)
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 55
mm: memory management contains pointers to memory areas
Content of Task Descriptor (9a)Task
Virtual Address Space
mm
task_struct
data
vm_area_structvm_endvm_startvm_flagsvm_inodevm_ops
countpgd
mmap
. . .
mm_struct
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 56
vm_endvm_startvm_flagsvm_inodevm_ops
vm_next
vm_area_structcode
vm_next
pmmap_avlmmap_sem
Content of Task Descriptor (10)
Task Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 57
sig: signals pointers to start-addresses of signal handlers of the task
Thread ModelThread Model
58© 2008 Universität Karlsruhe(TH), System Architecture Group
Thread Model
Thread Thread = abstraction for a pure activity
Thread includes code and private data (stack)
Each thread needs an execution environment Address space
© 2008 Universität Karlsruhe(TH), System Architecture Group 59
p
Files, I/O-devices and other resources
In many cases, a thread shares its complete environment with all other threads of the same AS
Example: File server consists of t identical threads,each thread serves one client’s request
Thread
Entity in which activity takes place
Object of dispatching (scheduling)
Thread Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 60
time
On a single processor system, threads are executed on the same CPU, thus we need to control all threads in order to prevent that a single thread is hogging the CPU
…
Process
Single threaded
Address space (Unix terminology)
Thread Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 61
Address space + resources
Additional resources
Task
Entity of an “application” consisting of t ≥ 1 thread(s) Address space
R
Thread Model
© 2008 Universität Karlsruhe(TH), System Architecture Group 62
1 or more threads+ AS+ resources
Resources
Address Space of a Task
All threads share the same AS
Bugs in one thread can crash the complete task
Danger of mutual stack overflow
Thread Model
Stack1
0xFFFFFFFF(Reserved for OS)
SP1
Stack2SP2
© 2008 Universität Karlsruhe(TH), System Architecture Group 63
Danger of mutual stack overflow
Robust systems should offer additional protection between threads of the same task, e.g.
Private global data
Protected thread stacks Code(text segment)
IP1
Initialized Data(data segment)
Uninitialized Data(BSS segment)
Heap
0x00000000
IP2
Process versus Task
© 2008 Universität Karlsruhe(TH), System Architecture Group 64
Threads encapsulate concurrency: “active” component
Address spaces encapsulate protection: “passive” part Keeps buggy process from trashing other processes or the
system
task
Example Multithreaded Programs
Embedded systems Elevators, Planes, Medical systems, Wristwatches
Single Program, concurrent operations
Modern OS kernelsC t i k l th d ( k l l l th d )
© 2008 Universität Karlsruhe(TH), System Architecture Group 65
Contains kernel threads (no kernel level threads) Kernel threads are completely executed in kernel mode Kernel level threads are executed in user mode most of the time
Often, no/few additional protection offered inside the kernel
Database Servers Access to shared data by many concurrent users
Also background utility processing must be done
Literature
Bacon, J.: Operating Systems (4)
Stallings, W.: Operating Systems (3, 4)
Silberschatz, A.: OS Concepts (2)
Overview
© 2008 Universität Karlsruhe(TH), System Architecture Group 66
Silberschatz, A.: OS Concepts (2)
Tanenbaum, A.: MOS (2)