Center for Biotechnology Bielefeld Bioinformatics Service Netzwerk - Programmierung Threads Alexander Sczyrba Jan Krüger

Center for Biotechnology Bielefeld Bioinformatics Service Übersicht ● Probleme mit fork ● Threads ● Perl threads API ● Shared Data ● Mutexes

Center for Biotechnology Bielefeld Bioinformatics Service Probleme mit fork ● fork ist teuer : ● Speicher wird für den Kindsprozess kopiert ● Alle Deskriptoren werden dupliziert ● … ● Interprocess Communication (IPC) zur Kommunikation zwischen Parent und Child nötig ● Übergabe for dem fork einfach ● Rückgabe von Informationen (Child zum Parent) schwieriger

Center for Biotechnology Bielefeld Bioinformatics Service Thread ● Auch : leightweigth process oder LWP ● Jeder Thread läuft unabhängig von anderen Threads in einem gemeinsamen Prozess ● Erzeugen von einem Thread ist x schneller als das Erzeugen eines Prozesses ● Alle Threads eines Prozesses teilen den gleichen globalen Speicher ● Vereinfacht Austausch von Daten ● Aber : Synchronisation nötig

Center for Biotechnology Bielefeld Bioinformatics Service Threads(2) ● Threads eines Prozesses teilen u.a. ● Globale Variablen ● Geöffnete Dateien (z.B. Datei Deskriptoren) ● Signal Handlers ● Jeder Thread hat u.a. eigene(n) ● Thread ID ● Register (inkl. Program counter und stack pointer) ● Stack (für lokale Variablen und Rücksprungadressen)

Center for Biotechnology Bielefeld Bioinformatics Service Aufgabe ● Der Befehl top bzw. htop zeigt Informationen über die zur Zeit laufenden Prozesse an ● – OSX (ports) : sudo ports install htop – GZI/Linux: /homes/jkrueger/.bin/htop ● starte [h]top und beobachte, welche Prozesse Threads benutzen – Achtung! Evtl. muss die Ansicht angepasst werden ● beschränke [h]top auf Deine eigene Prozesse ● starte den ServiceServer

Center for Biotechnology Bielefeld Bioinformatics Service Native Threads ● Implementation von Threads abhängig vom Betriebssystem und evtl. dessen Version ● 3 Kategorien von Threads: ● User-mode Threads ● Kernel Threads ● Mulitprocessor Kernel Threads

Center for Biotechnology Bielefeld Bioinformatics Service User mode Threads ● OS kennt keine Threads ● Auschliesslich im Programm (und dessen Bibliotheken) implementiert ● Problem ● Wenn ein Prozess blockiert, blockieren alle ● Kernel blockiert auf Prozess Ebene

Center for Biotechnology Bielefeld Bioinformatics Service Kernel Threads ● OS kennt Kernel Threads ● Blockieren eines Threads blockiert die anderen nicht ● Kernel blockiert auf Thread Ebene ● Aber: Prozess kann nicht mehrere Threads gleichzeitig laufen lassen ● Problem : Synchronisation

Center for Biotechnology Bielefeld Bioinformatics Service Erzeugen von Threads (in Perl) ● use threads; my $thr = threads->create(\&sub1, 1, „Thread 1“); sub sub1 { my $thr_no = shift; my $thr_name = shift; print „in the thread : Thread_no $thr_no ($thr_name)\n“; ● Create benötigt Referenz auf Subroutine und evtl. eine Liste von Parametern ● Thread wird in der Subroutine gestartet ● Kontrolle wird an die Subroutine und Caller übergeben

Center for Biotechnology Bielefeld Bioinformatics Service Warten auf einen Thread ● Subroutinen der Threads können Werte zurückgeben ● Warten auf einen Thread und dessen Rückgabewerte mit join ● use threads; my $thr = threads->create(\&sub1, 1, „Thread 1“); my $ret_value = $thr->join; sub sub1 { my $thr_no = shift; my $thr_name = shift; print „in the thread : Thread_no $thr_no ($thr_name)\n“;

Center for Biotechnology Bielefeld Bioinformatics Service Ignorieren eines Threads ● Kein Interesse an Rückgabewerten ? Egal, wann der Thread terminiert ? ● Detach Methode ● use threads; my $thr = threads->create(\&sub1, 1, „Thread 1“); $thr->detach; ● # do something else in the main thread sub sub1 { my $thr_no = shift; my $thr_name = shift; print „in the thread : Thread_no $thr_no ($thr_name)\n“;

Center for Biotechnology Bielefeld Bioinformatics Service Thread Methoden ● $thread = threads->self ● Thread-Objekt des aufrufenden Threads ● $id = $thread->tid() ● gibt die ID des Thread-Objekts zurück = threads->list() ● Liste aller non-joined, non-detached threads

Center for Biotechnology Bielefeld Bioinformatics Service Aufgaben ● schreibe ein Programm, das einen Thread erzeugt ● der Thread soll die globale Variable $count 500 mal inkrementieren ● gib jeweils den aktuellen Wert der Variable $count im Thread aus ● benutze an geeigneten Stellen sleep, um das Verhalten Deines Programms mit [h]top zu verfolgen ● gib die Variable nochmal aus, nachdem der Thread joined wurde ● Was fällt Dir auf?

Center for Biotechnology Bielefeld Bioinformatics Service Shared Data ● Ausnahme in Perl: ● keine Daten “shared by default” ● alle Daten werden von einem zum anderen Thread kopiert ● Shared Data mit: ● use threads; use threads::shared; ● my $foo : shared = 1; my $bar = 1; threads->create(sub { $foo++; $bar++ })->join; ● print "$foo\n"; # prints 2 since $foo is shared print "$bar\n"; # prints 1 since $bar is not shared

Center for Biotechnology Bielefeld Bioinformatics Service Aufgabe ● Ändere Dein Programm so ab, dass shared data benutzt wird ● Starte 2 Threads nacheinander, um die $count Variable bis zu inkrementieren ● Starte die Threads gleichzeitig ● Was fällt Dir auf?

Center for Biotechnology Bielefeld Bioinformatics Service Race Conditions ● use threads; use threads::shared; ● my $a : shared = 1; $thr1 = threads->new(&sub1); $thr2 = threads->new(&sub2); ● $thr1->join; $thr2->join; print "$a\n"; ● sub sub1 { my $foo = $a; $a = $foo + 1; } ● sub sub2 { my $bar = $a; $a = $bar + 1; }

Center for Biotechnology Bielefeld Bioinformatics Service Mutexes ● bei shared data ist Synchronisation zwischen Threads nötig ● Sperren einer shared Variable durch Mutex (mutual exclusion) möglich ● Zugriff auf Variable erfolgt erst nach Erhalt der Mutex ● der Versuch, eine bereits gesperrte Variable zu sperren, blockiert ● #include ● int pthread_mutex_lock(pthread_mutex_t *mptr); int pthread_mutex_unlock(pthread_mutex_t *mptr);

Center for Biotechnology Bielefeld Bioinformatics Service Synchronisation in Perl ● Perl benutzt andere Techniken zum Sperren von Variablen ● lock() Funktion sperrt Variable ● kein unlock() in Perl, sperrt bis Variable out of scope ist ● use threads; use threads::shared; ● my $count : shared = 0; my $thr = threads->create(&calc); ● sub calc { lock($count); # block until we obtain the lock $count = $count+1; }

Center for Biotechnology Bielefeld Bioinformatics Service Aufgabe ● Ändere Dein Counter-Programm so ab, dass die Variable vorher gesperrt wird. Bekommst Du jetzt das erwartete Ergebnis?