Embed Size (px)
DESCRIPTION
– 3 – , S’04 Why Do We Care About Thread Useful for L7 Part II A very important way to implement modern concurrent systems What’s concurrency? Web Browser Web Server Web Browser Web Browser Web Server Web Server Proxy
Citation preview
ThreadThread15213-S04, Recitation, Section A15213-S04, Recitation, Section A
Thread Memory Model Thread Interfaces (System Calls) Thread Safety (Pitfalls of Using Thread) Racing Semaphore
Final & Evaluation Forms
– 2 – 15-213, S’04
pthread_createpthread_joinpthread_selfpthread_cancelpthread_exitpthread_mutex_initpthread_mutex_[un]lockpthread_cond_initpthread_cond_[timed]wait
– 3 – 15-213, S’04
Why Do We Care About ThreadUseful for L7 Part II
A very important way to implement modern concurrent systems
What’s concurrency?
WebBrowser
WebServer
WebBrowser
WebBrowser
WebServer
WebServer
Proxy
– 4 – 15-213, S’04
Three Methods to Implement Concurrency1. Processes
Fork a child process for every incoming client connection Difficult to share data among child processes
2. Threads Create a thread to handle every incoming client connection Our focus today
3. I/O multiplexing with Unix select() Use select() to notice pending socket activity Manually interleave the processing of multiple open
connections More complex!
~ implementing your own app-specific thread package!
– 5 – 15-213, S’04
View of ProcessProcess = process context + code, data, and stack
shared libraries
run-time heap
0
read/write data
Program context: Data registers Condition code Stack pointer (SP) Program counter (PC)Kernel context: VM structures Descriptor table
Code, data, and stack
read-only code/data
stackSP
PC
Process context
– 6 – 15-213, S’04
View of ThreadMultiple threads can be associated with a process
Each thread has its own logical control flow (instruction flow) Each thread has its own thread ID (TID) Each thread shares the same code, data, and kernel context
shared libraries
run-time heap
0
read/write data
Shared code and data
read-only code/dataThread 1 context: Data registers Condition code SP1 PC1
stack 1
Thread 1 (main thread)
Kernel context: VM structures Descriptor table
Thread 2 context: Data registers Condition code SP2 PC2
stack 2
Thread 2 (peer thread)
Thread memorymodel
– 7 – 15-213, S’04
Posix Threads (Pthreads) InterfaceStandard interface for ~60 functions
Creating and reaping threads.pthread_createpthread_join
Determining your thread IDpthread_self
Terminating threadspthread_cancelpthread_exit
Synchronizing access to shared variablespthread_mutex_initpthread_mutex_[un]lockpthread_cond_initpthread_cond_[timed]wait
– 8 – 15-213, S’04
The Pthread "hello, world" Program
/* * hello.c - Pthreads "hello, world" program */#include "csapp.h"
/* thread routine */void *thread(void *vargp) { printf("Hello, world!\n"); return NULL;}
int main() { pthread_t tid;
Pthread_create(&tid, NULL, thread, NULL); Pthread_join(tid, NULL); exit(0);}
– 9 – 15-213, S’04
Execution of Threaded“hello, world”main thread
main thread waits for peer
thread to terminate
exit() terminates
main thread and any peer threads
peer thread
Call Pthread_create()
call Pthread_join()
Pthread_join() returns
printf()return NULL;(peer threadterminates)
Pthread_create() returns
– 10 – 15-213, S’04
PracticesBasic usage of thread
Pthread_exit() & exit() Joinable and detached thread
Thread safety Protecting shared variable Function that returns a static pointer (more) ……
– 11 – 15-213, S’04
pthread_exit() & exit()
void *thread(void *vargp){ pthread_exit((void*)42);}
int main(){ int i; pthread_t tid; pthread_create(&tid, NULL, thread, NULL); pthread_join(tid, (void **)&i);
printf("%d\n",i);}
Program 1.1
– 12 – 15-213, S’04
pthread_exit() & exit()Program 1.2
void *thread(void *vargp){ exit(42);}
int main(){ int i; pthread_t tid; pthread_create(&tid, NULL, thread, NULL); pthread_join(tid, (void **)&i);
printf("%d\n",i);}
– 13 – 15-213, S’04
pthread_exit() & exit()pthread_exit() only terminates the current thread, NOT
the process
Exit() terminates all the threads in the process, i.e., the process itself
– 14 – 15-213, S’04
PracticesBasic usage of thread
Pthread_exit() & exit() Joinable and detached thread
Thread safety Protecting shared variable Function that returns a static pointer (more) ……
– 15 – 15-213, S’04
Joinable & Detached ThreadsAt 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.
– 16 – 15-213, S’04
PracticesBasic usage of thread
Pthread_exit() & exit() Joinable and detached thread
Thread safety Protecting shared variable Function that returns a static pointer (more) ……
– 17 – 15-213, S’04
Protecting shared variablesProgram 1.5
int i = 42;
void *thread(void *vargp){ printf("%d\n",i); }
void *thread2(void *vargp){ i = 31; }
int main(){ pthread_t tid, tid2; pthread_create(&tid2, NULL, thread2, (void*)&i);
pthread_create(&tid, NULL, thread, (void*)&i); pthread_join(tid, (void**)&i); pthread_join(tid2, NULL);}
– 18 – 15-213, S’04
PracticesBasic usage of thread
Pthread_exit() & exit() Joinable and detached thread
Thread safety Protecting shared variable Function that returns a static pointer (more) ……
– 19 – 15-213, S’04
Functions that return a pointer to a static value
int main () {struct in_addr a, b;a.s_addr = inet_addr(“1.1.1.1”);b.s_addr = inet_addr(“2.2.2.2”);
printf(“%s %s\n”, inet_ntoa(a),inet_ntoa(b));
}
output: ???
int main () {struct in_addr a;a.s_addr = inet_addr(“1.1.1.1”);printf(“%s\n”, inet_ntoa(a));
}
Output: 1.1.1.1
– 20 – 15-213, S’04
Thread SafetyClass 1: Functions that do not protect shared variables
Class 2: Functions that keep state across multiple invocations rand() Textbook P. 886
Class 3: Functions that return a pointer to a static variable
Class 4: Functions that call thread-unsafe functions May or may not be thread-unsafe Textbook P.887
– 21 – 15-213, S’04
More Practice ProblemsProgram 1.3 & 1.4 are left for your practice
– 22 – 15-213, S’04
Racing
A race occurs when the correctness of a program depends on one thread reaching point x in its control flow before another thread reaches point y. Generally related with the access to the shared variables Need synchronization
Ways to do synchronization: Semaphores Mutual-exclusion
– 23 – 15-213, S’04
Program 2.b
void *foo(void *vargp) { int id; id = *((int *)vargp); printf("Thread %d\n", id);}
int main() { pthread_t tid[2]; int i;
for (i = 0; i < 2; i++) Pthread_create(&tid[i], NULL, foo, &i); Pthread_join(tid[0], NULL); Pthread_join(tid[1], NULL);}
Racing!
– 24 – 15-213, S’04
Program 2.avoid *foo(void *vargp) { int myid; myid = *((int *)vargp); Free(vargp); printf("Thread %d\n", myid);}
int main() { pthread_t tid[2]; int i, *ptr;
for (i = 0; i < 2; i++) { ptr = Malloc(sizeof(int)); *ptr = i; Pthread_create(&tid[i], 0, foo, ptr); } Pthread_join(tid[0], 0); Pthread_join(tid[1], 0);}
Good!
– 25 – 15-213, S’04
Program 2.c
void *foo(void *vargp) { int id; id = (int)vargp; printf("Thread %d\n", id);}
int main() { pthread_t tid[2]; int i;
for (i = 0; i < 2; i++) Pthread_create(&tid[i], 0, foo, i); Pthread_join(tid[0], 0); Pthread_join(tid[1], 0);}
Good!
– 26 – 15-213, S’04
The general solution for racingSemaphore & mutual-exclusion
Mutex is a special case for the problems that semaphore targets to solve, and thus can be implemented using semaphore
But mutex seems to be more popularly used (probably because more people understand it)
Classic solution: Dijkstra's P and V operations on semaphores. semaphore: non-negative integer synchronization variable.
P(s): [ while (s == 0) wait(); s--; ] V(s): [ s++; ]
OS 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 decrements.
Semaphore invariant: (s >= 0)
– 27 – 15-213, S’04
Program 2.dsem_t s; /* semaphore s */
void *foo(void *vargp) { int id; id = *((int *)vargp); V(&s); printf("Thread %d\n", id);}
int main() { pthread_t tid[2]; int i;
sem_init(&s, 0, 0); /* S=0 INITIALLY */
for (i = 0; i < 2; i++) { Pthread_create(&tid[i], 0, foo, &i); P(&s); } Pthread_join(tid[0], 0); Pthread_join(tid[1], 0);}
Good!
– 28 – 15-213, S’04
Program 2.esem_t s; /* semaphore s */
void *foo(void *vargp) { int id; P(&s); id = *((int *)vargp); V(&s); printf("Thread %d\n", id);}
int main() { pthread_t tid[2]; int i;
sem_init(&s, 0, 1); /* S=1 INITIALLY */
for (i = 0; i < 2; i++) { Pthread_create(&tid[i], 0, foo, &i); } Pthread_join(tid[0], 0); Pthread_join(tid[1], 0);}
Racing!
– 29 – 15-213, S’04
Summary So FarThread
Thread memory model How to write thread programs Thread safety (pitfalls of using thread)
Racing Semaphore
– 30 – 15-213, S’04
FinalTimes
Exam Time: May 3rd (Monday) 5:30pm – 8:30p UC McConomy
Review Session: May 1st (Saturday), 3:00pm
– 31 – 15-213, S’04
Evaluation FormsThere are questions on both sides
One student bring them to WH 5101
