Multithread Programming

Transkript

1 Vorlesung Rechnerarchitektur 2 Seite 150 Threads versus Processes Processes execute in separate address spaces (schwergewichtige Prozesse) communicate via IPC mechanisms (sockets, pipes, signals) Thread execute in a common address space (leichtgewichtige Prozesse) communicate via shared memory (global shared variables) The thread model takes a process and divides it into two parts: One contains resources used across the whole program (processwide information) such as programm instructions and global data. This part is still referred as process. The other contains information related to the execution state, such as the program conter, a stack and local data. This part is referred to as a thread. Why use threads? Creating a new process (fork and exec under UNIX) can be expensive and time consuming. A call into the operating system must be performed, which involves context switching rescheduling and a lot more activities. The entire process must be replicated (a new address space). The communication and synchronization must be performed over address space boundaries and thus involves the operating system kernel. Every synchronization and communication is a very expensive trap into the OS. Threads can be created without replicating an entire process. Only the execution state must be created. Creating a thread is done in the user space (same address space) rather than in kernel space. Communication is done via shared variables and also synchronization stays within the user address space by using synchronization variables and mutual exclusion. Using threads is much more efficient than processes. Threads can be implemented at the operating system level or at the user level. Thread at user level are realized by a thread library which handles threads whichout the involvement of the operating system, e.g. the thread scheduling is performed as a user thread within the user process. Thread switching is thus much faster than a process switch.

2 Vorlesung Rechnerarchitektur 2 Seite 151 Implementations PThreads POSIX threads IEEE Standard POSIX Section c Mach Threads Based on the functions supplied by the MACH Kernel NT Threads Windows NT specific Qt Threads Built-in thread support in the Qt library and Linuxthreads (Posix-conform), Solaris-Threads, NPTL, NGTL, PThreads language extension by library C-Language + thread function library + headerfile programming types function calls platform independend Goals exploiting potential parallelism overlapping I/O latencies handle asynchronous events real-time scheduling

3 Vorlesung Rechnerarchitektur 2 Seite 152 Execution Models The boss/worker model A single thread, the boss, accepts input for the entire program. Based on that input, the boss passes off specific tasks to one or more worker threads. The peer model In the peer ( Gleichberechtigte ) model, also known as the workcrew model, one thread must create all the other peer threads when the program starts. This thread subsequently acts as just another peer thread that work attracts, or suspends itself waiting for the other peers to finish. The pipeline model In the pipeline mode, each threads works at a different stage in the processing chain. All the pipeline assumptions must be met (s.a. RA1). Virtual Address Space Registers SP PC GPR0 GPR1 Thread 1 do_one_thing() i j x Stack Registers SP PC GPR0 GPR1 Thread 2 do_another_thing() i j x Stack Identity PID UID GID GPR1 Thread main main() do_one_thing() do_another_thing() Text Resources Open Files Locks Sockets r1 r2 Data Heap

4 Vorlesung Rechnerarchitektur 2 Seite 153 Example Program (sequential version) #include <stdio.h> void do_one_thing(int *); void do_another_thing(int *); void do_wrap_up(int, int); int r1 = 0, r2 = 0; void main() do_one_thing( &r1 ); do_another_thing( &r2 ); do_wrap_up(r1, r2); void do_one_thing(int *pnum_times) int i, j, x; for (i=0; i<4; i++) printf("doing one thing\n"); for (j=0; j<10000; j++) x += i; // wait some time (*pnum_times)++; void do_another_thing(int *pnum_times) int i, j, x; for (i=0; i<4; i++) printf("doing another thing\n"); for (j=0; j<10000; j++) x += i; // wait some time (*pnum_times)++; void do_wrap_up(int one_times, int another_times) int total; total = one_times + another_times; printf("wrap up: one thing %d, another %d, total %d\n", one_times, another_times, total);

5 Vorlesung Rechnerarchitektur 2 Seite 154 Example Program (threaded version) #include <stdio.h> #include <pthread.h> void do_one_thing(int *); void do_another_thing(int *); void do_wrap_up(int, int); int r1 = 0, r2 = 0; main() pthread_t thread1, thread2; pthread_create(&thread1, // 1 parameter NULL, // 2 parameter (void *) do_one_thing, // 3 parameter (void *) &r1); // 4 parameter pthread_create(&thread2, NULL, (void *) do_another_thing, (void *) &r2); pthread_join(thread1, NULL); //wait for termination of thread pthread_join(thread2, NULL); //wait for termination of thread do_wrap_up(r1, r2); // functions from last example Man-pages int pthread_create( pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg); int pthread_join( pthread_t th, void **thread_return);

6 Vorlesung Rechnerarchitektur 2 Seite 155 Posix-Threads (1) sind unabhängige Befehlssequenzen innerhalb eines Prozesse teilen sich alle Resourcen (Speicher, Filedeskriptoren,) eines Prozesses Vorteile erhöhter Durchsatz Ausnutzung von Shared-Memory-Systemen mit mehreren Prozessoren, vermeiden von Deadlocks Einbindung Deklarationen in pthread.h Linken der Library libpthread Erzeugen eines Threads int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_fkt)(void *), void *arg); thread liefert die Thread-ID des gestarteten Threads attr enthält Attribute des Threads (wenn NULL, werden Default-Werte angenommen, ansonsten Scheduling und detachstate einstellbar) start_fkt arg

7 Vorlesung Rechnerarchitektur 2 Seite 156 Posix-Threads (2) Beenden eines Threads void pthread_exit(void *status); status kann von einen wartenden Thread verarbeitet werden. Ein return aus der Startroutine beendet Threads ebenso. Warten auf die Beendigung eines Threads int pthread_join(pthread_t thread, void **status); Weitere Funktionen pthread_t pthread_self(); // liefert eigene ID int pthread_equal(pthread_t t1,pthread_t t2); // vergleicht zwei Threads

8 Vorlesung Rechnerarchitektur 2 Seite 157 Posix-Threads (3) The Producer/Consumer Example The Producer and Consumer in the following example share data through a common data object. If neither the Producer nor the Consumer makes any effort whatsoever to ensure that the Consumer is getting each value produced once and only once (whithout while loop). However, let s assume for a moment that these two threads make no arrangements for synchronization and talk about the potential problems that might arise in that situation. One problem arises when the Producer is quicker than the Consumer and generates two numbers before the Consumer has a chance to consume the first one. Thus the Consumer would skip a number because it is overwritten before it could be consumed. Another problem that might arise is when the Consumer is quicker than the Producer and consumes the same value twice. data = i write data i = data read = 1 count = 0 Producer void producer(int *arg) int i, n = *arg; for (i=1; i<=n; i++) ; while (count == 1) ; data = i; count = 1; Consumer void consumer(int *arg) int i = 0, n = *arg; while (1) ; while (count == 0) ; i = data; count = 0; produced++; consumed++; if (i == n) return; Problem weakly ordered Speicherzugriffe: Laufen die Threads Consumer und Producer nebenläufig, so kann es passieren, dass der Consumer einen bereits geänderten count Wert sieht, aber noch die alten Daten verwenden würde --> Synchronisation durch eine Speicherbarriere notwendig (PowerPC620 special instruction sync to force all issued store instruction to complete)

9 Vorlesung Rechnerarchitektur 2 Seite 158 Posix-Threads (4) Producer/Consumer: Erweiterung der Speicherzelle zur Datenweitergabe in einen Ringpuffer. #define next(x) (( (x) + 1) % BUF_SIZE) data buf[buf_size]; int rdptr = 0, wrptr = 0; rdptr Queue wrptr + buffer size Producer while (work_to_do) buf[wrptr] = produce(); while (next(wrptr)==rdptr) (); wrptr = next(wrptr); Consumer while (work_to_do) while (wrptr == rdptr) (); consume(buf[rdptr]); rdptr = next(rdptr); (wrptr == rdptr) empty ring buffer queue (next(wrptr)==rdptr) full ring buffer queue Es existiert immer ein leerer Buffer, in den geschreiben werden kann! Problem Sobald mehr als ein Producer oder auch mehr als ein Consumer eingesetzt wird, funktioniert das Programm nicht mehr, da das Lesen und Ändern des wrptr oder des rdptr nicht atomar erfolgen. Lösung: Synchronisation Siehe auch:

10 Vorlesung Rechnerarchitektur 2 Seite 159 Posix-Threads (5) Mutex - garantiert die exclusive Ausführung kritischer Code-Sequenzen Das Mutexobjekt mutex wird mittels pthread_mutex_lock() gesperrt. Sollte der Mutex schon gelockt sein, blockiert der aufrufende Thread bis der Mutex verfügbar ist. pthread_mutex_t mutex; int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); //EBUSY if locked int pthread_mutex_unlock(pthread_mutex_t *mutex); Initialisierung int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); //dynamic pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //static Löschen eines Mutex int pthread_mutex_destroy(pthread_mutex_t *mp); Lock/Unlock int pthread_mutex_trylock(pthread_mutex_t *mp); int pthread_mutex_lock(pthread_mutex_t *mp); int pthread_mutex_unlock(pthread_mutex_t *mp); Ein Thread, welcher einen Mutex lockt, ist sein Besitzer. Nur der Besitzer kann einen Mutex unlocken.

11 Vorlesung Rechnerarchitektur 2 Seite 160 Posix-Threads (6) Consumer/Producer mit Mutex Producer while (work_to_do) pthread_mutex_lock(&mutex); buf[wrptr] = produce(); while (next(wrptr)==rdptr) ; wrptr = next(wrptr); pthread_mutex_unlock(&mutex); Consumer while (work_to_do) pthread_mutex_lock(&mutex); while (wrptr == rdptr) ; consume(buf[rdptr]); rdptr = next(rdptr); pthread_mutex_unlock(&mutex); Problem: Das Beispiel funktioniert dann nicht, wenn der Consumer auf eine leere Queue testet, oder der Producer auf eine volle Queue trift. Die Semaphore-Variable wird dann nicht mehr freigegeben. Vorsicht bei der Verwendung automatischer Variablen als Argumente bzw. Ergebnissen von Threads: pthread_t t; void *g(int *i) int res; // Speicherplatz im Stack!!! /* berechnet irgendwas, benutzt dabei *i, Ergebnis in res */ return &res; // das geht nicht gut! Warum? void f() int a = 7; pthread_create(&t, NULL, g, &a); // auch das geht nicht gut! Warum?

12 Vorlesung Rechnerarchitektur 2 Seite 161 Posix-Threads (7) Condition Variable - warten auf Ereignisse Initialisierung pthread_cond_t cond; int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr); pthread_cond_t cond = PTHREAD_COND_INITIALIZER; Löschen int pthread_cond_destroy(pthread_cond_t *cond); Warten auf ein Ereignis int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); Blockiert den aufrufenden Thread bis ein anderer Thread das Eintreten des Ereignisses cond signalisiert. Der Mutex mutex wird unlocked bei Aufruf von pthread_cond_wait und wieder gelockt, bevor die Funktion beendet wird. Signalisieren int pthread_cond_signal(pthread_cond_t *cond); Busy-wait ohne Condition-Variable for(;;) pthread_mutex_lock(mutex); if (cond) break; pthread_mutex_unlock(mutex); <hier ist die Bedingung erfüllt> pthread_mutex_unlock(mutex); Nachteile: verbraucht sehr viel Resourcen, verlangt Programmierdisziplin Version mit Condition-Variable pthread_mutex_lock(mutex); pthread_cond_wait(cond,mutex); <hier ist die Bedingung erfüllt> pthread_mutex_unlock(mutex); Es ist möglich, daß ein pthread_cond_signal mehr als einen Thread aufweckt, ebenso kann ein pthread_cond_wait scheitern. Daher sollte nach dem Aufruf von pthread_cond_wait getestet werden, ob die Bedingung auch wirklich erfüllt ist.

13 Vorlesung Rechnerarchitektur 2 Seite 162 Posix-Threads (8) Beispiel FIFO-Queue für Datenpointer. Es soll für beliebig viele Thread möglich sein, Pointer in das FIFO einzufügen bzw. zu entnehmen. #include <unistd.h> #include <string.h> #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define QSIZE 10 /* number of pointers in the queue */ typedef struct pthread_mutex_t buf_lock; /* lock the structure */ int start_idx; /* start of valid data */ int num_full; /* # of full locations */ pthread_cond_t notfull; /* full -> not full condition */ pthread_cond_t notempty; /* empty -> notempty condition */ void *data[qsize]; /* Circular buffer of pointers */ circ_buf_t; circ_buf_t *new_cb() circ_buf_t *cbp; cbp = (circ_buf_t *) malloc(sizeof (circ_buf_t)); if (cbp == NULL) return (NULL); pthread_mutex_init(&cbp->buf_lock, NULL); pthread_cond_init(&cbp->notfull, NULL); pthread_cond_init(&cbp->notempty, NULL); cbp->start_idx = 0; cbp->num_full = 0; return (cbp); void delete_cb(circ_buf_t *cbp) pthread_mutex_destroy(&cbp->buf_lock); pthread_cond_destroy(&cbp->notfull); pthread_cond_destroy(&cbp->notempty); free(cbp); new_cd legt einen neuen Puffer an und initialisiert den Mutex buf_lock und die Condition-Variables notfull und notempty. delete_cb löscht den Mutex und die Condition-Variables und anschließend den Puffer.

14 Vorlesung Rechnerarchitektur 2 Seite 163 Posix-Threads (9) void put_cb_data(circ_buf_t *cbp, void *data) pthread_mutex_lock(&cbp->buf_lock); /* wait while the buffer is full */ while (cbp->num_full == QSIZE) pthread_cond_wait(&cbp->notfull, &cbp->buf_lock); cbp->data[(cbp->start_idx + cbp->num_full) % QSIZE] = data; cbp->num_full += 1; pthread_cond_signal(&cbp->notempty); pthread_mutex_unlock(&cbp->buf_lock); void *get_cb_data(circ_buf_t *cbp) void *data; pthread_mutex_lock(&cbp->buf_lock); /* wait while there's nothing in the buffer */ while (cbp->num_full == 0) pthread_cond_wait(&cbp->notempty, &cbp->buf_lock); data = cbp->data[cbp->start_idx]; cbp->start_idx = (cbp->start_idx + 1) % QSIZE; cbp->num_full -= 1; pthread_cond_signal(&cbp->notfull); pthread_mutex_unlock(&cbp->buf_lock); return (data); put_cb_data fügt einen Datenpointer data in den Puffer cbp ein. Dazu wird wie folgt vorgegangen: Zuerst wird der Puffer gelockt. Dann wird gewartet, bis Platz im Puffer ist. Anschließend wird das Datum in den Puffer eingefügt, evtl. wartenden Threads signalisiert, daß der Puffer jetzt nicht leer ist, und schließlich wird der Lock auf den Puffer wieder freigegeben. get_cb_data liefert das älteste Datum im Puffer. Dazu wird zuerst der Puffer gelockt. Dann wird gewartet, bis der Puffer nicht leer ist. Anschließend wird das Datum dem Puffer entnommen, evtl. wartenden Threads signalisiert, daß der Puffer jetzt nicht voll ist, und zuletzt wird der Puffer freigegeben und das Datum zurückgeliefert.