Approaches to Concurrency

Transcription

1 PROCESS AND THREADS

2 Approaches to Concurrency Processes Hard to share resources: Easy to avoid unintended sharing High overhead in adding/removing clients Threads Easy to share resources: Perhaps too easy Medium overhead Not much control over scheduling policies Difficult to debug Event orderings not repeatable I/O Multiplexing Tedious and low level Total control over scheduling Very low overhead Cannot create as fine grained a level of concurrency Does not make use of multi-core

3 But first, What is a process? Some review of the functions we learned (e.g., fork, waitpid) What is a thread?

4 Processes Definition: A process is an instance of a running program. One of the most profound ideas in computer science Not the same as program or processor Process provides each program with two key abstractions: Logical control flow Each program seems to have exclusive use of the CPU Private virtual address space Each program seems to have exclusive use of main memory How are these Illusions maintained? Process executions interleaved (multitasking) or run on separate cores Address spaces managed by virtual memory system

5 Kernel virtual memory (code, data, heap, stack) User stack (created at runtime) Memory invisible to user code %esp (stack pointer) Memory mapped region for shared libraries 0x (32) 0x (64) Run-time heap (created by malloc) Read/write segment (.data,.bss) Read-only segment (.init,.text,.rodata) brk Loaded from the executable file 0

6 Concurrent Processes Two processes run concurrently (are concurrent) if their flows overlap in time Otherwise, they are sequential Examples (running on single core): Concurrent: A & B, A & C Sequential: B & C Process A Process B Process C Time

7 User View of Concurrent Processes Control flows for concurrent processes are physically disjoint in time However, we can think of concurrent processes are run ning in parallel with each other Process A Process B Process C Time

8 A View of a Process Process = process context + code, data, and stack Process context Code, data, and stack Program context: Data registers Stack pointer (SP) Program counter (PC) Kernel context: VM structures Descriptor table brk pointer SP brk PC 0 stack shared libraries run-time heap read/write data read-only code/data

9 Context Switching Processes are managed by a shared chunk of OS code called the kernel Important: the kernel is not a separate process, but rather runs as part of some user process Control flow passes from one process to another via a context switch Process A Process B Time user code kernel code user code kernel code user code context switch context switch

10 fork: Creating New Processes int fork(void) creates a new process (child process) that is identical t o the calling process (parent process) returns 0 to the child process returns child s pid to the parent process pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); Fork is interesting (and often confusing) because it is called once but returns twice

11 Understanding fork Process n Child Process m pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); pid = m pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); pid = 0 pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); pid_t pid = fork(); if (pid == 0) { printf("hello from child\n"); else { printf("hello from parent\n"); hello from parent Which one is first? hello from child

12 Fork Example #1 Parent and child both run same code Distinguish parent from child by return value from fork Start with same state, but each has private copy Including shared output file descriptor Relative ordering of their print statements undefined void fork1() { int x = 1; pid_t pid = fork(); if (pid == 0) { printf("child has x = %d\n", ++x); else { printf("parent has x = %d\n", --x); printf("bye from process %d with x = %d\n", getpid(), x);

13 Fork Example #2 Both parent and child can continue forking void fork2() { printf("l0\n"); fork(); printf("l1\n"); fork(); printf("bye\n"); L0 L1 L1 Bye Bye Bye Bye

14 Fork Example #2 Both parent and child can continue forking void fork4() { printf("l0\n"); if (fork()!= 0) { printf("l1\n"); if (fork()!= 0) { printf("l2\n"); fork(); printf("bye\n"); L0 L1 L2 Bye Bye Bye Bye

15 exit: Ending a process void exit(int status) exits a process Normally return with status 0 atexit() registers functions to be executed upon exit void cleanup(void) { printf("cleaning up\n"); void fork6() { atexit(cleanup); fork(); exit(0);

16 File Descriptors and Descriptor Table Descriptor table (one table per process) Open file table (shared by all processes) v-node table (shared by all processes) stdin stdout stderr fd 0 fd 1 fd 2 fd 3 fd 4 File A File pos refcnt=1... File access File size File type... File B File access File pos refcnt=1 File size File type......

17 Descriptor tables Parent's table fd 0 fd 1 fd 2 fd 3 fd 4 Open file table (shared by all processes) File A File pos refcnt=2... v-node table (shared by all processes) File access File size File type... Child's table fd 0 fd 1 fd 2 fd 3 fd 4 File B File pos refcnt=2... File access File size File type... After Fork.

18 Descriptor table (one table per process) fd 0 fd 1 fd 2 fd 3 fd 4 Open file table (shared by all processes) File A File pos refcnt=1... File B File pos refcnt=1 v-node table (shared by all processes) File access File size File type... File sharing: e.g., Opening the same file twice....

19 Zombies Idea When process terminates, still consumes system resources Various tables maintained by OS Called a zombie Living corpse, half alive and half dead Reaping Performed by parent on terminated child Parent is given exit status information Kernel discards process What if parent doesn t reap? If any parent terminates without reaping a child, then child wi ll be reaped by init process So, only need explicit reaping in long-running processes e.g., shells and servers

20 Zombie Example linux>./forks 7 & [1] 6639 Running Parent, PID = 6639 Terminating Child, PID = 6640 linux> ps PID TTY TIME CMD 6585 ttyp9 00:00:00 tcsh 6639 ttyp9 00:00:03 forks 6640 ttyp9 00:00:00 forks <defunct> 6641 ttyp9 00:00:00 ps linux> kill 6639 [1] Terminated linux> ps PID TTY TIME CMD 6585 ttyp9 00:00:00 tcsh 6642 ttyp9 00:00:00 ps void fork7() { if (fork() == 0) { /* Child */ printf("terminating Child, PID = %d\n", getpid()); exit(0); else { printf("running Parent, PID = %d\n", getpid()); while (1) ; /* Infinite loop */ ps shows child process as defunct Killing parent allows child to be reap ed by init

21 wait: Synchronizing with Children int wait(int *child_status) suspends current process until one of its children terminates return value is the pid of the child process that terminated if child_status!= NULL, then the object it points to w ill be set to a status indicating why the child process terminat ed

22 wait: Synchronizing with Children void fork9() { int child_status; if (fork() == 0) { printf("hc: hello from child\n"); else { printf("hp: hello from parent\n"); wait(&child_status); printf("ct: child has terminated\n"); printf("bye\n"); exit(); HC Bye HP CT Bye

23 wait() Example If multiple children completed, will take in arbitrary order Can use macros WIFEXITED and WEXITSTATUS to get information about exit status void fork10() { pid_t pid[n]; int i; int child_status; for (i = 0; i < N; i++) if ((pid[i] = fork()) == 0) exit(100+i); /* Child */ for (i = 0; i < N; i++) { pid_t wpid = wait(&child_status); if (WIFEXITED(child_status)) printf("child %d terminated with exit status %d\n", wpid, WEXITSTATUS(child_status)); else printf("child %d terminate abnormally\n", wpid);

24 waitpid(): Waiting for a Specific Process waitpid(pid, &status, options) suspends current process until specific process terminate void fork11() { pid_t pid[n]; int i; int child_status; for (i = 0; i < N; i++) if ((pid[i] = fork()) == 0) exit(100+i); /* Child */ for (i = N-1; i >= 0; i--) { pid_t wpid = waitpid(pid[i], &child_status, 0); if (WIFEXITED(child_status)) printf("child %d terminated with exit status %d\n", wpid, WEXITSTATUS(child_status)); else printf("child %d terminated abnormally\n", wpid);

25 Summary Processes At any given time, system has multiple active processes Only one can execute at a time on a single core, though Each process appears to have total control of processor + private memory space

26 Summary (cont.) Spawning processes Call fork One call, two returns Process completion Call exit One call, no return Reaping and waiting for Processes Call wait or waitpid

27 Approaches to Concurrency Processes Hard to share resources: Easy to avoid unintended sharing High overhead in adding/removing clients Threads Easy to share resources: Perhaps too easy Medium overhead Not much control over scheduling policies Difficult to debug Event orderings not repeatable I/O Multiplexing Tedious and low level Total control over scheduling Very low overhead Cannot create as fine grained a level of concurrency Does not make use of multi-core

28 Approach #3: Multiple Threads Very similar to approach #1 (multiple processes) but, with threads instead of processes

29 Traditional View of a Process Process = process context + code, data, and stack Process context Code, data, and stack Program context: Data registers Condition codes Stack pointer (SP) Program counter (PC) Kernel context: VM structures Descriptor table brk pointer SP brk PC 0 stack shared libraries run-time heap read/write data read-only code/data

30 Alternate View of a Process Process = thread + code, data, and kernel context Thread (main thread) Code and Data SP stack Thread context: Data registers Condition codes Stack pointer (SP) Program counter (PC) brk PC 0 shared libraries run-time heap read/write data read-only code/data Kernel context: VM structures Descriptor table brk pointer

31 A Process With Multiple Threads Multiple threads can be associated with a process Each thread has its own logical control flow Each thread shares the same code, data, and kernel context Share common virtual address space (inc. stacks) Each thread has its own thread id (TID) Thread 1 (main thread) stack 1 Thread 1 context: Data registers Condition codes SP1 PC1 0 Shared code and data shared libraries run-time heap read/write data read-only code/data Kernel context: VM structures Descriptor table brk pointer Thread 2 (peer thread) stack 2 Thread 2 context: Data registers Condition codes SP2 PC2

32 Logical View of Threads Threads associated with process form a pool of peers Unlike processes which form a tree hierarchy Threads associated with process foo Process hierarchy T1 T2 shared code, data and kernel context T4 P0 P1 sh sh sh T5 T3 foo bar

33 Thread Execution Single Core Processor Simulate concurrency by time slici ng Multi-Core Processor Can have true concurrency Thread A Thread B Thread C Thread A Thread B Thread C Time Run 3 threads on 2 cores

34 Logical Concurrency Two threads are (logically) concurrent if their flows overlap in time Otherwise, they are sequential Examples: Concurrent: A & B, A&C Sequential: B & C Time Thread A Thread B Thread C

35 Threads vs. Processes How threads and processes are similar Each has its own logical control flow Each can run concurrently with others (possibly on different co res) Each is context switched How threads and processes are different Threads share code and some data Processes (typically) do not Threads are somewhat less expensive than processes Process control (creating and reaping) is twice as expensive as thre ad control Linux numbers: ~20K cycles to create and reap a process ~10K cycles (or less) to create and reap a thread

36 Posix Threads (Pthreads) Interface Pthreads: Standard interface for ~60 functions that manipulate threads f rom C programs Creating and reaping threads pthread_create() pthread_join() Determining your thread ID pthread_self() Terminating threads pthread_cancel() pthread_exit() exit() [terminates all threads], RET [terminates current thread] Synchronizing access to shared variables pthread_mutex_init pthread_mutex_[un]lock pthread_cond_init pthread_cond_[timed]wait

37 The Pthreads "hello, world" Program /* * hello.c - Pthreads "hello, world" program */ #include "csapp.h" void *thread(void *vargp); int main() { pthread_t tid; Pthread_create(&tid, NULL, thread, NULL); Pthread_join(tid, NULL); exit(0); /* thread routine */ void *thread(void *vargp) { printf("hello, world!\n"); return NULL; Thread attributes (usually NULL) Thread arguments (void *p) return value (void **p)

38 Execution of Threaded hello, world main thread call Pthread_create() Pthread_create() returns call Pthread_join() main thread waits for peer thread to terminate Pthread_join() returns peer thread printf() return NULL; (peer thread terminates) exit() terminates main thread and any peer threads

39 Thread-Based Concurrent Echo Server int main(int argc, char **argv) { int port = atoi(argv[1]); struct sockaddr_in clientaddr; int clientlen=sizeof(clientaddr); pthread_t tid; int listenfd = Open_listenfd(port); while (1) { int *connfdp = Malloc(sizeof(int)); *connfdp = Accept(listenfd, (SA *) &clientaddr, &clientlen); Pthread_create(&tid, NULL, echo_thread, connfdp); Spawn new thread for each client Pass it copy of connection file descriptor Note use of Malloc()! Without corresponding Free()

40 Thread-Based Concurrent Server (cont) /* thread routine */ void *echo_thread(void *vargp) { int connfd = *((int *)vargp); Pthread_detach(pthread_self()); Free(vargp); echo(connfd); Close(connfd); return NULL; Run thread in detached mode Runs independently of other threads Reaped when it terminates Free storage allocated to hold clientfd Producer-Consumer model

41 Threaded Execution Model Connection Requests Listening Server Client 1 data Client 1 Server Client 2 Server Client 2 data Multiple threads within single process Some state between them File descriptors

42 Potential Form of Unintended Sharing while (1) { int connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen); Pthread_create(&tid, NULL, echo_thread, (void *) &connfd); main thread connfd = connfd 1 Main thread stack connfd peer 1 Peer 1 stack connfd = connfd 2 Race! connfd = *vargp vargp peer 2 connfd = *vargp Peer 2 stack vargp Why would both copies of vargp point to same location?

43 Could this race occur? Main int i; for (i = 0; i < 100; i++) { Pthread_create(&tid, NULL, thread, &i); Thread void *thread(void *vargp) { int i = *((int *)vargp); Pthread_detach(pthread_self()); save_value(i); return NULL; Race Test If no race, then each thread would get different value of i Set of saved values would consist of one copy each of 0 through 99.

44 Experimental Results No Race Single core laptop Multicore server The race can really happen!

45 Issues With Thread-Based Servers Must run detached to avoid memory leak. At any point in time, a thread is either joinable or detached. Joinable thread can be reaped and killed by other threads. must be reaped (with pthread_join) to free memory resources. Detached thread cannot be reaped or killed by other threads. resources are automatically reaped on termination. Default state is joinable. use pthread_detach(pthread_self()) to make detached. Must be careful to avoid unintended sharing. For example, passing pointer to main thread s stack Pthread_creat e(&tid, NULL, thread, (void *)&connfd); All functions called by a thread must be thread-safe Stay tuned

46 Pros and Cons of Thread-Based Designs + Easy to share data structures between threads e.g., logging information, file cache. + Threads are more efficient than processes. Unintentional sharing can introduce subtle and hard-toreproduce errors! The ease with which data can be shared is both the greatest strength and the greatest weakness of threads. Hard to know which data shared & which private Hard to detect by testing Probability of bad race outcome very low But nonzero! Future lectures