1 / 71

1. Synchronization: basic 2. Synchronization: advanced

1. Synchronization: basic 2. Synchronization: advanced. Synchronization: basic. Threads review Sharing Mutual exclusion Semaphores. Process: Traditional View. Process = process context + code, data, and stack. Process context. Code, data, and stack. stack. Program context:

channer
Download Presentation

1. Synchronization: basic 2. Synchronization: advanced

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 1. Synchronization: basic2. Synchronization: advanced

  2. Synchronization: basic • Threads review • Sharing • Mutual exclusion • Semaphores

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

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

  5. Process with Two Threads Thread 1 Program context: Data registers Condition codes Stack pointer (SP) Program counter (PC) Code, data, and kernel context shared libraries brk run-time heap read/write data stack PC read-only code/data SP 0 Thread 2 Kernel context: VM structures Descriptor table brk pointer Program context: Data registers Condition codes Stack pointer (SP) Program counter (PC) stack SP

  6. Threads vs. Processes • Threads and processes: similarities • Each has its own logical control flow • Each can run concurrently with others • Each is context switched (scheduled) by the kernel • Threads and processes: differences • Threads share code and data, processes (typically) do not • Threads are less expensive than processes • Process control (creating and reaping) is more expensive as thread control • Context switches for processes more expensive than for threads

  7. Threads vs. Processes (cont.) • Processes form a tree hierarchy • Threads form a pool of peers • Each thread can kill any other • Each thread can wait for any other thread to terminate • Main thread: first thread to run in a process Thread pool Process hierarchy T2 P0 T4 T1 P1 shared code, data and kernel context sh sh sh T3 T5 foo

  8. Posix Threads (Pthreads) Interface • Pthreads: Standard interface for ~60 functions that manipulate threads from C programs • Threads run thread routines: • void *threadroutine(void *vargp) • Creating and reaping threads • pthread_create(pthread_t *tid, …, func *f, void *arg) • pthread_join(pthread_ttid, void **thread_return) • Determining your thread ID • pthread_self() • Terminating threads • pthread_cancel(pthread_ttid) • pthread_exit(void *tread_return) • return(in primary thread routine terminates the thread) • exit(terminates all threads)

  9. The Pthreads“Hello, world" Program /* * hello.c - Pthreads "hello, world" program */ #include "csapp.h" void *thread(void *vargp); int main() { pthread_ttid; 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) assigns return value (void **p)

  10. 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-to-reproduce errors!

  11. Synchronization: basic • Threads review • Sharing • Mutual exclusion • Semaphores

  12. Shared Variables in Threaded C Programs • Question: Which variables in a threaded C program are shared? • The answer is not as simple as “global variables are shared” and “stack variables are private” • Requires answers to the following questions: • What is the memory model for threads? • How are instances of variables mapped to memory? • How many threads might reference each of these instances? • Def: A variable x is shared if and only if multiple threads reference some instance of x.

  13. Threads Memory Model • Conceptual model: • Multiple threads run within the context of a single process • Each thread has its own separate thread context • Thread ID, stack, stack pointer, PC, condition codes, and GP registers • All threads share the remaining process context • Code, data, heap, and shared library segments of the process virtual address space • Open files and installed handlers • Operationally, this model is not strictly enforced: • Register values are truly separate and protected, but… • Any thread can read and write the stack of any other thread The mismatch between the conceptual and operation model is a source of confusion and errors

  14. Example Program to Illustrate Sharing /* thread routine */ void *thread(void *vargp) { int myid = (int) vargp; static intcnt= 0; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); } char **ptr; /* global */ int main() { inti; pthread_t tid; char *msgs[2] = { "Hello from foo", "Hello from bar" }; ptr = msgs; for (i = 0; i < 2; i++) Pthread_create(&tid, NULL, thread, (void *)i); Pthread_exit(NULL); } Peer threads reference main thread’s stack indirectly through global ptr variable

  15. Mapping Variable Instances to Memory • Global variables • Def: Variable declared outside of a function • Virtual memory contains exactly one instance of any global variable • Local variables • Def: Variable declared inside function without static attribute • Each thread stack contains one instance of each local variable • Local static variables • Def: Variable declared inside function with the static attribute • Virtual memory contains exactly one instance of any local static variable.

  16. Mapping Variable Instances to Memory Global var: 1 instance (ptr[data]) Local vars: 1 instance (i.m, msgs.m) Local var:2 instances ( myid.p0 [peer thread 0’s stack], myid.p1 [peer thread 1’s stack] ) char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[2] = { "Hello from foo", "Hello from bar" }; ptr = msgs; for (i = 0; i < 2; i++) Pthread_create(&tid, NULL, thread, (void *)i); Pthread_exit(NULL); } /* thread routine */ void *thread(void *vargp) { int myid = (int)vargp; static intcnt= 0; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); } Local static var: 1 instance (cnt[data])

  17. Shared Variable Analysis • Which variables are shared? • Answer: A variable x is shared iff multiple threads reference at least one instance of x. Thus: • ptr, cnt, and msgs are shared • i and myid are not shared Variable Referenced by Referenced by Referenced by instance main thread? peer thread 0? peer thread 1? ptr cnt i.m msgs.m myid.p0 myid.p1 yes yes yes no yes yes yes no no yes yes yes no yes no no no yes

  18. Synchronization: basic • Threads review • Sharing • Mutual exclusion • Semaphores

  19. badcnt.c: Improper Synchronization volatile intcnt = 0; /* global */ intmain(intargc, char **argv) { int niters = atoi(argv[1]); pthread_t tid1, tid2; Pthread_create(&tid1, NULL, thread, &niters); Pthread_create(&tid2, NULL, thread, &niters); Pthread_join(tid1, NULL); Pthread_join(tid2, NULL); /* Check result */ if (cnt != (2 * niters)) printf("BOOM! cnt=%d\n”, cnt); else printf("OKcnt=%d\n", cnt); exit(0); } /* Thread routine */ void *thread(void *vargp) { inti, niters = *((int *)vargp); for (i = 0; i < niters; i++) cnt++; return NULL; } linux> ./badcnt 1000000 OK cnt=2000000 linux> ./badcnt 100000 BOOM! cnt=1302251 linux> cnt should equal 2,000,000. What went wrong?

  20. Assembly Code for Counter Loop C code for counter loop in thread i for (i=0;i < niters; i++) cnt++; Corresponding assembly code movl (%rdi),%ecx movl $0,%edx cmpl %ecx,%edx jge .L13 .L11: movlcnt(%rip),%eax incl %eax movl %eax,cnt(%rip) incl %edx cmpl %ecx,%edx jl .L11 .L13: Head (Hi) Load cnt (Li) Update cnt (Ui) Store cnt (Si) Tail (Ti)

  21. Concurrent Execution • Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! • Ii denotes that thread i executes instruction I • %eaxiis the content of %eax in thread i’s context i (thread) instri %eax1 %eax2 cnt 1 H1 - - 0 Thread 1 critical section 1 L1 0 - 0 1 U1 1 - 0 Thread 2 critical section 1 S1 1 - 1 2 H2 - - 1 2 L2 - 1 1 2 U2 - 2 1 2 S2 - 2 2 2 T2 - 2 2 OK 1 T1 1 - 2

  22. Concurrent Execution (cont) • Incorrect ordering: two threads increment the counter, but the result is 1 instead of 2 i (thread) instri %eax1 %eax2 cnt 1 H1 - - 0 1 L1 0 - 0 1 U1 1 - 0 2 H2 - - 0 2 L2 - 0 0 1 S1 1 - 1 1 T1 1 - 1 2 U2 - 1 1 2 S2 - 1 1 Oops! 2 T2 - 1 1

  23. Concurrent Execution (cont) • How about this ordering? • We can analyze the behavior using a progress graph i (thread) instri %eax1 %eax2 cnt 0 1 H1 0 1 L1 2 H2 0 2 L2 1 2 U2 1 1 2 S2 1 1 U1 1 1 1 S1 1 T1 Oops! 1 2 T2

  24. Progress Graphs A progress graphdepicts the discrete execution state space of concurrent threads. Each axis corresponds to the sequential order of instructions in a thread. Each point corresponds to a possible execution state (Inst1, Inst2). E.g., (L1, S2) denotes state where thread 1 has completed L1 and thread 2 has completed S2. Thread 2 T2 (L1, S2) S2 U2 L2 H2 Thread 1 H1 L1 U1 S1 T1

  25. Trajectories in Progress Graphs Thread 2 A trajectory is a sequence of legal state transitions that describes one possible concurrent execution of the threads. Example: H1, L1, U1, H2, L2, S1, T1, U2, S2, T2 T2 S2 U2 L2 H2 Thread 1 H1 L1 U1 S1 T1

  26. Critical Sections and Unsafe Regions Thread 2 L, U, and S form acritical section with respect to the shared variable cnt Instructions in critical sections (wrt to some shared variable) should not be interleaved Sets of states where such interleaving occurs form unsafe regions T2 S2 critical section wrtcnt U2 Unsafe region L2 H2 Thread 1 H1 L1 U1 S1 T1 critical section wrtcnt

  27. Critical Sections and Unsafe Regions Thread 2 safe Def:A trajectory is safe iffit does not enter any unsafe region Claim:A trajectory is correct (wrtcnt) iff it is safe T2 S2 critical section wrtcnt U2 Unsafe region unsafe L2 H2 Thread 1 H1 L1 U1 S1 T1 critical section wrtcnt

  28. Enforcing Mutual Exclusion • Question: How can we guarantee a safe trajectory? • Answer: We must synchronizethe execution of the threads so that they never have an unsafe trajectory. • i.e., need to guarantee mutually exclusive access to critical regions • Classic solution: • Semaphores (EdsgerDijkstra) • Other approaches (out of our scope) • Mutex and condition variables (Pthreads) • Monitors (Java)

  29. Synchronization: basic • Threads review • Sharing • Mutual exclusion • Semaphores

  30. Semaphores • Semaphore: non-negative global integer synchronization variable • Manipulated by P and V operations: • P(s):[ while (s == 0) wait(); s--; ] • Dutch for "Proberen" (test) • V(s): [ s++; ] • Dutch for "Verhogen" (increment) • OS kernel guarantees that operations between brackets [ ] are executed indivisibly • Only one P or V operation at a time can modify s. • When while loop in P terminates, only that P can decrement s • Semaphore invariant: (s >= 0)

  31. C Semaphore Operations Pthreads functions: #include <semaphore.h> intsem_init(sem_t *sem, 0, unsigned intval);} /* s = val */ intsem_wait(sem_t *s); /* P(s) */ intsem_post(sem_t *s); /* V(s) */ CS:APP wrapper functions: #include "csapp.h” void P(sem_t *s); /* Wrapper function for sem_wait */ void V(sem_t *s); /* Wrapper function for sem_post */

  32. badcnt.c: Improper Synchronization volatile intcnt = 0; /* global */ intmain(intargc, char **argv) { int niters = atoi(argv[1]); pthread_t tid1, tid2; Pthread_create(&tid1, NULL, thread, &niters); Pthread_create(&tid2, NULL, thread, &niters); Pthread_join(tid1, NULL); Pthread_join(tid2, NULL); /* Check result */ if (cnt != (2 * niters)) printf("BOOM! cnt=%d\n”, cnt); else printf("OKcnt=%d\n", cnt); exit(0); } /* Thread routine */ void *thread(void *vargp) { inti, niters = *((int *)vargp); for (i = 0; i < niters; i++) cnt++; return NULL; } How can we fix this using semaphores?

  33. Using Semaphores for Mutual Exclusion • Basic idea: • Associate a unique semaphore mutex, initially 1, with each shared variable (or related set of shared variables). • Surround corresponding critical sections with P(mutex) and V(mutex) operations. • Terminology: • Binary semaphore: semaphore whose value is always 0 or 1 • Mutex:binary semaphore used for mutual exclusion • P operation: “locking” the mutex • V operation: “unlocking” or “releasing” the mutex • “Holding” a mutex: locked and not yet unlocked. • Counting semaphore: used as a counter for set of available resources.

  34. goodcnt.c: Proper Synchronization • Define and initialize a mutex for the shared variable cnt: volatile intcnt = 0; /* Counter */ sem_t mutex; /* Semaphore that protects cnt */ Sem_init(&mutex, 0, 1); /* mutex = 1 */ • Surround critical section with P and V: for (i = 0; i < niters; i++) { P(&mutex); cnt++; V(&mutex); } linux> ./goodcnt 1000000 OK cnt=2000000 linux> ./goodcnt 1000000 OK cnt=2000000 linux> Warning: It’s much slower than badcnt.c.

  35. 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 Why Mutexes Work Thread 2 Provide mutually exclusive access to shared variable by surrounding critical section with P and V operations on semaphore s(initially set to 1) Semaphore invariant creates a forbidden region that encloses unsafe region that cannot be entered by any trajectory. T2 V(s) Forbidden region 0 0 0 0 -1 -1 -1 -1 S2 0 0 0 0 -1 -1 -1 -1 Unsafe region U2 0 0 0 0 -1 -1 -1 -1 L2 -1 -1 -1 -1 0 0 0 0 P(s) H2 Thread 1 H1 P(s) L1 U1 S1 V(s) T1 Initially s = 1

  36. Summary • Programmers need a clear model of how variables are shared by threads. • Variables shared by multiple threads must be protected to ensure mutually exclusive access. • Semaphores are a fundamental mechanism for enforcing mutual exclusion.

  37. 2. Synchronization: Advanced

  38. Synchronization: advanced • Producer-consumer problem • Thread safety • Races • Deadlocks

  39. Using Semaphores to Schedule Access to Shared Resources • Basic idea: Thread uses a semaphore operation to notify another thread that some condition has become true • Use counting semaphores to keep track of resource state. • Use binary semaphores to notify other threads. • Two classic examples: • The Producer-Consumer Problem • The Readers-Writers Problem

  40. Producer-Consumer Problem producer thread consumer thread • Common synchronization pattern: • Producer waits for empty slot, inserts item in buffer, and notifies consumer • Consumer waits for item, removes it from buffer, and notifies producer • Examples • Multimedia processing: • Producer creates MPEG video frames, consumer renders them • Event-driven graphical user interfaces • Producer detects mouse clicks, mouse movements, and keyboard hits and inserts corresponding events in buffer • Consumer retrieves events from buffer and paints the display shared buffer

  41. Producer-Consumer on 1-element Buffer int main() { pthread_ttid_producer; pthread_ttid_consumer; /* Initialize the semaphores */ Sem_init(&shared.empty, 0, 1); Sem_init(&shared.full, 0, 0); /* Create threads and wait */ Pthread_create(&tid_producer, NULL, producer, NULL); Pthread_create(&tid_consumer, NULL, consumer, NULL); Pthread_join(tid_producer, NULL); Pthread_join(tid_consumer, NULL); exit(0); } #include “csapp.h” #define NITERS 5 void *producer(void *arg); void*consumer(void *arg); struct { intbuf; /* shared var */ sem_t full; /* sems */ sem_t empty; } shared;

  42. Producer-Consumer on 1-element Buffer Initially:empty==1, full==0 Producer Thread Consumer Thread void *producer(void *arg) { inti, item; for (i=0; i<NITERS; i++) { /* Produce item */ item = i; printf("produced %d\n", item); /* Write item to buf */ P(&shared.empty); shared.buf= item; V(&shared.full); } return NULL; } void *consumer(void *arg) { inti, item; for (i=0; i<NITERS; i++) { /* Read item from buf */ P(&shared.full); item = shared.buf; V(&shared.empty); /* Consume item */ printf("consumed %d\n“, item); } return NULL; }

  43. Producer-Consumer on an n-element Buffer • Requires a mutex and two counting semaphores: • mutex: enforces mutually exclusive access to the the buffer • slots: counts the available slots in the buffer • items: counts the available items in the buffer • Implemented using a shared buffer package called sbuf.

  44. sbufPackage - Declarations #include "csapp.h” typedefstruct { int *buf; /* Buffer array */ intn; /* Maximum number of slots */ int front; /* buf[(front+1)%n] is first item */ int rear; /* buf[rear%n] is last item */ sem_tmutex; /* Protects accesses to buf */ sem_t slots; /* Counts available slots */ sem_t items; /* Counts available items */ } sbuf_t; void sbuf_init(sbuf_t *sp, intn); void sbuf_deinit(sbuf_t *sp); void sbuf_insert(sbuf_t *sp, int item); intsbuf_remove(sbuf_t *sp); sbuf.h

  45. sbufPackage - Implementation Initializing and deinitializing a shared buffer: /* Create an empty, bounded, shared FIFO buffer with n slots */ void sbuf_init(sbuf_t *sp, intn) { sp->buf = Calloc(n, sizeof(int)); sp->n = n; /* Buffer holds max of n items */ sp->front = sp->rear = 0; /* Empty buffer iff front == rear */ Sem_init(&sp->mutex, 0, 1); /* Binary semaphore for locking */ Sem_init(&sp->slots, 0, n); /* Initially, buf has n empty slots */ Sem_init(&sp->items, 0, 0); /* Initially, buf has zero items */ } /* Clean up buffer sp */ void sbuf_deinit(sbuf_t *sp) { Free(sp->buf); } sbuf.c

  46. sbufPackage - Implementation Inserting an item into a shared buffer: /* Insert item onto the rear of shared buffer sp */ void sbuf_insert(sbuf_t *sp, int item) { P(&sp->slots); /* Wait for available slot */ P(&sp->mutex); /* Lock the buffer */ sp->buf[(++sp->rear)%(sp->n)] = item; /* Insert the item */ V(&sp->mutex); /* Unlock the buffer */ V(&sp->items); /* Announce available item */ } sbuf.c

  47. sbufPackage - Implementation Removing an item from a shared buffer: /* Remove and return the first item from buffer sp */ intsbuf_remove(sbuf_t *sp) { int item; P(&sp->items); /* Wait for available item */ P(&sp->mutex); /* Lock the buffer */ item = sp->buf[(++sp->front)%(sp->n)]; /* Remove the item */ V(&sp->mutex); /* Unlock the buffer */ V(&sp->slots); /* Announce available slot */ return item; } sbuf.c

  48. Case Study: Prethreaded Concurrent Server Pool of worker threads Service client Client Worker thread Insert descriptors Master thread Accept connections Remove descriptors Buffer ... ... Client Worker thread Service client

  49. Prethreaded Concurrent Server sbuf_tsbuf; /* Shared buffer of connected descriptors */ intmain(intargc, char **argv) { inti, listenfd, connfd, port; socklen_tclientlen=sizeof(structsockaddr_in); structsockaddr_inclientaddr; pthread_ttid; port = atoi(argv[1]); sbuf_init(&sbuf, SBUFSIZE); listenfd = Open_listenfd(port); for (i = 0; i < NTHREADS; i++) /* Create worker threads */ Pthread_create(&tid, NULL, thread, NULL); while (1) { connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen); sbuf_insert(&sbuf, connfd); /* Insert connfd in buffer */ } } echoservert_pre.c

  50. Prethreaded Concurrent Server Worker thread routine: void *thread(void *vargp) { Pthread_detach(pthread_self()); while (1) { intconnfd = sbuf_remove(&sbuf); /* Remove connfd from buffer */ echo_cnt(connfd); /* Service client */ Close(connfd); } } echoservert_pre.c

More Related