Thread per Request Thread per Connection Thread per Object

Softwareentwicklung in verteilten Umgebungen, Teil 7
Operating System Support
(Coulouris et al., Kapitel 7)
Dieter Schmalstieg
Jens Grubert
Partly based on material by Victor García Barrios
Dieter Schmalstieg SVU – Processes and Threads

Prozesse im Betriebssystem
• Prozess = in Ausführung befindliches Programm
– Eine bestimmte Aktivität
– Eigener Adressraum pro Prozess
– Schutz vor Störung d. andere Prozesse (kernel mode)
• Granularität oft unzureichend
– Speziell bei viel Nebenläufigkeit im verteilten System
Dieter Schmalstieg SVU – Processes and Threads

Ausführung
Prozesse im Betriebssystem
– Prozess definiert durch
Execution State
– Scheduling durch OS
– Prozess erzeugen,
umschalten ist teuer
[Public Domain]
Dieter Schmalstieg SVU – Processes and Threads

Teure Administration von Prozessen
• Betriebssystem muss Prozesse verwalten
und sichern
– CPU Kontext (Registerwerte, Zähler,
Stackpointer, ..)
– Memory Management Unit Register
– Caches (TLB translation lookaside buffer, ..)
• Mehr Prozesse als Hauptspeicher
� auf Festplatte auslagern
Dieter Schmalstieg SVU – Processes and Threads

Kernel Space and User Space
User Space:
user applications
Kernel Space
Device control, Process, Thread and
Memory Management, …
Hardware
Dieter Schmalstieg SVU – Processes and Threads

Kontextumschaltungen bei Prozessen
A muss deaktiviert werden:
� Benutzermodus � Kernelmodus
� Umschaltung zw. Prozesskontexten im Kernelraum
� Kernelmodus � Benutzermodus � B aktiviert!
Dieter Schmalstieg SVU – Processes and Threads

Prozesse vs. Threads
• Prozess verantwortlich für
– Resourcen (State)
– Datenintegrität
• Threads of Execution
– Innerhalb eines Prozesses
– Gemeinsamer Addressraum
– Gleichzeitige Ausführung
– Gemeinsamer Prozess-State
– Minimaler Thread-Kontext
• CPU, Scheduling-Information, Synchronization
– Kein Schutz der Threads untereinander
Dieter Schmalstieg SVU – Processes and Threads

Multi-Threading Eigensschaften
• Thread = unabhängiger Kontrollfluss
• Threads innerhalb Prozess teilen Daten
Zugriffe der Threads synchronisieren!
• Wenn ein Thread blockiert, kann ein anderer
weitermachen
• Threads können sich 1..n Prozessoren teilen
• Thread-Support durch OS oder Middleware
oder Programmiersprache
• Kommunikation Thread-Thread billiger als IPC
Dieter Schmalstieg SVU – Processes and Threads

Threads als Softwaredesign-Werzeug
• Parallelismus innerhalb der Anwendung
• Server
– Verwalten mehrerer eingehender Nachrichten
• Client
– 1 Thread für User Interface
– 1 Thread erledigt Hintergrundarbeiten
• Allgemein asynchrone Verarbeitung
– Z.B. automatisches Sichern
Dieter Schmalstieg SVU – Processes and Threads

Probleme mit Threads
• Synchronisation von Threads
• Vermeiden von Deadlocks
• Fairness
• Effiziente Nutzung der Resourcen
– Kein exzessives Threading
– Kosten für Thread Switching
Dieter Schmalstieg SVU – Processes and Threads

User Level Threads
• Thread-Bibliothek ausserhalb des Kernels
– Scheduling, Speichern/Wiederherstellen
– Kernel weiss nichts von Threads
• Vorteile
– Schnelles Erstellen und Umschalten
– Applikationsspezifisches Scheduling
– OS-unabhängig
• Nachteile
– Blocking Call blockiert alle Threads im Prozess
– Nutzung von Multiprocessing nicht garantiert
Dieter Schmalstieg SVU – Processes and Threads

Kernel Level Threads
• Kernel verwaltet Thread Contexts
• Scheduling für alle Threads im Kernel
• Vorteile
– Ein Thread blockiert andere nicht
– Multiprocessing möglich
• Nachteil
– Nur Kernel-Systemaufrufe als API � teuer
• � Hybride User Level / Kernel Level durch
möglich
Dieter Schmalstieg SVU – Processes and Threads

System Call vs Local RPC vs Remote RPC
(a) System call
Thread
User Kernel
Control transfer via
trap instruction
Control transfer via
privileged instructions
Protection domain
Dieter Schmalstieg SVU – Processes and Threads

System Call vs Local RPC vs Remote RPC
(a) System call
Thread
(b) RPC/RMI (within one computer)
User Kernel
Thread 1 Thread 2
User 1 Kernel
User 2
Control transfer via
trap instruction
Control transfer via
privileged instructions
Protection domain
boundary
Dieter Schmalstieg SVU – Processes and Threads

System Call vs Local RPC vs Remote RPC
(a) System call
Thread
(b) RPC/RMI (within one computer)
(c) RPC/RMI (between computers)
User Kernel
Thread 1 Thread 2
User 1 Kernel User 2
Control transfer via
trap instruction
Control transfer via
privileged instructions
Protection domain
boundary
Thread 1 Network Thread 2
User 1 User 2
Kernel 1
Kernel 2
Dieter Schmalstieg SVU – Processes and Threads

Lightweight remote procedure call
Client
1. Copy args
User stub
Kernel
Shared memory statt marshalling/unmarshalling möglich
A stack
2. Trap to Kernel
A
Server
4. Execute procedure
and copy results
Dieter Schmalstieg SVU – Processes and Threads
stub
3. Upcall 5. Return (trap)

Multi-Threaded Clients and Servers
Dieter Schmalstieg SVU – Processes and Threads

Thread 1
generates
results
Clients und Server mit Threads
T1
Client
Thread 2 makes
requests to server
Receipt &
queuing
Requests
N threads
Server
Input-output
• Typisch bei Client: User Interface,
Verarbeitung, Netzwerkkomm.
• Typisch bei Server: Mehrere Clients, mehrere
Verbindungen
Dieter Schmalstieg SVU – Processes and Threads

Client mit Multi-Threading
• Interaktion mit User und Server parallel
– Keine Blockierung der User-Interaktion
• Lokale Datenverarbeitung
• Verbergen von Kommunikationslatenz
– Andere Aktivität parallel durchführen
– Z.B. Webbrowser: Page Refresh
• Lastausgleich (erfordert Koop. des Servers)
– Verbindung zu replizierten Servern
– Paralleler Datentransfer
Dieter Schmalstieg SVU – Processes and Threads

Multi-Threaded Server
• Server kann iterativ oder multi-threaded sein
Server State: ja/per-session/nein/soft
• Multi-Threaded Server Design
– Einfacher strukturierter Code
– Bessere Performance auf Multiprozessoren
• Auffinden des Servers
– Directory Service
– Well known ports (0-1023)
Dieter Schmalstieg SVU – Processes and Threads

Threads als
Verbindungsabstraktion
• Multi-threaded Server:
– Dispatcher/Worker (worker pool) Modell
– Eingehende Anforderungen � Dispatcher Thread
(= Anprechpartner für Client)
– Anforderung wird ausgewertet � Auswahl eines freien
Worker Threads � Übergabe der Anforderung
Dieter Schmalstieg SVU – Processes and Threads

Server Thread Design Patterns
• Verschiedene Server-Architekturen
• Wer erzeugt die Threads?
• Wann wird ein Thread erzeugt?
• Wieviele Threads gibt es?
Dieter Schmalstieg SVU – Processes and Threads

Anzahl der Threads
• Fixe Anzahl oder dynamische Anzahl?
• Erzeugung/Zerstörung von Threads teuer
• Wiederverwendung von Threads
– Idee eines Thread Pool
– Threads werden am Anfang erzeugt
– Nicht benötigte Threads werden „geparkt“
Dieter Schmalstieg SVU – Processes and Threads

I/O
Architekturen für Threaded Server
workers
remote
objects
per-connection threads per-object threads
remote
objects
a. Thread-per-request b. Thread-per-connection c. Thread-per-object
remote
objects
Dieter Schmalstieg SVU – Processes and Threads
I/O

• Dispatcher
Thread Per Request
– Empfängt Anfragen
– Für jede Anfrage wird ein Worker
Thread erzeugt/rekrutiert
• Worker Thread
– Dekodiert Anfrage
– Bearbeitet Anfrage
– Beantwortet Anfrage
– Ende
Dieter Schmalstieg SVU – Processes and Threads

• Dispatcher Thread
Thread per Connection
– Erkennt neuen Client
– Verbindet Client mit neuem/rekrutiertem Worker
Thread
• Worker Thread
– Dekodiert Anfrage
– Bearbeitet Anfrage
– Beantwortet Anfrage
– Wartet auf nächste Anfrage
dieses Clients
Dieter Schmalstieg SVU – Processes and Threads

Thread per Object
• Jeder Servant (Service-Objekt) hat
– eigenen Thread, Queue
• Dispatcher
– Empfängt Anfrage, reiht Anfrage in
richtige Queue ein
• Servant Thread
– Liest Anfrage aus Queue
– Führt Anfrage aus
– Serialization auf der Queue
• Nachteil: Ungenutzte Threads wenn
Dieter Schmalstieg SVU – Processes and Threads

Threaded Server Architekturen
Thread per Request Thread per Connection Thread per Object
Threaderstellung teuer
(besonders für wenig
Rechenintensive Aufgaben)
Ineffizient wenn eine
Clientanfrage
rechenintensiv ist aber
ressourcen für verfügbare
threads > clients
Ineffizient wenn
Objectmethoden
rechenintensiv sind aber
ressourcen für verfügbare
threads > Objects
Dieter Schmalstieg SVU – Processes and Threads