Krishnamurthy Concurrency
Arvind Spring 2004
Todays lecture
n
Semester roughly divided into:
n n n n
Threads, synchronization, scheduling Virtual memory File systems Networking
n
Next 2.5 weeks: threads and synchronization Today: thread basics Friday: C++ tutorial Wednesday: thread implementation
n n n
1
Process Environments
n
Uniprogramming: 1 process at a time
n
n n
n
Cooperative timesharing: mostly PCs, vintage OSes Easy for OS, hard for user (generally) Does not deal with concurrency (by defining it away) Violates isolation: Infinite loops
OS
n
Multiprogramming: > 1 process at a time
n
Time-sharing: CTSS, Multics, Unix, VMS, NT, ...
OS
Why concurrency?
n
Operating systems have two general functions:
A. Standard services: Provide standard facilities that everyone needs Examples: standard libraries, file systems, windowing systems B. Coordinator: allow several things to work together Examples: memory protection, virtual memory
n
OS has to coordinate all the activity on a machine
n
Requests from multiple users, I/O interrupts Instead of dealing with everything at once, deal with one at a time
n
Decompose hard problems into simpler ones
n
2
Processes
n
Process: OS abstraction to represent what is needed to run a single program Formally, a process is a sequential stream of execution in its own address space Two parts to a process:
n
n
n
n
Sequential execution: no concurrency inside a process everything happens sequentially Process state: everything that is necessary to run the process
n
Question: What is typically part of the process state?
n
In other words, suppose you want to migrate a process what would you have to transport to the new machine?
Program vs. process
main() { ... foo() ... } foo() { ... }
main() { ... foo() ... } foo() { ... }
heap stack
main foo
registers PC Process
Program
3
Program vs. process (contd)
n
Process > program
n n
Program is just part of process state Example: many users can run the same program (creating different processes)
n
Process < program
n n
A program can invoke more than one process Example: cc starts up cpp, cc1, cc2, as, ld (each are programs themselves)
Process creation in Unix
n
Each process has its own state Even if two processes are created from the same executable, they will still have different state associated with them When a process clones itself using fork, a separate copy is created
n
n
int x = 1; int pid; main() { pid = fork(); x = x + 1; }
Updates made on different variables
4
Process creation in Unix (contd.)
n
How to make processes:
n n
fork clones a process exec overlays the current process
if((pid = fork()) == 0) { /* child process */ exec(foo); else /* parent */ wait(pid);
/* exec does not return */ /* wait for child to finish */
n
Question: Is this a good interface?
Announcements
n
Zheng Ma is the TA for the class
n n
Email: [e-mail] Please put cs422 in subject line
n
Assignment 0 is on the class website
n n
Each person needs to this separately Due: Jan 26th
5
Processes, Threads, Address Spaces
n
Process: Thread(s) + Address space Thread: sequential execution stream within a process
n
n
Provides concurrency
n
Address space: state needed to run a program
n context n
n
Execution or Container for execution stream Literally, all the memory addresses that can be touched by the program Provides illusion of program having its own machine
n
Multithreading: single program composed of a number of different concurrent activities
Thread creation in Nachos
n
Thread creation in Nachos is very explicit
void SimpleThread (int which) { int num; for (num=0; num<5; num++) printf(*** thread %d looped %d times\n, which, num); }
void ThreadTest() { Thread *t = new Thread(forked thread); t->Fork(SimpleThread, 1); SimpleThread(0); }
n
What is the output? Depends on the implementation
6
Explicit Yields
void SimpleThread (int which) { int num; for (num=0; num<5; num++) { printf(*** thread %d looped %d times\n, which, num); currentThread->Yield(); } }
void ThreadTest() { Thread *t = new Thread(forked thread); t->Fork(SimpleThread, 1); SimpleThread(0); }
Thread State
n
Can be classified into two types:
n n
Private Shared
n
Shared state
n n
Contents of memory (global variables, heap) File system
n
Private state
n n n
Program counter Registers Stack
7
Threads Share Memory
int done[2] = {0, 0}; void SimpleThread (int which) { int num; for (num=0; num<5; num++) printf(*** thread %d looped %d times\n, which, num); done[which] = 1; } void ThreadTest() { Thread *t = new Thread(forked thread); t->Fork(SimpleThread, 1); SimpleThread(0); while (!done[1]); // Perform work that incorporates results from two threads }
Classifying State
int x; void foo() { int y; x = 1; y = 1; } global variable stack variable
main() { int *p; p = (int *)malloc(sizeof(int)); *p = 1; heap access }
8
Address Space Properties
n n
Addresses of global variables defined at link-time Addresses of heap variables defined at malloc-time
int x; main() { int *p = malloc(sizeof(int)); printf(%x %x, &x, p); } // &x will never change across executions, p might
Stack Variables
...