of 2/8/2008
Components a Process
Program vs. process Process:
object code of program (program text in UNIX) data on which the program will execute (from file or user interaction) resources required by the program (e.g., files) status of the process execution (e.g., PC and registers)
Process Creation
Parent process creates children processes, which, in turn create other processes, forming a tree of processes Resource sharing options
Parent and child share all resources Children share subset of parent's resource Parent and child share no resources
OS keeps process descriptor for each (generally) nonterminated process Traditional process: one address space and one flow of control Modern process: one address space and one or more flows of execution (threads) MORE LATER
CS414: Operating Systems
Execution options
Parent and child execute concurrently Parent waits until children terminate
Address Space
Child duplicate of parent Child has a program loaded into it
CS414: Operating Systems
UNIX fork
fork() creates new child process; one process executes fork() and two become ready Child is identical to parent
except for return code from fork()
Context Switch
To run a process, the OS loads the values of the hardware registers (PC, SP, other registers) from the values stored in that process' PCB As the program executes, the CPU registers changes values (PC, SP) When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process Context-switching is overhead; the system does no useful work while switching The duration of a context switch is dependent on hardware Typically, time sharing OS performs 100 to 1000 context switches per second Picture on next slide.
No part of the address space is shared parent and child communicate via pipes, explicitly shared memory, and shared files Parent can wait or continue Child can exec Example: your shell program; typing date forks a new process and then execs date; & after the command means it runs in parallel with your shell, otherwise it waits {DEMO}
CS414: Operating Systems
CS414: Operating Systems
Context Switch
Threads
Original Process: address space and (single) flow of execution Thread
we must separate address space (process or task) and flow of execution (thread or lightweight process, LWP)
Motivation:
Context switch between cooperating processes is HUGE (reestablishing address space); context switch between cooperating threads is cheap fork() of cooperating process is expensive; spawn of thread is cheap programming is easier(?)
traditional UNIX
CS414: Operating Systems CS414: Operating Systems
embedded systems
Windows, Solaris (POSIX)
1
2/8/2008
Threads and Address Space
files, I/O PC Registers TCB1 PC Registers PC Registers TCB3 stacks TCB2
Sample Pthreads Code (1/2)
// Pthreads example code // compile with: gcc -Wall pthreads_example.c -o pthreads_example // -lpthread execute with: ./pthreads_example (or "time ./pthreads_example") #include <pthread.h> #include <stdio.h> void thread_func (int num) { long long i,j; printf("Thread %d executing.\n", num); j = 0; for (i=0; i < 700000000U; ++i){ ++j; } printf("Thread %d done (%lld).\n", num, j); }
gigabyte virtual address space
CS414: Operating Systems
CS414: Operating Systems
Sample Pthreads Code (2/2)
int main () { pthread_t thread1, thread2; pthread_t thread3, thread4; pthread_create(&thread1, NULL, (void *) &thread_func, (void *) 1); pthread_create(&thread2, NULL, (void *) &thread_func, (void *) 2); pthread_create(&thread3, NULL, (void *) &thread_func, (void *) 3); pthread_create(&thread4, NULL, (void *) &thread_func, (void *) 4); pthread_join(thread1, NULL); pthread_join(thread2, NULL); pthread_join(thread3, NULL); pthread_join(thread4, NULL); return 0; }
CS414: Operating Systems CS414: Operating Systems
DEMO
Run the previous program on Linux
Hmmm.. Why is top saying that only one of the CPUs is pegged at 100%? Why arent both pegged?
Kernel Threads
An improvement over only processes Creation/Switching still requires trapping to the kernel (system call) Thread data structure resides within the kernel:
Thread Control Block (TCB) (execution state and scheduling info), so more complexity for the kernel In what sense?
User-level Threads
Faster than kernel-level threads Managed by run-time system in user-space (no kernel calls) Creation, switching, and synchronizing between thread calls can be done without kernel involvement Process-specific scheduling policies are possible Problem: whole process blocks when one thread blocks (there a...