verteilte und parellele eingebettete...

Verteilte und Parellele Eingebettete SystemeMit Digitallogik und High-level Synthese

PD Stefan BosseUniversität Bremen, FB Mathematik & Informatik

SS 20182018-07-18

[email protected]

1. Inhalt

1. Inhalt 32. Überblick 3

2.1. Schwerpunkte in diesem Kurs . . . . . . . . . . . . . . . . . . . . 42.2. Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.3. Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4. Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.5. Inhalte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3. Einführung in die verteilte und parallele Datenverarbeitung 103.1. Verteilte vs. Parallele Systeme . . . . . . . . . . . . . . . . . . . . 103.2. Verteilte Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.3. Parallele Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.4. Sequenzielle vs. parallele Datenverarbeitung . . . . . . . . . . . . 21

4. Das Prozessmodell 214.1. Funktionale Komposition . . . . . . . . . . . . . . . . . . . . . . . 224.2. Sequenzielle Komposition . . . . . . . . . . . . . . . . . . . . . . . 234.3. Zustände und Zustandsdiagramm . . . . . . . . . . . . . . . . . . 254.4. Sequenzieller Prozess . . . . . . . . . . . . . . . . . . . . . . . . . 264.5. Parallele Komposition . . . . . . . . . . . . . . . . . . . . . . . . . 294.6. Prozessfluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.7. Metaprozesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.8. Kommunizierende Sequenzielle Prozesse . . . . . . . . . . . . . . . 334.9. Geteilte Ressourcen und Kommunikation . . . . . . . . . . . . . . 344.10. Prozessmehrfachauswahl . . . . . . . . . . . . . . . . . . . . . . 364.11. CSP Modell und Prozessalgebra . . . . . . . . . . . . . . . . . . 38

5. Zustands-Raum Diagramme 405.1. Nebenläufige Programmierung: Zustands-Raum Diagramme . . . 40

1

Verteilte und Parellele Eingebettete Systeme

5.2. Globale Ressourcen und Synchronisation . . . . . . . . . . . . . . 446. Petri Netze 47

6.1. Petri-Netze: Einführung und Grundlagen . . . . . . . . . . . . . . 486.2. Kommunizierende Seq. Prozesse und Petri-Netze . . . . . . . . . 546.3. Deadlocks in Petri-Netzen . . . . . . . . . . . . . . . . . . . . . . 586.4. Verhaltensmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.5. Datenabhängigkeitsgraphen . . . . . . . . . . . . . . . . . . . . . 59

7. Parallelisierung 607.1. Parallelisierungsklassen . . . . . . . . . . . . . . . . . . . . . . . . 607.2. Parallelisierungsmethoden . . . . . . . . . . . . . . . . . . . . . . 637.3. Funktionale Programmierung . . . . . . . . . . . . . . . . . . . . 677.4. Asynchrone Ereignisverarbeitung . . . . . . . . . . . . . . . . . . 68

8. Parallele Programmierung 708.1. Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708.2. JavaScript :: Daten und Variablen . . . . . . . . . . . . . . . . . . 708.3. JavaScript :: Funktionen . . . . . . . . . . . . . . . . . . . . . . . 708.4. JavaScript :: Datenstrukturen . . . . . . . . . . . . . . . . . . . . 718.5. JavaScript :: Objekte . . . . . . . . . . . . . . . . . . . . . . . . . 728.6. JavaScript :: threads.js . . . . . . . . . . . . . . . . . . . . . . . . 738.7. JavaScript :: threads.js :: IPC . . . . . . . . . . . . . . . . . . . . 76

9. Synchronisation und Kommunikation 789.1. Nebenläufigkeit, Wettbewerb, und Synchronisation . . . . . . . . 799.2. Der Mutuale Ausschluss: Ein Problem und seine Definition . . . . 799.3. Eigenschaften von Parallelen Systemen . . . . . . . . . . . . . . . 809.4. Lock und atomare Operationen . . . . . . . . . . . . . . . . . . . 839.5. Mutex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869.6. Semaphore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 969.7. Semaphore - Produzenten-Konsumenten Systeme . . . . . . . . . 989.8. Semaphore - Dining Philosophers . . . . . . . . . . . . . . . . . . 999.9. Monitor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009.10. Event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1049.11. Barriere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1059.12. Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1069.13. Channel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

10. Parallelisierung und Metriken 10710.1. Parallelität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10810.2. Datenabhängigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . 10810.3. Rechenzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10910.4. Klassifikation von parallelen Algorithmen . . . . . . . . . . . . . 11010.5. Speedup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11110.6. Kosten und Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . 11210.7. Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . 11510.8. Maßzahlen für Parallele Systeme . . . . . . . . . . . . . . . . . . 11910.9. Amdahl’s Gesetz . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

11. Plattformen und Netzwerke 12311.1. Eigenschaften von Parallelarchitekturen . . . . . . . . . . . . . . 124

PD Stefan Bosse 2


11.2. Klassifikation Rechnerarchitektur . . . . . . . . . . . . . . . . . 12511.3. SISD-Architektur Eigenschaften . . . . . . . . . . . . . . . . . . 12611.4. SISD-Architektur - Von-Neumann Architektur . . . . . . . . . . 12611.5. SISD-Architektur - Harvard-Architektur . . . . . . . . . . . . . . 12711.6. SIMD-Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . 12811.7. MISD-Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . 13011.8. MIMD-Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . 13211.9. Speichermodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 13211.10. Rechnerarchitektur für Vision-Systeme (I) . . . . . . . . . . . . 13311.11. Rechnerarchitektur für Vision-Systeme (II) . . . . . . . . . . . 13411.12. Rechnerarchitektur für Vision-Systeme - Netra . . . . . . . . . 13411.13. Kommunikationsstrukturen . . . . . . . . . . . . . . . . . . . . 13711.14. Netzwerkarchitekturen und Topologien . . . . . . . . . . . . . . 14011.15. Netzwerkarchitekturen und Topologien . . . . . . . . . . . . . . 14111.16. Netzwerkarchitekturen und Topologien . . . . . . . . . . . . . . 14111.17. Dynamische Verbindungsnetzwerke . . . . . . . . . . . . . . . . 14211.18. Statische Verbindungsnetzwerke . . . . . . . . . . . . . . . . . . 14611.19. Kommunikationsstrukturen - Routing . . . . . . . . . . . . . . 15211.20. Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . 15311.21. Kommunikation - Zusammenfassung . . . . . . . . . . . . . . . 155

12. Register Transfer Logik (RTL) 15512.1. RT Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15612.2. RTL Synthese von Digitallogikschaltungen . . . . . . . . . . . . 159

13. High-level Synthese von Digitallogik 16013.1. Abbildung von Algorithmen auf RTL . . . . . . . . . . . . . . . 16113.2. RTL Beschreibungssprache: µRTL . . . . . . . . . . . . . . . . . 16113.3. RTL Beschreibungssprache: µRTL . . . . . . . . . . . . . . . . . 16213.4. µRTL Hardware Synthese von sequenziellen Prozessen . . . . . . 16313.5. m-µRTL: Multi-Prozess Systeme auf RT Ebene . . . . . . . . . . 16813.6. m-µRTL: Multi-Prozess Systeme auf RT Ebene . . . . . . . . . . 16813.7. m-µRTL Hardware Synthese von Multi-Prozess Systemen . . . . 16913.8. Globale Objekte mit Mutex-Scheduler . . . . . . . . . . . . . . . 171

14. Referenzen 17314.1. Bücher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17314.2. Videos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

2. Überblick

2.1. Schwerpunkte in diesem Kurs

ä Grundlagen von parallelen und verteilten Systemen

PD Stefan Bosse 3


ä Konzepte der parallelen und verteilten Programmierung

ä Praktische Relevanz und Anwendung

ä Plattformen und Technologien; Register Transfer Logik

ä Implementierung paralleler Systeme in Hardware

Begleitet von Übungen um obige Techniken konkret anzuwenden

Vorlesung2 SWS mit Grundlagen und Live Programming

Übung2 SWS mit Programmierung und angewandter Vertiefung

VoraussetzungenGrundlegende Programmierfähigkeiten, Grundkenntnisse in Rechnerar-chitektur und Netzwerken

2.2. Literatur

VorlesungsskriptDie Inhalte der Vorlesung werden sukzessive bereitgestellt

Concurrent Programming: algorithms, Principles, and FoundationsMichel Raynal, Springer 2013, ISBN 978-3-642-320626-2

Parallel Image ProcessingT. Bräunl, Springer Berlin, 2001

PD Stefan Bosse 4


An introduction to parallel programmingP. S. Pacheco, Elsevier, MK, 2011.

Advanced Digital Logic Design (with Verilog)M. D- Ciletti, Pearson, 2011

PD Stefan Bosse 5


2.3. Software

Verwendete Software (Vorlesung und Übung):

threads.js/parallel.js

www.bsslab.de/v2/?Software/jam

ä Programmierung in JavaScript

ä Bibliothek für Parallele und Verteilte Systeme

ä Einfach zu Erlernen

ä Auf jeder JavaScript VM ausführbar

..

T=require('./threads');S={ev:T.Event()};T.Thread(function (id) {ev.await();print('Hey got the event!');

},'mytask1',S);

jxcore+

www.bsslab.de/v2/?Software/jam

ä JavaScript VM mit Multithreading

ä Ausführung von der Kommandozeile

PD Stefan Bosse 6


ä Wird auch für Live Programming genutzt

ä Einsatz auf verschiedenen Hostplattformen : PC, Smartphone, EmbeddedPC, Server, ..

ä Einsatz auf Betriebssystemen: Windows, Linux, Solaris, MacOS, Android

..> jx threads_demo.js

Verwendete Software (Vorlesung und Übung):

pipe

pipe2.sourceforge.net

ä GUI basierte Simulation und Analyse von Petri Netzen

ä Modellierung von parallelen Systemen mit Diagrammen

PD Stefan Bosse 7

http://pipe2.sourceforge.net


ConPro

www.bsslab.de/v2/?Software/conpro

ä Highlevel Synthesewerkzeug und Programmiersprache

ä Programmierung von parallelen Systemen für den Schaltkreisentwurf

PD Stefan Bosse 8


..

process p:beginreg x,y: int[8];x <- 0, y <-0;ev.await();for i = 0 to 10 dobeginvec.[i] <- vec.[i]*vec.[i];

endsema.up();

end

2.4. Ziele

1. Verständnis der Grundprinzipien und Architekturen verteilter (VS) undparalleler Systeme (PS) und Fähigkeit zum Transfer auf technische Sys-teme

2. Verständnis und Fähigkeit der programmatischen Anwendung von Syn-chronisation und Kommunikation in VS und PS

3. Verständnis der Probleme und dem Betrieb von parallelen Systemen imVergleich zu sequenziellen Systemen (Effizienz, Blockierung, Skalierung,Ressourcenbedarf)

4. Praktische Kenntnisse der Programmierung von PS und VS anhand vonProgrammierübungen mit JavaScript und jxcore (node.js)

5. Erkenntnisse von Grenzen und Möglichkeiten der Parallelisierung undVerteilung und die Fähigkeit effiziente Systeme zu entwickeln

6. Übertragung von parallelen Softwarearchitekturen und Methoden aufHardware (Schaltkreisentwurf)

2.5. Inhalte

A. Parallele und Verteilte Systeme

B. Sequenzielle und Parallele Datenverarbeitung

C. Funktionale, Sequenzielle, und Parallele Komposition

D. Prozessmodelle, Petri-Netze

E. Kommunizierende Prozesse

F. Synchronisation und Kommunikation (Primitiven)

PD Stefan Bosse 9


G. Praktische Parallele Programmierung mit JavaScript undthreads.js/parallel.js

H. Parallelisierung: Methoden und ALgorithmen

I. Netzwerke und Nachrichrenaustausch, Network-on-Chip

J. Abbildung Multiprozessmodell auf Hardware (RTL)

K. High-level Synthese mit ConPro

3. Einführung in die verteilte und paralleleDatenverarbeitung

3.1. Verteilte vs. Parallele Systeme

Verteiltes SystemEin verteiltes System ist eine Sammlung von lose gekoppelten Prozes-soren oder Computern, die über ein Kommunikationsnetzwerk miteinanderverbunden sind ( Multicomputer ).

ä Speichermodell : Verteilter Speicher → Jeder Prozessor verfügtüber privaten Speicher

ä Kommunikation : Nachrichtenbasiert über Netzwerkeä Ressourcen : Nicht direkt geteilt

Paralleles SystemEin paralleles System ist eine Sammlung von stark gekoppelten Prozes-soren ( Multiprozessoren )

ä Speichermodell : Gemeinsamer Speicherä Kommunikation : Direkt über elektrische Signale→ Switched Net-

work (Kreuzschiene) | Bus→ Punkt-zu-Punkt | Punkt-zu-N-Netzwerkeä Ressourcen : Gemeinsam genutzt (Bus, Speicher, IO)

PD Stefan Bosse 10


Abb. 1. Taxonomie von verteilten und parallelen Systemen [1]

Verteilter Speicher

ä Zugriff auf Speicher erfordert Netzwerkkommunikation

ä Vorteil: Speicher ist skalierbar mit Anzahl der Prozessoren

ä Nachteil: Langsamer Speicherzugriff zwischen Prozessen

Unified Memory Architecture

ä Symmetrisches Multiprocessing (SMP)

ä Vorteil: Konstante Zugriffszeit auf Speicher

ä Vorteil: Schneller Speicherzugriff zwischen Prozessen

PD Stefan Bosse 11


Non Unified Memory Architecture

ä Vorteil: Clustering von SMPs

ä Nachteil: Ungleiche Zugriffszeiten auf Speicher

[computing.llnl.gov]

3.2. Verteilte Systeme

ä Historisch basierend auf Netzwerk-Betriebssystemen (z. B. Linux-Clustern): Benutzer sind sich der Vielzahl von Maschinen bewusst!

o Tools: Remote Login (telnet, ssh), Remote Desktop (Windows),Dateitransfer (FTP, SSH), Netzwerk Dateisystem (NFS)

ä Ein Verteiltes Betriebssystem verbirgt die einzelnen Maschinen: Be-nutzer sind sich der Vielzahl von Maschinen nicht bewusst!

o Zugriff auf entfernte Ressourcen ähnlich wie der Zugriff auf lokale

o Übertragung von Prozessen (Berechnung) und Programmcode(anstatt Daten)

PD Stefan Bosse 12


[Tanenbaum]

Geschichte der Verteilten Betriebssysteme (DOS)

Abb. 2. Zeitleiste einiger ausgewählter DOS. Goldenes Zeitalter der DOS-Entwicklung war in den 80er und 90er Jahren!

PD Stefan Bosse 13


Entwurfskriterien und Eigenschaften

NamensgebungWie können wir ein Objekt benennen, das weit entfernt an einem unbekan-ntem Ort ist?

RobustheitWas passiert, wenn eine Maschine oder ein Netzwerk ausfällt?

SicherheitWie können wir unser System vor Versagen, Betrug, Eindringen, Diebstahlvon Daten, … schützen?

PerformanceLangsamer als je zuvor?

KonsistenzIch machte eine Banktransaktion, die Bestätigung der Transaktion ging ver-loren, und die Transaktion wurde wiederholt. Mein Konto wurde zweimalbelastet?

SkalierbarkeitWas passiert mit diesen Kriterien, wenn wir die Anzahl der Maschinen umdas Zehnfache erhöhen?

3.3. Parallele Systeme

Definition

ä Zerlegung (Partitionierung) eines sequenziellen Algorithmus oder einesProgramms in parallele Tasks (Prozesse) → Parallele Komposition

ä Ausführung der Prozesse parallel (nebenläufig und ggfs. konkurrierend)auf mehreren Verarbeitungseinheiten (u. A. generische programmges-teuerte Prozessoren)

Motivation für parallele Datenverarbeitung

ä Verkleinerung der Berechnungslatenz

..Def. Latenz: Gesamte oder Teilbearbeitungszeit eines Datensatzes

PD Stefan Bosse 14


ä Erhöhung des Datendurchsatzes

..

Def. Datendurchsatz: Anzahl der verarbeiteten Datensätze pro Zeitein-heit

ä Latenz und Bandbreite sind zunächst unabhängig!

ä Pipelining kann die Bandbreite erhöhen (nur Sinnvoll bei Datenströmen)

ä Parallele Tasks können die Latenz verringern

Abb. 3. Unterschied Latenz zu BandbreiteMan unterscheidet: Parallele Rechnerarchitektur und parallele Datenverar-beitung

Motivation für parallele Datenverarbeitung

ä Steigerung der Energieeffizienz von mikroelektronischen Systemen:

o Komplexe generische Einprozessoranlagen besitzen ungünstige En-ergieeffizienz, aber:

o Parallelisierung kann zu verbesserter Energieeffizienz des Gesamtsys-tems führen!

ä Skalierung von parallelen Rechnern auf reine Digitallogiksysteme für an-wendungsspezifische Lösungen kann deutliche Reduktion der Hardware-Komplexität und der elektrischen Leistungsaufnahme bedeuten!

PD Stefan Bosse 15


o System-on-Chip Entwurf

o Leistungsaufnahme eine CMOS Digitalschaltkreises (f : Frequenz, N :Schaltende Elemente, U : Spannung, C : Technologie):

P (f,N,U,C) ∼ fNU2C (1)

[Qualcomm]

Abb. 4. Erhöhung der Performanz und der Energieffizienz durch Paral-lelisierung

Anwendung paralleler Datenverarbeitung

ä Digitale Bildverarbeitung und automatische Bildinterpretation (Vision)

ä Datenkompression (Video, mpeg)

ä Komplexe Steuerungssysteme mit großer Anzahl von Freiheitsgraden, wiez.B. Positionierungssteuerung von Robotergelenken und Maschinen

ä Kommunikation, z. B. nachrichten-basiertes Routing

ä Kryptoverfahren

ä Parallele numerische Verfahren, wie z. B. Lösung von Differentialgle-ichungen (Strömungsmechanik, Elektromagnetische Wellenausbreitung,Wetter- und Klimamodelle)

PD Stefan Bosse 16


Beispiel Numerik und Digitale Bildverarbeitung

ä Welche Probleme und Nachteile gibt es?

[1,2]

Abb. 5. Parallele Berechnung der Summe von Bildpixeln mit Baumstruktur

Ebenen der Datenverarbeitung in Abhängigkeit vom Paral-lelisierungsgrad

PD Stefan Bosse 17


Rechnerarchitekturen in der Datenverarbeitung

ä Für sequenzielle Datenverarbeitung existieren generische programmges-teuerte Rechneranlagen (von-Neumann Architektur), die die meisten se-quenziellen Algorithmen effizient ausführen können.

ä Das Programm besteht dabei aus einer Vielzahl elementarer einfacherMaschinenbefehle → Sequenzielle Komposition

..

Es gibt keine generischen Rechneranlagen und Architekturen für paralleleDatenverarbeitung

ä Parallele Algorithmen kann man klassifizieren.

ä Die Klasse bestimmt die Rechnerarchitektur, die diese Algorithmen ef-fizient verarbeiten können.

PD Stefan Bosse 18


Beispiel Sensorisches Material

Abb. 6. Beispiel eines verteilten und parallelen Systems: Sensornetzwerk (untenrechts) mit Maschen Topologie mit System-on-Chip Sensorknoten (oben rechts)mit massiv paralleler Datenverarbeitung. Sensorik: Dehnungsmessstreifen aufGummiplatte (links)

Parallelität und Nebenläufigkeit

ä Parallelität und Nebenläufigkeit ist ein zeitliches Ablaufmodell

ä Beschreibt eine zeitliche Überlappung oder Gleichzeitigkeit bei der Aus-führung von parallelen Prozessen

ä Nebenläufigkeit kann ohne Synchronisation auskommen!

Konkurrenz

ä Concurrent → übereinstimmend!

ä Konkurrenz beschreibt den Wettbewerb um geteilte Ressourcen!

ä Wettbewerb bedeutet Konflikt welcher aufgelöst werden muss!

ä Synchronisation zw. Prozessen!

ä Konsens Programmiermodell!

PD Stefan Bosse 19


[blog.golang.org]

..

Parallele und verteilte Datenverarbeitungssysteme vereinen Nebenläu-figkeit und Konkurrenz

ä Nebenläufigkeit durch Ausführungsplattform

ä Konkurrenz muss durch Programmierung gelöst werden

3.4. Sequenzielle vs. parallele Datenverarbeitung

ä Bei der sequenziellen Datenverarbeitung gibt es einen Algorithmhus, derdurch ein Program implementiert wird, das durch einen Prozess auf einemProzessor ausgeführt wird.

PD Stefan Bosse 20


ä Das Programm besteht aus einer Sequenz von Operationen die exakt inder Reihenfolge hintereinander ausgeführt werden.

ä Bei einem Parallen Programm findet eine Partitionierung in Subpro-gramme statt, die von mehreren Prozessen i.A. auf verschiedenen Prozes-soren ausgeführt werden.

ä Drei Phasen einer parallelen Programmausführung:

1. Verteilungsphase der Eingabedaten

2. Ausführungsphase mit Paralleler Verarbeitung

3. Zusammenführungsphase der Ausgabedaten

Was könnte noch fehlen?

Abb. 7. Vergleich klassiche sequenzielle zur parellelen Datenverarbeitung

4. Das Prozessmodell

4.1. Funktionale Komposition

PD Stefan Bosse 21


..

Eine Berechnung setzt sich aus der verschachtelten und verkettetenApplikation von Funktionen zusammen, die jeweils aus elementarenAusdrücken E={ϵ1,ϵ2,..} bestehen → Funktionale KompositionF(X)=f1(f2(f3..(X)))

ä Jede Funktion f i beschreibt einen Teil der Berechnung.

ä Ausdrücke bestehen aus:

1. Konstante und variable Werte 1,2.0,'c',"hello",x,y,z

2. Einfache arithmetische Ausdrücke ϵ=x+y

3. Zusammengesetzte Ausdrücke (arithmetische Komposition)ϵ=(x+1)*(y-1)*z

4. Relationale Ausdrücke x < 0

5. Boolesche Ausdrücke a and b or c

6. Bedingte Ausdrücke liefern Werte if x < 0 then x+1 else x-1

7. Funktionsapplikation f(x,y,z)

ä Entspricht dem mathematischen Modell was auf Funktionen und Aus-drücken gründet mit den Methoden

o Definition f (x) = λ.x → ϵ(x)

o Applikation f (ϵ), bei mehreren Funktionsargumenten f (ϵ1,ϵ2,..)

o Komposition f ◦ g ◦ h ◦ .. = f(g(h(..(x)))

o Rekursion f (x) = λ.x → ϵ(f ,x)

o und Substitution a=ϵ

ä Zeitliches Modell: unbestimmt (t 7→ 0), Auswertereihenfolge nicht fest-gelegt

PD Stefan Bosse 22


4.2. Sequenzielle Komposition

..

Eine imperative Berechnung setzt sich aus einer Sequenz I=(i1 , i2 , ..)von elementaren Anweisungen A={a1,a2,..} zusammen →Sequenzielle Komposition i1 ; i2 ; …

ä Die Anweisungen werden sequentiell in exakt der angegebenen Reihenfolgeausgeführt

ä Die Menge der Anweisungen A lässt sich in folgende Klassen unterteilen:

1. Arithmetische, relationale, und boolesche Ausdrücke (in Verbindung mit2./3.) x+1, a*(b-c)*3, x<(a+b), ...

2. Datenanweisungen: Wertzuweisungen an Variablen x := a+b

3. Kontrollanweisungen wie bedingte Verzweigungen und Sprünge(Schleifen)

..

if a < b then x := 0label: x:=x+1; if x < 100 then loop label

ä Man fasst die Sequenz I als ein imperatives Programm X == Aus-führungsvorschrift zusammen.

ä Die Ausführung des Programms (statisch) bezeichnet man als Prozess(dynamisch)

ä Ein Prozess befindet sich aktuell immer in einem Zustand σ einerendlichen Menge von Zuständen Σ={σ1 , σ2 , ..}.

PD Stefan Bosse 23


ä Der gesamte Zustandsraum Σ des Prozesses setzt sich aus dem

o Kontrollzustand s ∈ S={s1, s2, ..}, und dem

o Datenzustand mit der Menge aller Speicherzustände (Daten) d ∈D={d1, d2, ..} zusammen.

ä Der Fortschritt eines sequenziellen Programms bedeutet ein Änderung desKontroll- und Datenzustandes → Zustandsübergänge

ä Die Zustandsübergänge können durch ein Zustandsübergangsdiagrammdargestellt werden.

4.3. Zustände und Zustandsdiagramm

ä Jede Anweisung in wird durch wenigstens einen Kontrollzustand sm ∈ Srepräsentiert: in ∈ I ∈ A ⇒ sm ∈ S

Beispiel Berechnung GGT

..

A={assign :=,loop WHILE,branch IF}

S={s1,s2,s3,s4,s5,s6}

xi1→s1 := 32;yi2→s2 := 16;WHILEii3→s3 x <> y DOIFi4→s4 x < y THENxi5→s5 := x - y;

ELSEyi6→s6 := y - x;

Kontrollzustandsdiagramm

PD Stefan Bosse 24


4.4. Sequenzieller Prozess

Ausführungszustände

ä Ein Prozess P besitzt einen “makroskopischen” Ausführungszustandps. Die Basismenge der Ausführungszustände PS ist (“Milestones”):

o Start und bereite aber noch nicht rechnend (START)

o Rechnend (RUN)

o Terminiert und nicht mehr rechnend (END)

ä Dazu kann es eine erweiterte Menge PS*an Ausführungszuständen geben:

o Auf ein Ereignis wartend (AWAIT)

o Blockiert (BLOCKED)

o Rechenbereit aber nicht rechnend (nach Ereignis) (READY)

PS = {START, RUN, END}PS∗ = {AWAIT, BLOCKED, READY}ps(P ) ∈ PS ∪ PS∗

PD Stefan Bosse 25


Prozessblockierung

ä Das Konzept der Prozessblockierung ist elementar für kommunizierendeProzesse

ä Kommunikation: Lesen und Schreiben von Daten, Ein- und Ausgabe, Net-zwerknachrichten, usw.

ä Befindet sich ein Prozess im Ausführungszustand BLOCKED wartet dieserauf ein Ereignis:

o Daten sind verfügbar

o Zeitüberschreitung

o Geteilte Ressource ist frei

o Synchronisation mit anderen Prozessen

ä Bei einem blockierter Prozess schreitet der Kontrollfluss nicht weiter voran

ä Die ausführung einer Operation (Instruktion) kann verzögert werden bisdas zu erwartende Ereignis eintritt

ä Ein Prozess kann mittels der Operation suspend und resume blockiertoder wieder lauffähig gemacht werden

ä In einem Kontrollflussdiagramm würde es einen Kantenübergang auf denblockierten Zustand geben

Prozesszustandsübergangsdiagramm

PD Stefan Bosse 26


[bitsofcomputer.blogspot.com]

Instruktionen sind Prozesse

ä Jede Instruktion i kann als ein elementarer Prozess P aufgefasst werden.

ä Zu jeder Instruktion gehört eine Aktion

ä Terminierung eines Prozesses entspricht ausgeführter Instruktion.

ä Ein folgender Prozess wird erst dann aktiviert (gestartet) wenn dervorherige terminiert ist → Synchronisation.

PD Stefan Bosse 27


Zeitliches Modell

ä Ein Prozess führt die Anweisungen der Reihe nach aus. Das symbolischeSemikolon teilt den Anweisungen eigene Ausführungsschritte (Zeitpunkteti) zu.

i1 : t1 7→ i2 : t2 7→ i3 : t3 7→ .. 7→ in : tn mitt1 < t2 < t3 < .. < tn

T =∑i

ti − ti−1

ä Die gesamte Ausführungszeit T(p) eines sequenziellen Prozesses p ist dieSumme der Ausführungszeiten der Elementarprozesse

Prozesskonstruktor

P = (P1 ; P2 ; .. ; Pn) ⇔SEQi1i2..

in

4.5. Parallele Komposition

ä Ausgangspunkt sei das Ausführungsmodell eines sequenziellen ProzessesP

..

Ein sequenzieller Prozess Ps besteht aus einer Sequenz von Anweisun-gen I=(i1 ; i2 ;..) (Berechnungen), die schrittweise und nacheinanderausgeführt werden: Ps=P(i1 ; i2 ; .. ; in) ⇒ p1 7→ p2 7→ .. 7→ pn

ä Ein Prozess P kann sich in verschiedenen Ausführungszuständen ps ∈ RS⊂ PS ∪ PS* befinden:

..

RS={START, RUN, BLOCKED(i),END}ps(P) ∈ RS

PD Stefan Bosse 28


ä Dabei kann ein Prozess in einer Instruktion i blockieren, d.h. diefolgende Instruktion i+1 wird noch nicht ausgeführt und der Prozessverbleibt aktionslos in der aktuellen Instruktion

Prozesse als steuerbare Objekte

ä Ein Prozess P kann mittels Operationen gestartet und gestoppt werden:

Definition 1.

..

op start(P): ps(P)=START|END 7→ ps(P)=RUNop stop(P): ps(P)=RUN|BLOCKED|START 7→ ps(P)=ENDop suspend(P): ps(P)=RUN 7→ ps(P)=BLOCKEDop resume(P): ps(P)=BLOCKED 7→ ps(P)=RUN

Parallele Prozesse

..

Ein Datenverarbeitungssystem als paralleler Prozess kann aus einerVielzahl nebenläufig ausgeführter Prozesse P={P1, P2, P3,…} bestehen→Parallele Komposition P=P1 ∥ P2 ∥ P3 ∥ ..

ProzesskonstruktorP = (P1 ∥ P2 ∥ .. ∥ Pn) ⇔PARi1i2..

in

Ausführungsreihenfolge

ä Achtung! Wenn keine Kommunikation (Synchronisation) zwischen denProzessen stattfindet ist die Ausführung und das Endergebnis (der Berech-

PD Stefan Bosse 29


nung) gleich der sequenziellen Ausführung der Prozesse:

P1 ∥ P2 ∥ .. ∥ Pn ⇒ P1;P2; ..;Pn

P1 ∥ P2 ⇒ P1;P2 ⇒ P2;P1!

Prozesserzeugung und Synchronisation

ä Ein neuer paralleler Prozess kann durch den entsprechenden Prozesskon-struktor erzeugt werden

ä Geschieht dies innerhalb eines Prozesses Pi so wird dessen Prozessaus-führung blockiert bis alle Teilprozesses des parallelen Prozessen terminiertsind!

Forking

ä Ein neuer Prozess Pj kann mittels Forking erzeugt werden (Aufspaltungdes Kontrollflusses, so auch von einem anderen Prozess Pi) ohne dass einausführender Prozess auf die Terminierung des Parallelprozesses wartenmuss:

P1; //P2;P3 = P1;P3 ∥ P2

//P1; //P2;P3 = P1 ∥ P2 ∥ P3

ProzesskonstruktorP = P1; //P2 ⇔FORKi1i2..

in

PD Stefan Bosse 30


Zeitliches Modell

P = P1 ∥ P2 ∥ .. ∥ Pn

P1 = (i1,1 : t1,1; i1,2, : t1,2; ..) · · ·Pn = (in,1 : tn,1; in,2 : tn,1; ..), mitti,1 < ti,2 < .. < ti,m fü r jeden Prozess mit m Instr. undt(P ) = [t1, t2] = [t1,1, t1,q] ∪ [t2,1, t2,r] ∪ .. ∪ [tn,1, tn,s]

t1 = min{t1,1, t2,1, .., tn,1}t2 = max{t1,q, t2,r, .., tn,s}T = t2 − t1

4.6. Prozessfluss

ä Der Prozessfluss in einem parallelen System kann durch Übergangs- undTerminierungsdiagramme dargestellt werden. (wie bereits im seq. Fallgezeigt wurde).

ä Eingehende Kanten (Pfeile) des Graphen beschreiben den Start einesProzesses, ausgehende Kanten die Terminierung.

Abb. 8. Beispiel eines Prozessflussdiagramms für vier Prozesse. P1 startet P3,und P2 spaltet P4 ab. (mit P_,i = Instruktion(P,i))

Beispiel

PD Stefan Bosse 31


..

Seq([function (id) { log('P1: I am '+id) },function (id) { log('P2: I am '+id) },

])Par([function (id) { log('P3: I am '+id) },function (id) { log('P4: I am '+id) },

])log('after')

4.7. Metaprozesse

ä Die Menge aller Prozesse {P1, P2,..} eines Systems bilden ein Meta-Prozess P. Dieser terminiert wenn alle enthaltenen (Sub-) Prozesse ter-miniert sind.

Abb. 9. Vier parallele Prozesse P1, P2, P3, und P4. Die Prozesse bilden hiereine Prozesshierarchie, d.h z.B. P3 und P4 gehören zum Meta-Prozess PB.

4.8. Kommunizierende Sequenzielle Prozesse

Definition 2.Prozesskommunikation bedeutet Synchronisation zwischen Prozessen

PD Stefan Bosse 32


..

Prozess Synchronisation tritt auf, wenn der Berechnungsfortschritt einesoder mehrerer Prozesse von dem Verhalten der anderen Prozesse abhängt.

ä Zwei Arten der Prozess Interaktion benötigen Synchronisation:

o Wettbewerb (z.B. um geteilte Ressourcen)

o Kooperation

ä Parallele Datenverarbeitung bedeutet:

o Distribution: Partitionierung und Verteilung von Eingabedaten aufverschiedene Prozesse, die jeweils ein Teilergebnis berechenen→Ko-operation

o Zusammenführung: Zusammenführen von Teilergebnissen→ Ko-operation

Abb. 10. Kommunikation von parallelen Prozessen in der parallelen Daten-verarbeitung, z.B. um Rechenergebnisse auszutauschen oder während derVerteilungs- und Zusammenführungsphase

Paralleler Datenzugriff

ä Daten werden gespeichert und befinden sich in Speicherelementen:einzelne Register oder adressierbare RAM Speicher.

ä Mehrere Prozesse müssen je nach Datenabhängigkeit parallel auf geteilteRessource Speicher zugreifen, um

o Eingabedaten zu lesen und

o Zwischenergebnisse auszutauschen und

PD Stefan Bosse 33


o Ausgabedaten schreiben zu können.

⇔Wettbewerb

ä Nebenläufiger Zugriff auf geteilte Ressourcen ist ein Konflikt der aufgelöstwerden muss → Mutual Exclusion Problem

4.9. Geteilte Ressourcen und Kommunikation

Abb. 11. Paralleler Zugriff auf Speicherresourcen von Prozessen

Queue

ä Ressourcen-Konflikt und Synchronisation kann mit Daten-Queues/Channels aufgelöst werden.

ä Eine Queue hat im wesentlichen zwei Operationen die synchronisiertenZugriff ermöglicht (FIFO Speicher):

Definition 3.

..

op write(Q,x): Q[y,z,...],x → Q[x,y,z,...]op read(Q): Q[x,y,z] → Q[x,y],z

ä Eine Queue hat einen Prozess PW der Daten in die Queue schreiben kannund einen Prozess PR der Daten aus der Queue lesen kann.

Synchronisation

PD Stefan Bosse 34


..

Queue Q=[] ⇔ state=EMPTY: Lesender Prozess wirdblockiert bis Q ̸= []Queue Q=[x,y,z] ⇔ state=FULL: Schreibender Prozess wirdblockiert bis state(Q) ̸= FULL

Abb. 12. Verbindung zweier Prozesse durch eine Queue

Channel

ä Ähnlich wie eine Queue eventuell mit Einschränkungen:

o Puffergröße: 0 (!!) → Kein Wettbewerb! / 1

o Nur zwei Prozesse zugelassen: Ein Leser und ein Schreiber

o Rendezvous Synchronisation: Schreibender Prozess wird blockiert bislesender Prozess read Operation ausführt

Beispiel

PD Stefan Bosse 35


..

Par([function () {var x=ch.read();log('hello '+x);

},function () {ch.write('world');

}],{ch:Channel()

})

4.10. Prozessmehrfachauswahl

ä Ein Prozess kann in seinem Kontrollfluss nur eine blockierende Anweisunggleichzeitig aufrufen, d.h. in unserem Prozessmodell nur einen folgendenelementaren Prozess aktivieren.

ä Häufig ist es aber notwendig dass der Prozessfluss in mehrere Elemen-tarprozesse mit einer blockierenden Operation aufspaltet (z.B. Lesen einesChannels) von dem dann nur ein Prozess zur Ausführung kommt (der ersteder bereit wurde) → Konditionaler Fork

ä Der aufgespaltete konditonale Prozessfluss wird dann wieder zusammenge-führt (join) → Klassische IO Selektion

Auswahlprozesskonstruktor:

P = (p1,cond → p1,do|p2,cond → p2,do|..)ALTi1,cond?i1,do

i1,cond?i1,do

..

Beispiel ALT

PD Stefan Bosse 36


..

Par([function () {var x;Alt([[function () { x=ch1.read() }, Konditonaler Prozess 1function () { log('Got channel 1') }], Ereignis

Prozess 1[function () { x=ch2.read() }, Konditonaler Prozess 2function () { log('Got channel 2') }], Ereignis

Prozess 2[function () { x=ch3.read() }, Konditonaler Prozess 3function () { log('Got channel 3') }], Ereignis

Prozess 3]);log('hello '+x);

},function () {ch1.write('world');

}],{ch1:Channel(),ch2:Channel(),ch3:Channel()

})

4.11. CSP Modell und Prozessalgebra

ä Prozessalgebra nach dem “Communicating Sequential Processes” (CSP)Modell von Hoare:

ä Beschreibung des Verhaltens von Prozessen als Reaktion auf Ereignisse→Synchronisierter Prozessfluss

ä Kommunikation sind Ereignisse

ä Algebraisch wird die Entwicklung von Prozessen durch Ereignisse x,y, ..beschrieben

Definition 4.Ereignis : x

Prozess : P

Ein Prozess der nach einem Ereignis x sich wie Prozess P verhält: x→ P

Folge von Ereignissen: x→ (y → P )

PD Stefan Bosse 37


Parallele Ausführung: P ∥ Q

Alphabet eines Prozesses: αP = x1, y2, ..

ä Ein Alphabet eines Prozesses beschreibt die möglichen Ereignisse die alsVorbedingung eines Prozesses auftreten können: αP = x1, y2, ..

ä Rekursive Definition von Prozessen: µX : A • F (X)Mit A: Alphabet des Prozesses (Ereignismenge)

Beispiel

ä Ein Taktprozess:

A = αCLOCK = {tick}CLOCK = µX : {tick} • (tick → X)

ä Ein Snackautomat:

A = αSNACK = {coin, choco}SNACK = µX : {coin, choco} • (coin→ (choc→ X))

ä Deterministische oder nichtdeterministische Auswahl von Ereignissen undProzessentwicklungen sind typisch für parallele Systeme!

Definition 5.Auswahl: (x→ P |y → Q)

→ D.h. entweder tritt Ereignis x ein und der Auswahlprozess verhält sich wieP , oder es tritt das Ereignis y ein und der Prozess verhält sich wie Q.

Es gilt: α(x→ P |y → Q) = αP = αQ

→ D.h. die Ereignismenge ist immer x, y.

Beispiel Snackautomat mit Choco und Kaffee

VMCT = µX • coin→ (choc→ X|coffee→ X)

Beispiel Alt Prozessauswahlkonstruktor

ALT = µX : {in1.x, in2.x, · · · , out1.x, out2.x, · · · } • (in1.x→ (P1 → (out1.x→ X))|in2.x→ (P2 → (out2.x→ X))| · · · )

PD Stefan Bosse 38


Spur

ä Eine Spur (Trace) des Verhaltens eines Prozesses beschreibt die zeitlicheAbfolge von Ereignissen in die ein Prozess verwickelt war.

ä Spruen werden von Beobachtern aufgenommen (Monitor).

Definition 6.Spur: < x, y, .. >

Leere Spur: <>

Spurbindung: < a, b >ˆ< c, d > → < a, b, c, d >

Beispiele

< coin, choc, coin, choc, coin, coin, coffee >

< tick, tick, tick >

Spurenmenge

ä Es gibt eine Vielzahl von möglichen Spuren in einem Einzel- und Multi-prozesssystem!

ä Jede Spur kann zudem in Teilspuren zerlegt werden beginned mit derleeren Spur.

ä Spurenmenge ⇔ Zustandsraumdiagramm!

Beispiele

traces(STOP ) = {<>}traces(coin→ STOP ) = {<>,< coin >}traces(µX • tick → X) = {<>,< tick >,< tick, tick >, ..} = {tick}∗traces(µX • coin→ choc→ X) = {<>,< coin >,< coin, choc >, ..}= {s|∃n • s ⩽< coin, choc>n}

PD Stefan Bosse 39


Kommunikation

Definition 7.αc(P ) = {v|c.v ∈ αP} : Menge aller Nachrichten eines Prozeses P

(c!v → P ) = (c.v → P ) : Ausgabe eines Wertes über den Kanal c (Schreiben)

(c?x→ P ) : Eingabe eines Wertes über einen Kanal c (Lesen)

5. Zustands-Raum Diagramme

..

Für die Visualisierung und Analyse von nebenläufigen Prozessen und Ak-tionen

5.1. Nebenläufige Programmierung: Zustands-Raum Dia-gramme

..

Zustands-Raum Diagramme beschreiben die möglichen Zustands-Entwicklungen - das Verhalten - von parallelen Programmen.

ä Computer sind endliche Zustandsautomaten. Der Zustandsübergang wirddurch die Programminstruktionen hervorgerufen.

ä Der Zustand S eines parallelen Programms welches aus N Prozessen Pibesteht setzt sich zusammen aus folgenden Tupeln:

o Globale Variablen des Programms:

o Lokale Variablen und Instruktionszeiger von Prozess 1:

o Lokale Variablen und Instruktionszeiger von Prozess 2: usw.

ä Die Berechnung ändert globale und lokale Variablen (Datenfluss) sowieInstruktionszeiger (Kontrollfluss) und führt zu einer Zustandsänderungcomp: si → sj.

ä Wesentliche Zustandsänderung ist die Änderung von lokalen und globalenSpeicher.

ä Variablen sind Bestandteil von Ausdrücken und erlauben zwei Operatio-nen: {READ,WRITE}

PD Stefan Bosse 40


..

var x: read(x) ⇔ RHS value(x) → ϵ(x)write(x,v) ⇔ LHS reference(x) → x := v

Beschreibung eines parallelen Programms auf Programmierebene

ä Der Zugriff auf globale und somit geteilte Variablen muss atomar sein,d.h. immer nur ein Prozess kann den Wert einer Variable lesen oder einenneuen Wert schreiben.

ä Der parallele Zugriff auf eine geteilte Ressource muss aufgelöst werden(Konflikt): i.A. mutualer Ausschluss durch Sequenzialisierung der paral-lelen Zugriffe!

ä Beispiel

..

write(X,v1) || write (X,v2) || read(X,x3) →write(X,v1);read(X,x3);write(X,v2)

ä Algebraisch ausgedrückt ergibt sich die Transformation:

(write(x, v1)→ p1) ∥(write(x, v2)→ p2)

(write(x, v1)→ (write(x, v2)→ (p1 ∥ p2)))|(write(x, v2)→ (write(x, v1)→ (p1 ∥ p2)))|..

ä Instruktionen von Prozessen werden sequenziell ausgeführt. Instruktionenkönnen auf Prozess-lokale und Programm-globale Variablen zugreifen.

ä Definition eines parallelen Programms: globale Variablen (V ) undProzesse mit lokalen Variablen (v)

PD Stefan Bosse 41


..

var V1,V2,...process p1(a1,a2,...) process p2(a1,a2,...)var v1,v2,.... var v1,v2,....<Instruktion1 i1> <Instruktion1 i1><Instruktion2 i2> <Instruktion1 i2>Vi := ϵ(ai,vi,Vi) Vi := ϵ(ai,vi,Vi)vi := ϵ(ai,vi,Vi) vi := ϵ(ai,vi,Vi)

end end

ä Bei einem sequenziellen Programm ist das Ergebnis einer Berechnung (d.h.die Werte aller Variablen) deterministisch allein durch die Anweisungsse-quenz und die Eingabedaten gegeben, und kann beliebig oft wiederholtwerden - immer mit dem gleichen Ergebnis→ Reihenfolge aller Anweisun-gen der Berechnung vorgegeben und fest

ä Bei einem parallelen Programm können mehrere Anweisungen ver-schiedener Prozesse gleichzeitig ausgeführt werden bzw. konkurrieren.

ä Die Reihenfolge parallel ausgeführter Anweisungen von einzelnenProzessen kann hingegen undeterministisch = zufällig sein!!

ä Jeder der Prozesse kann als nächster den Zustand des Programms ändern.

ä Ein Zustands-Raum Diagramm beschreibt die Änderung des Programmzu-standes als sequenzielle Auswertung aller möglichen Prozessaktivitäten.

ä Das Diagramm ist ein gerichteter Graph, dessen Knoten den aktuellenProgrammzustand s ∈ S beschreiben, und dessen Kanten die möglichenZustandsübergänge beschreiben.

ä Es gibt einen ausgewiesen Startzustand (Initialisierung) und einen odermehrere Endzustände.

ä Gibt es mehrere Endzustände liegt wohl möglich ein Entwurfsfehler vor,da das Programm unterschiedliche Endergebnisse liefern kann.

Algorithmus: Entwicklung des Zustands-Raum Diagramms

ä Parallelen Programms welches aus N Prozessen P={p1,p2,..,pN} besteht.

1. Initialisiere den Startzustand sx=s0 und erzeuge Wurzel-Knoten s0 imDiagramm.

2. Aktueller Zustand: sx. Setze P*:=P mit P={p1,p2,..,pN} als Prozesslisteund S*={}

3. Wähle (entferne) einen beliebigen Prozess px aus der Prozessliste P* undsetze P*:= {pn| pn ∈ P* ∧ pn ̸∈ px}

PD Stefan Bosse 42


4. Evaluiere die nächste Instruktion ix,n von px und berechne die Wirkungauf lokale und globale Variablen sowie den Instruktionszeiger Ix,n.

5. Erzeuge einen neuen Zustandsknoten sj/=x , füge ihn zur Liste S*:=S* ∪{sj} hinzu und verbinde ihn mittels einer Kante tx→j mit dem aktuellenAusgangszustand sx

6. Wiederhole Schritt 3 bis 5 für alle anderen verbleibenden Prozesse p ∈ Pbis P*={}

7. Setze S**:=S*. Für jeden Knoten sx ∈ S** wiederhole die Schritte 2 bis6. Iteriere Schritt 7 bis alle Prozesse terminiert sind oder keine Zustand-sänderung mehr auftritt.

Beispiel

..

// Sequenzielles Programm // Paralleles Programmfor i := 1 to 3 do i1 process p1

for i := 1 to 3 do i1endprocess p2for j := 1 to 3 do i2

end

Abb. 13. Beispiel und mögliche Entwicklung des Programmzustands (lokaleVar. i,j)

5.2. Globale Ressourcen und Synchronisation

Globale Ressourcen

ä In dem bisherigen Programmmodell gibt es nur globale Variablen alsglobale geteilte Ressourcen, die konkurrierend von Prozessen gelesen undbeschrieben werden können.

ä Die globalen Variablen dienen dem Datenaustausch = Kommunikationzwischen den Prozessen (Shared Memory Model!).

PD Stefan Bosse 43


Atomare Aktionen

ä Atomare Operationen, Schreibweise |A| werden in einem Schritt ausge-führt und können nicht durch andere Prozesse unterbrochen werden (keineInterferenz).

ä Einzelne Lese- und Schreibe-Operationen mit globalen Variablen sindatomar. Nebenläufigkeit wird durch Sequenzialisierung aufgelöst.

..t1: |X := v|

Nicht atomare Aktionen und Synchronisation

Zusammengesetzte Ausdrücke können aus mehreren Berechnungsschrittenbestehen, so ist z. B. X := X + 1 als Ganzes nicht mehr atomar!

..

t1: |temp=X|t2: |X:=temp+1|

Beispiel einer unzureichend geschützten nicht atomaren Aktion

..

var X := 1// INCR(X) // DECR(X)proc p1 proc p2var t:=0 var t:=0t := X t := XX := t + 1 X := t - 1

end end

PD Stefan Bosse 44


Abb. 14. Zustands-Raum Diagramm mit unterschiedlichen Endergebnissen(X=0,-1,1)

..

Nicht atomare Aktionen (Sequenz von Aktionen) mit globalen Ressourcenmüssen durch Mutuale Ausschlusssynchronisation geschützt werden →Schutz von kritischen Codebereichen ⇒ Datenkonsistenz!

Semaphore

ä Eine Semaphore S ist ein Zähler s>0 der niemals negative Werte annehmenkann.

ä Es gibt zwei wesentliche atomare Operationen die von einer Menge vonProzessen P={p1,p2,…} auf einer Semaphore S angewendet werden kön-nen:

Definition 8.

PD Stefan Bosse 45


..

op down(S) | p:|IF s > 0 THEN s := s - 1 else WAITERS+(S,p),BLOCK(p)|

op up(S) | p:|IF s = 0 AND WAITERS(S) ̸= [] THEN pi=WAITERS-(S),UNBLOCK(pi)ELSE s := s + 1|

ä Eine Semaphore mit einem Startwert s=1 entspricht einer Mutex (binäreSemaphore). Ein down(S) leitet einen kritischen Bereich in einer Sequenzi1,i2,i3, … ein, und ein up(S) gibt ihn wieder frei:

..... down(S) |i1,i2,i3,…| up(S) ...

Beispiel einer mit einer Semaphore geschützten nicht atomaren Ak-tion

..

var X := 1sema S := 1// INCR(X) // DECR(X)proc p1 proc p2var t:=0 var t:=0down(S) down(S)t := X t := XX := t + 1 X := t - 1up(S) up(S)

end end

PD Stefan Bosse 46


Abb. 15. Zustands-Raum Diagramm mit einem Endergebnis (X=1)

6. Petri Netze

..

Petri-Netze für die Modellierung, Analyse, und Implementierung von Par-allelen Systemen und Digitallogik

6.1. Petri-Netze: Einführung und Grundlagen

..

Petri-Netze eignen sich für die Darstellung paralleler Prozesse und derenAnalyse des dynamischen Verhaltens

PD Stefan Bosse 47


Petri-Netz (State-Transition)

ä Ein Petri-Netz ist ein Quadrupel PN = <S,T ,E,A> mit

o S: Menge von Stellen (oder auch Plätzen sowie Zuständen/States)

o T : Menge von Übergängen (oder auch Transitions)

o E: Menge der Eingabekanten, gegeben durch die Relation E ⊆ S ×T

o A: Menge der Ausgabekanten, gegeben durch die Relation A ⊆ T ×S

Markierungen M

ä Das dynamische Verhalten der Petri-Netze wird mittels vonMarkierungen beschrieben (Tokens).

ä Es gibt eine Markierungsfunktion M : S → N mit N={0,1,2..}, die dieAnzahl der Markierungen M(s), s ∈ S einer Stelle s angibt.

ä Eine Stelle kann keine, eine, oder mehrere Markierungen besitzen(aufnehmen). Es kann eine maximale Kapazität k einer Stelle geben, dieÜbergänge beeinflusst (k-begrenzte Stellen, im Gegensatz zu unbegrenztenmit k → ∞).

ä Eine Markierung kann durch Übergänge t ∈ T von eine Stelle s1 ∈ S zueiner anderen s2 ∈ S übertragen werden.

Interpretation

ä Petri-Netze können auch verschiedene Weise interpretiert werden, d.h.die Abbildung von Systemen auf PN durch Assoziation von Stellen undÜbergängen!

PD Stefan Bosse 48


Regeln für den Übergang

ä Jedem Übergang t ∈ T ist eine Menge von Eingangsstellen SE ∈ S zuge-ordnet (mindestens eine Stelle).

ä Jedem Übergang ist eine Menge von Ausgangsstellen SA ∈ S zugeordnet(mindestens eine Stelle).

ä Ein Übergang kann schalten, d.h. Markierungen von den Eingangs- zuden Ausgangsstellen übertragen, wenn alle Eingangsstellen wenigstens eineMarkierung besitzen.

ä Eine Kante kann eine Gewichtung g besitzen, die die Anzahl der gle-ichzeitig zu übertragenden Markierungen angibt.

Dynamik: Kausalität

Verschiedene Grundsituationen und Vorbedingungen (Guards/Aktivierung) fürÜbergänge

PD Stefan Bosse 49


A. Der Übergang t1+mussvordemÜbergangt2~ geschaltet haben → Kausalität,Ereignisreihenfolge

B. Hier muss t1 zweimal geschaltet haben, um die Kante zu t2 mitdem Gewicht g=2 zu aktivieren. Zusätzlich müssen zwei weitereStellen Markierungen besitzen, um den Übergang t2 mit insgesamt vierMarkierungen aktivieren zu können.

C. Konflikt: Entweder Übergang t1 oder t2 wird aktiviert (nicht determinis-tisch!)

Dynamik: Parallelität und Synchronisation

Verschiedene Grundsituationen für die Synchronisation bei paralleler Ak-tivierung von Teilnetzen

PD Stefan Bosse 50


A. Fork Situation: Ein Übergang t produziert bei seiner Aktivierung mehrereMarkierungen (entsprechend seiner Ausgangskanten).

B. Join Situation: Mehrere Markierungen entsprechend der Eingangskantenwerden konsumiert und aktivieren den Übergang t.

C. D. Kontakt: nur bei Stellen mit endlicher Kapazität k möglich. Ähnlichdem Konflikt, wo ein ein Übergang (Kante x) einen anderen deak-tiviert (Kante y). Jedoch auch D: Nebenläufigkeit der Übergänge t1,t2, und t3.

PD Stefan Bosse 51


Beispiel: Dining Philosophers

Abb. 16. Dinierende Philosophen (Ausschnitt für einen Philosophen) mit einermöglichen Situation (linke und rechte Gabel Stellen sind Ressourcen, und diebeiden anderen Stellen bilden den Zustand des Philosophens ab). Es gilt k=1!

Petri-Netze mit Ressourcen und Prozessen

ä Stellen S können Lager/Kontainer für Daten/Ressourcen (Markierun-gen/Tokens) repräsentieren, meistens mit einer Kapazität k > 1!

ä FIFO-Queues wären Implementierungen solcher Kontainer!

ä Übergänge T können mit Prozessen oder Operationen verknüpft sein, dieDaten/Ressourcen verarbeiten.

ä Datenflussgraphen können in solche ST Netze abgebildet werden.

Petri-Netze und Digitallogik

ä ST Petri-Netze können ebenfalls zur Darstellung kombinatorischer undsequenzieller Digitallogiksysteme verwendet werden.

PD Stefan Bosse 52


ä Dabei werden Stellen Signalwerten, und Übergängen Signaländerungenzugeordnet.

ä Ein Signal (hier x und y) wird mit zwei Stellen verknüpft (zweiwertigeLogik).

ä Die Übergänge werden mit einer Änderung des gegebenen Signalsverknüpft (Aktivierungsbedingung): A= {a+,a-,a~}, wobei a+ den Über-gang 0→1, a-:1→0, und a~ entweder 0→1 oder 1→0 des Signals a be-deutet.

ä Der bidirektionale Pfeil (Schleife) bedeutet hier einen “nur-lese” Transferder Stellen der Eingangssignale!

Abb. 17. Beispiel: (Circuit) PN für die Beschreibung des Verhaltens einesInverters aus der Digitallogik (kombinatorische Logik) mit erweiterten Regelsatzfür Übergänge

ä Die Plätze der Eingangssignale werden explizit mit Markierungen verse-hen.

ä Anmerkung: Das PN bildet einen Zustandsübergangsgraphen (STG) ab!

PD Stefan Bosse 53


Abb. 18. Weiteres Beispiel: (Circuit) PN für die Beschreibung des Verhaltenseines Oder-Gatters

6.2. Kommunizierende Seq. Prozesse und Petri-Netze

ä Petri-Netze können zur Beschreibung von Multi-Prozess (MP) Systemenverwendet werden.

ä Petri-Netze können aus Signalflussdiagrammen oder Datenflussgraphenabgeleitet werden.

ä Sie können dann zur Synthese von MP Systemen verwendet werden.

Kontroll-Prozess-Modell

Prozesse PProzesse p&in;P führen (sequenziell) Anweisungen durch.Dabei werden Prozesse auf Übergänge t&in;T abgebildet, die mit der se-quenziellen Ausführung von Anweisungen bei deren Aktivierung verknüpftsind.

ProzesssteuerungMarkierungen aktivieren Prozesse und dienen der Synchronisation.Parallelisierung durch spezielle Fork-Übergänge und Synchronisation durchspezielle Join-Übergänge.

Kommunikation

PD Stefan Bosse 54


Interprozess-Kommunikation (synchronisierter Datenaustausch) findetdurch Kontainer (Queues) statt, die durch spezielle Übergänge t&in;Trepräsentiert und abgebildet werden.

Abb. 19. Abbildungen von Anweisungen und Prozesskonstruktoren (z. B. :=,Seq, while, Par, ?!) auf Kontroll-Prozess-Petri-Netze

Daten-Prozess-Modell

Prozesse PProzesse p&in;P (bzw. funktionale Blöcke f&in;F deren Berechnung durchProzesse gekapselt werden können) führen Berechnungen durch.

ä Dabei werden Prozesse auf Übergänge t&in;T abgebildet, die mit derBerechnung als Aktion verknüpft sind.

ä Direkte Abbildung aus Signalflussdiagrammen möglich!

ä Pipeline-Architektur

DatenDaten werden durch Markierungen repräsentiert.

ä Sie dienen der Aktivierung von Prozessen = Übergängen, die die Datenverarbeiten sollen.

Kommunikation

PD Stefan Bosse 55


Interprozess-Kommunikation (synchronisierter Datenaustausch) findetdurch Kontainer (Queues) statt, die durch Stellen sÎS repräsentiert undabgebildet werden.

ä Die Daten (Markierungen) werden durch die Stellen zwischen Übergangenübertragen.

Beispiel aus der Digitalen Signalverarbeitung

Abb. 20. Beispiel eines Signalflussdiagramms für einen PID-Regler Algo-rithmus mit Grundelementen Addierer , Multiplizierer , und Verzögerungs-/Speicherelement Z−1

PD Stefan Bosse 56


Abb. 21. Abbildung auf Petri-Netz (Funktionsblöcke/Operationen aufÜbergänge, Daten auf Stellen) und hier umgekehrt schließlich auf CSP (pro-cess) mit Kommunikationskanälen (channel) und ConPro Programmiersprache.

6.3. Deadlocks in Petri-Netzen

ä Deadlocks in Petri-Netzen entstehen durch Konflikte oderMehfachauswahl bei Übergängen (Nicht-Determinismus), wo die Reihen-folge der Aktivierungen maßgeblich ist.

1. PN mit genau einer Kante zu und von jeder Stelle sind dead-lock/konfliktfrei!

2. PN wo alle Übergänge höchstens einen Eingangs- und Ausgangsplatz be-sitzen sind deadlock/konfliktfrei!

PD Stefan Bosse 57


Abb. 22. Beispiel einer Deadlock Situation die in einem Petri-Netz auftretenkann, in Abhängigkeit von der Reihenfolge der Aktivierungen der Übergänge

6.4. Verhaltensmodelle

Zustands-basiert (Verhalten)

Reaktive Systeme:

ä Finite State Machines

ä Petri-Netze

ä Hierarchische nebenläufige FSMs

Aktions-basiert (Verhalten)

Transformatorische Systeme:

ä Datenflussgraph

ä Kontrollflussgraph

Heterogene Modelle

ä Programmflussgraph: Kontrollflussgraph + Datenflussgraph

ä Programmiersprachliche Paradigmen

PD Stefan Bosse 58


Daten-, Kontroll-, und Programmfluss

ä Ein Programm wird durch einen Programmfluss beschrieben

ä Der Programmfluss lässt sich in reine Daten- und Kontrollanweisungenzerlegen → Daten- und Kontrollfluss

ä Der Datenfluss wird durch den Datenpfad implementiert (Verhaltens-beschreibung des Datenpfades, mit Datenabhängigkeitsgraphen) → Reg-ister, Funktionale Operatoren, Datenpfadselektoren (Multiplexer)

ä Der Kontrollfluss wird durch den Kontrollpfad implementiert (Verhaltens-beschreibung des Kontrollpfades mit Zustandsübergangsgraphen) → Zus-tandsautomat

ä Datenanweisungen verwenden arithmetische, relationale, und BoolescheAusdrücke

6.5. Datenabhängigkeitsgraphen

ä Eine Datenabhängigkeit in der Informatik ist eine Situation, in der sicheine Programmanweisung (Anweisung) auf die Daten einer vorhergehen-den Anweisung bezieht.

ä Ein Datenabhängigkeitsgraph G = (I, E) besteht aus einer Menge vonInstruktionen I und einer Menge transitiver Relationen R = I x I, mit (a,b) in R falls die Instruktion a vor b bewertet werden muss.

ä Mit anderen Worten, es gibt eine Kante von a nach b:

wenn a vor b ausgewertet werden muss.

Scheduling

ä Jeder Knoten (Anweisung) auf derselben Ebene ist unabhängig von deranderen → Parallelisierung

ä Um die Anweisungen in Level i auszuführen, müssen die Anweisungen inLevel i-1 beendet sein

PD Stefan Bosse 59


[Ortiz-Ubarri, José]

Abb. 23. Beispiel eines DAG für eine Instruktionssequenz (nur Datenanweisun-gen)

7. Parallelisierung

7.1. Parallelisierungsklassen

DatenflussDer Datenfluss beschreibt den Fluss von Daten durch Verarbeitungs- undSpeichereinheiten (Register).Die Verarbeitungseinheiten sind Knoten eines gerichteten Graphs, die Kan-ten beschreiben den Datenfluss und bilden die Datenpfade. Die Verar-beitungseinheiten müssen aktiviert werden.

KontrollflussDer Kontrollfluss beschreibt die temporale schrittweise Verarbeitung vonDaten im Datenpfad durch zustandsbasierte selektive Aktivierung von Ver-arbeitungseinheiten.Der Kontrollfluss kann durch Zustandsübergangsdiagramme beschriebenwerden.

ProgrammflussDer Programmfluss setzt sich kombiniert aus Daten- und Kontrollflusszusammen.

ä Programmanweisungen werden Zuständen S1,S2,.. zugeordnet.

PD Stefan Bosse 60


ä Einfache Anweisungen (Berechnungen) werden jeweils einem Zustand,komplexe Anweisungen i.A. mehreren Unterzuständen zugeordnet.

Abb. 24. Programm-, Kontroll-, und Datenflussgraphen

Datenparallelität

In vielen Programmen werden dieselben Operationen auf unterschiedliche Ele-mente einer Datenstruktur angewendet. Im einfachsten Fall sind dies die Ele-mente eines Feldes.

ä Wenn die angewendeten Operationen unabhängig voneinander sind, kanndiese verfügbare Parallelität dadurch ausgenutzt werden, um die zu ma-nipulierenden Elemente der Datenstruktur auf verschiedene Prozessorenzu verteilen, so dass jeder Prozessor die Operation auf den ihm zugeord-neten Elementen ausführt.

ä Parallelität im Datenpfad → Feine Granularität

ä Bei der Datenparallelität wird unterschieden zwischen:

o Parallele Ausführung der gleichen Instruktion auf verschiedenenDaten (Vektorparallelität) → Vektoranweisung

o Ausführung verschiedener Instruktionen die nur Daten verarbeiten(reine Datenanweisungen)

ä Zur Ausnutzung der Datenparallelität wurden sequentielle Programmier-sprachen zu datenparallelen Programmiersprachen erweitert. Diese ver-wenden wie sequentielle Programmiersprachen einen Kontrollfluss, deraber auch datenparallele Operationen ausführen kann.

o Z.B. µRTL: Bindung von mehreren Datenpfadanweisungen durchKommasyntax: x ← ϵ , y ← ϵ , .. , z ← ϵ ;

PD Stefan Bosse 61


ä Häufig werden Vektoranweisungen deklarativ und nicht prozedural imper-ativ beschrieben.

ä Beispiel für eine deklarative Vektoranweisung und die dazugehörige im-perative Anweisungssequenz in Schleifenform (Fortran 90):

..

a(1 : n) = b(0 : n − 1) + c(1 : n) ⇔FOR (i=1:n)a(i) = b(i-1) + c(i)

ENDFOR

ä Datenabhängigkeiten können zwischen der linken und rechten Seite einerDatenzuweisung bestehen, so dass

o zuerst auf alle auf der rechten Seite auftretenden Felder zugegrif-fen wird und die auf der rechten Seite spezifizierten Berechnungendurchgeführt werden,

o bevor die Zuweisung an das Feld auf der linken Seite der Vektoran-weisung erfolgt!

ä Daher ist folgende Vektoranweisung nicht in die folgende Schleife trans-formierbar:

..

a(1 : n) = a(0 : n − 1) + a(2 : n + 1) ̸=FOR (i=1:n)a(i) = a(i-1) + a(i+1)

ENDFOR

ä Datenparallelität benötigt i.A. keine weitere Synchronisation

Instruktionsparallelität

ä Parallelität im Kontrollpfad (Zustandsautomat) auf Instruktions- undProzessebene → Grobe Granularität je nach Anzahl der Instruktionenpro Prozess (Task)

ä Gebundene Instruktionsblöcke sind Parallelprozesse (Par Prozesskon-struktor)

ä Bekannt als Multithreading Programmier- und Ausführungsmodell (z.B.pthreads)

ä Instruktionsparallelität benötigt i.A. Synchronisation zwischen den einzel-nen Prozessen

PD Stefan Bosse 62


Möglichkeiten der Parallelisierung

1. Parallelität auf Bitebene (jegliche funktionale Operation)

2. Parallelität durch Pipelining (nur Datenströme)

3. Parallelität durch mehrere Funktionseinheiten:

ä Superskalare Prozessoren

ä Very Large Instruction Word (VLIW) Prozessoren

4. Funktionsparallelität (Evaluierung der Funktionsargumente und Rekur-sion)

5. Parallelität auf Prozess- bzw. Threadebene (Kontrollpfadebene)

7.2. Parallelisierungsmethoden

Abrollung von Schleifen

ä Das Abrollen von Schleifen ist eine der gängigsten Parallelisierungsmeth-oden bei der Schleifen durch Replikation der Schleifeninstruktionen(Schleifenkörper) in eine paralellisierbare Anweisungssequenz

o teilweise

o oder vollständig transformiert werden.

Definition 9.

..

FOR i = i1 to i2 DOFOR j = j1 to j2 DO..IB(i,j,x(i,j),x(i+1,j),..,);

ENDEND ⇒IB(i1,j1,x(i1,j1),x(i1+1,j1),..) ∥IB(i1+1,j1,x(i1+1,j1),x(i1+2,j1),..) ∥IB(i1+n,ij+m,x(i1+n,ij+m),x(i1+n+1,j1+m),..) ∥..

ä Zu Beachten sind Datenabhängigkeiten zwischen einzelnen Anweisungsit-erationen und Kosten durch die Abrollung (Overhead)

PD Stefan Bosse 63


ä Beispiel: Nicht abrollbar und parallelisierbar durch DatenabhängikeitISb(ISb−1(ISb−2(..)) !

..

X := 1;FOR i = a to b DOIS: X := X*i;

END

Deklarative Beschreibung von Vektoroperationen

ä In der Bildverarbeitung werden Vektoroperationen (und Matrixoperatio-nen) sehr häufig verwendet. Dabei werden häufig die gleichen Operationenauf alle Pixel eines Bildes (Feldelemente) angewendet.

ä Anstelle der iterativen Berechnung mittels Schleifen definiert man deklar-ativ die Berechnung eines Pixels (Punktoperator) oder eines Bereichesdes Bildes (Lokaloperator):

Definition 10.img′ = F (img) ::= {f(x)|x ∈ img} ⇔

..

PROCEDURE F (img: VECTOR OF type):BEGINRETURN f(img)

END

PD Stefan Bosse 64


Beispiel Punktoperator

Abb. 25. Algorithmus: Transformation von Farb- in Grauwertbilder [2]

JavaScript

ä JavaScript (und andere funktionalen Programmiersprachen) arbeiten in-tensiv mit Listen und Arrays

ä Listen und Arrays lassen sich mittels eines Abbildungsoperators und einerElementfunktion (Punktoperator) transformieren (map-and-reduce)

..

var img = [ 21,2,6,28,2,3,4,6,9,100,20 ];function gray2color (img) {return {r:img,g:img,b:img }

}var img2 = img.map(gray2color);

Lokaloperatoren

ä Lokale Operatoren sind rechenintensiver als Punktoperatoren. Um einneues Pixel zu berechnen wird der alte Wert des Pixels sowie die alten

PD Stefan Bosse 65


räumlich benachbarten Werte der Pixel innerhalb einer definierten maxi-malen Entfernung verwendet.

ä Für eine 3x3-Nachbarschaftsberechnung werden zum Beispiel Neun Daten-werte für jedes Pixel benötigt.

ä Für die Berechnung lokaler Operatoren wird eine bestimmte Anzahl vonparallelen Datenaustauschvorgängen benötigt → Kommunikation.

ä Wenn jedes Pixel auf einem anderen Prozessor gespeichert wird ist Kom-munikation teuer!

Beispiel Lokaloperator

Abb. 26. Komplexitätsreduktion durch Separation der Operatoren: (1) AlleZeilenoperationen werden parallel ausgeführt (2) Alle Spaltenoperationen wer-den parallel ausgeführt

Abb. 27. Algorithmus: Parallele Nachbarschaftsberechnung

Basisblock Optimierer und Scheduler

ä Nebenläufigkeits- und Datenabhängigkeitsanalyse

ä Ziel: Reduktion von Zeitschritten, Minimierung der Latenz, Paral-lelisierung

1. Basisblöcke sind Bereiche im Programmflussgraphen, die nur einen Kon-trollzugang am Kopf und nur einen Kontrollausgang am Ende haben, und

PD Stefan Bosse 66


keine weiteren Seiteneingänge.

2. Ein Basisblock der nur aus Datenanweisungen besteht ist ein Major-Block. Dieser wird in elementare Minor-Blöcke zerlegt, die wenigstenseine Anweisung enthalten (bei einem gebunden Block der ganze Block)

3. Es werden Datenabhängigkeitsgraphen für jeden Major-Block erstellt.

4. Nicht abhängige Anweisungen werden durch einen Scheduler mit ASAP-Verhalten in einen gebundenen Block (paralleler Prozess) zusammenge-fasst.

7.3. Funktionale Programmierung

ä Determinismus macht paralleles Auswerten der Argumente und Paral-lelisierung bei Rekursion möglich

ä Parameter von Funktionen sind datenunabhängig→ Parallele Evaluierungder Funktionsargumente bei der Funktionsapplikation

ä Funktionsaufrufe sind gänzlich oder partiell datenunabhängig → Paral-lelisierung der Funktionsaufrufe (Endrekursion, Kopfrekursion bringt keinVorteil)

ä Probleme:

o Argumente haben teils kein ausreichendes Potential (Ausdrücke zueinfach und zu flach)

o Große Rekursionstiefen können zu einer zu feinen Aufteilung führen→ nicht gut auf Prozessoren aufzuteilen

7.4. Asynchrone Ereignisverarbeitung

ä Neben der Parallelisierung der reinen Datenverarbeitung (Berechnung)kann auch eine Partitionierung von Ein- und Ausgabe bzw. derEreignisverarbeitung erfolgen

ä Bekanntes Beispiel: Geräteinterrupts mit einfachen Foreground-Background System mit zwei Prozessen:

o P1: Hohe Priorität (Ereignisverarbeitung → Interrupthandler →Foreground Prozess)

o P2: Niedrige Priorität (Berechnung → Hauptprogramm → Back-ground Prozess) mit Preemption durch Ereignisverarbeitung

PD Stefan Bosse 67


ä Ein- und Ausgabeoperationen eines Programms können synchron (block-ierend) oder asynchron (im Hintergrund verarbeitet und nicht block-ierend) ausgeführt werden.

Beispiel JavaScript

ä Synchrone Operationen liefern das Ergebnis in einer Datenanweisungzurück die solange blockiert wird bis das Ereignis eintritt(Ergebnisdatenverfügbar sind). Dabei werden zwei aufeinander folgende Operationensequenziell ausgeführt, und eine folgende Berechnung (nicht ereignisab-hängig) erste nach den Ereignissen ausgeführt:

..

x = IO1(arg1,arg2,..);y = IO2(arg1,arg2,..);z = f(x,y);

ä Bei der asynchronen (nebenläufigen) Ausführung von ereignisabhängigenOperationen wird das Ergebnis über eine Callback Funktion verarbeitet.Die IO Operation blockiert nicht. Vorteil: Folgende Berechnungen könnenunmittelbar ausgeführt werden.

..

IO1(arg1,arg2,..,function (res) { x=res; });IO2(arg1,arg2,..,function (res) { y=res; });z = f(x,y); // Problem?

PD Stefan Bosse 68


Abb. 28. Ereignisbasierte Verarbeitung von asynchronen Operationen innode.js/jxcore: Ein JS Thread verbunden über die Eventloop mit N IO Threads

Synchronisation

ä Asynchoene Ereignisverarbeitung mit preemptiven Verhalten benötigt ex-plizite Synchronisation (Locks…) zur Atomarisierung von kritischen Bere-ichen

ä Asynchrine Ereignisverarbeitung spaltet den Datenfluss auf und benötigtDaten- und Ergebnissynchronisation über Prädikatfunktionen oder ex-plizite Synchronisation:

..

var x,y,z;function P(f,x,y,z) {if (x!=undefined && y!=undefined)return f(x,y);

else return z;}IO1(arg1,arg2,..,function (res) { x=res; z=P(f,x,y,z)});IO2(arg1,arg2,..,function (res) { y=res; z=P(f,x,y,z)});

PD Stefan Bosse 69


8. Parallele Programmierung

8.1. Überblick

8.2. JavaScript :: Daten und Variablen

ä Variablen werden mit dem Schlüsselwort var definiert→ Erzeugung einesDatencontainers!

ä Es gibt keine Typendeklaration in JS! Kerntypen:

Tcore={number, boolean, object, array, string, function}

ä Alle Variablen sind polymorph und können alle Werttypen aufnehmen.

ä Bei der Variabledefinition kann ein Ausdruckswert zugewiesen werden

..var v = ϵ,..; v = ϵ;

8.3. JavaScript :: Funktionen

ä Funktionen können mit einem Namen oder anonym definiert werden

ä Funktionen sind Werte 1. Ordnung → Funktionen können Variablen oderFunktionsargumenten zugewiesen werden

ä Eine Funktion kann einen Wert mit der return Anweisung zurückgeben.Ohne explizite Wertrückgabe → undefined

ä Es wird nur Call-by-value Aufruf unterstützt - jedoch werden Objekte,Funktionen und Arrays als Referenz übergeben; Parameter pi sind anFunktionsblock gebunden

..function name (p1,p2,..) { statements ; return ϵ } name(ϵ1,ϵ2,..)

ä Da in JavaScript Funktionen Werte erster Ordnung sind können

o Funktionen an Funktionen übergeben werden und

o Funktionen neue Funktionen zurückgeben (als Ergebnis mit return)

ä Es können daher anonyme Funktionen function (..) {..} definiertwerden die entweder einer Variablen als Wert oder als Funktionsargumentübergeben werden.

PD Stefan Bosse 70


..

var x = function (pi) { ϵ(pi) }array.forEach(function(elem,index) { ϵ(pi) }

8.4. JavaScript :: Datenstrukturen

..

In JavaScript sind Objekte universelle Datenstrukturen (sowohl Daten-strukturen als auch Objekte) die mit Hashtabellen implementiert wer-den. Arrays werden in JavaScript ebenfalls als Hashtabelle implemen-tiert!. D.h. Objekte == Datenstrukturen == Arrays == Hashtabellen.

ä Es gibt kein nutzerdefinierbares Typensystem in JavaScript.

ä Eine Datenstruktur kann jederzeit definiert und verändert werden (d.h.Attribute hinzugefügt werden)

..

var dataobject = {a:ϵ,b:ϵ, ..f:function () { .. }

}..dataobject.c = ϵ

ä Dadurch dass Objekte und Arrays mit Hashtabellen implementiert (d.h.Elemente werden durch eine Textzeichenkette referenziert) werden gibtes verschiedene Möglichkeiten auf Datenstrukturen und Objektattributezuzugreifen:

..

dataobject.attributedataobject["attribute"]array[index]array["attribute"]

8.5. JavaScript :: Objekte

ä Objekte zeichnen sich in der objektorientierten Programmierung durchMethoden aus mit der ein Zugriff auf die privaten Daten (Variablen) einesObjekts möglich wird.

PD Stefan Bosse 71


ä In JavaScript kann auf Variablen eines Objekts (die Attribute) immerdirekt zugegriffen werden.

ä Attribute können Funktionen sein - jedoch können die Funktionen nichtwie Methoden direkt auf die Daten des Objektes zugreifen.

ä Daher definiert man Methoden über Prototypenerweiterung in JavaScript.

ä Die Methoden können über die this Variable direkt auf das zugehörigeObjekt zugreifen (also auch auf die Variablen/Attribute)

ä Es gibt eine Konstruktionsfunktion für solche Objekte mit Prototypendef-inition der Methoden

ä Objekte werden mit dem new Operator und der Konstruktionsfunktionerzeugt.

..

function constructor (pi) {this.x=ϵ..

}constructor.prototype.methodi = function (..) {this.x=ϵ;..

}...

var obj = new constructor(..);

8.6. JavaScript :: threads.js

ä Die threads.js Bibliothek implementiert das CCSP Multiprozessmodellmittels Multithreading von jxcore

ä Die Bibliothek muss mittels require('./threads').init(options)geladen und initialisiert werden

Ausführungsmodell

ä Es werden Prozesse auf Threads abgebildet die bestenfalls 1:1 auf denCPUs / Cores ausgeführt werden. Es gibt eine Obergrenze an Threads(max. 64) die statisch bei der Initialisierung des threads Moduls über dieOptionen festgelegt werden müssen(numthr:number).

PD Stefan Bosse 72


ä Prozesse können synchronisiert auf geteilte Objekte (konkurrierend) zu-greifen. Der Zugriff erfolgt durch Nachrichtenaustausch mit dem Haupt-thread (Hauptprozess).

Abb. 29. Threadmodell und Kommunikation der Prozesse mit geteilten Ob-jekten

Prozesskonstruktoren

Seq([f 1,f 2,..])Der Seq Konstruktor erzeugt eine sequenzielle Komposition von Prozessen(über einer Array von Funktionen definiert). Da JavsScript inhärent sequen-ziell ist gleichbedeutend mit: f 1();f 2();..

Par([f 1,f 2,..],{shared})Der Par Konstruktor erzeugt eine parallele Komposition von Prozessen (übereiner Array von Funktionen definiert). Alle Subprozesse werden nach Erzeu-gung automatisch gestartet. Der aufrufende Prozess wird blockiert bis alleSubprozesse terminiert sind. Ein shared environment kann mit geteilten(IPC) Objekten übergeben werden.

PD Stefan Bosse 73


Fork([f 1,f 2,..],{shared})Der Fork Konstruktor erzeugt eine parallele Komposition von Prozessen(über einer Array von Funktionen definiert). Alle Subprozesse werden nachErzeugung automatisch gestartet. Der aufrufende Prozess wird nicht block-iert! Ein shared environment kann mit geteilten (IPC) Objekten übergebenwerden.

Geteilte Ressourcen

ä Prozesse können sich Ressourcen teilen:

o Interprozesskommunikation (Channel, Semaphore, ..)

o Arrays (Matrizen)

ä Geteilte Ressourcen müssen explizit erzeugt werden und als zweites Argu-ment an die Prozesskonstruktoren übergeben werden.

..

Par([function process1 () {var x;x=ch.read();log(x);

},function process2 () {var x=Math.random();ch.write(x);log(x);

}],{ch:Channel()

})

Weitere Prozesskonstruktoren:

Alt([[f 1,cond,f 1,do],[f 2,cond,f 2,do,..],{shared})Der Alt Konstruktor erzeugt eine parallele Komposition von Prozessen (überein Array von Funktionsarrays definiert) von denen aber nur ein blockierterkonditionaler Prozess selektiert (aktiviert) wird. Jeder konditionale Prozesskann eine blockierende Operation ausführen. Der erste bereite Prozess wirdausgeführt mit nachfolgender Aktivierung (eines optionalen) do Prozesses.Der aufrufende Prozess wird blockiert bis ein Subprozess terminiert ist.

PD Stefan Bosse 74


ä Alternative Prozesskonstruktoren werden eingesetzt um

o Auf eine Menge von synchronisierenden Kommunikationskanälen se-lektiv auswählend zugreifen zu können

..

Alt([[function process1,cond () {x=ch1.read();

},function process1,do () {log(x);

},],[function process2,cond () {x=ch2.read();

},function process2,do () {log(x);

},],..

],{ch1:Channel(),ch2:Channel(),..

})

ProcessArrayDer ProcessArray Konstruktor erzeugt eine parallele Komposition von einemArray von N Prozessen (über eine einzige Funktion definiert). Alle Sub-prozesse werden nach Erzeugung automatisch gestartet. Den Prozessen wirdbeim Start ein Index als Argument übergen. Der aufrufende Prozess wirdblockiert wenn wait auf True gesetzt wird (Verhalten wie Par Konstruktor),ansonsten wird er nicht blockiert (Verhalten wie Fork Konstruktor)!

PD Stefan Bosse 75


..

ProcessArray(function (index) {..},N,,{environment}wait?

)

8.7. JavaScript :: threads.js :: IPC

IPC Objekte

Channel(depth)Ein Channel stellt synchronisierten Datenaustausch zwischen Prozessen her.Ein Channel mit depth=0 (oder kein Argument) implementiert das klas-sische Rendezvous System: Schreiber wird blockiert bis Leser zugreift undumgekehrt. Ansonsten gibt depth die Anzahl der Speicherzellen des FIFOsan. Ein Channel ist polymorph und kann gelesen oder beschrieben werdenmit folgenden Operationen:

..

x = channel.read()channel.write(ϵ)

Semaphore(init)Eine Sempahore stellt Synchronisation in Produzenten-Konsumenten Syste-men über einen geschützten Zähler her. Der Startwert init des Zählers mussangegeben werden. Der Zähler kann um eins erhöht oder erniedrigt werden.

Es stehen folgende Operationen zur Verfügung:

..

semaphore.up()semaphore.down()

… weitere folgen …

Shared Memory

ä Es stehen zwei verschiedene geteilte Speicherobjekte zur Verfügung:

PD Stefan Bosse 76


Matrix(dims: number [],init?:number|function)Eine n-dimensionale Float32 Matrix die zwischen parallelen Prozessen geteiltwerden kann.Der Zugriff auf die Zellen der Matrix erfolgt mit den Op-erationen m.read(index1:number, index2:number, ..) →number und m.write(val:number,index1:number, index2, ..).Es gibt die Möglichkeit die Float32 Matrix mittels derm.slice(range1:(number|number []|null), range2, ..) Opera-tion in ein (nicht teilbares) natives Array zu wandeln. Der Platzhalter nulloder undefined wählt den gesamten Indexbereich der jeweiligen Dimensionder Matrix aus.

Memory(length:number,init?:number|function)Ein lineares Byte8 Buffer Array das zwischen parallelen Prozessen geteiltwerden kann. Der Zugriff auf die Zellen erfolgt wie bei nativen Arraysb[index:number].

ä Achtung bei threads.js Version < 1.1.22: Der erzeugende Prozess (main)muss b.buffer verwenden (ausgenommen Prozesse in einem Seq Kon-struktor wo der Buffer über das environment übergeben wird). Alle in-neren Prozesse die den Buffer als geteilte Ressource (über das shared en-vironment) nutzen verwenden direkt b!

Beispiele

PD Stefan Bosse 77


..

var m = Matrix([1000,1000],Math.random);var b = Memory(1000000,0);b[0]=1;m.write(0,[99,123]);var msub = m.slice([null,0]); // returns first row as ArrayPar([function () {for(var i=1;i<100;i++)mat1.write(mat1.read([i,2])-buf1[i],[i-1,2]);

},function () {for(var i=1;i<100;i++)mat1.write(mat1.read([i,3])-buf1[i],[i-1,3]);

}],{mat1:m,buf1:b

});

9. Synchronisation und Kommunikation

9.1. Nebenläufigkeit, Wettbewerb, und Synchronisation

Definition 11.Nebenläufigkeit mit Konkurrenz. Operationen in verschiedenen Prozesseneines Programms konkurrieren z. B. um gemeinsame Ressourcen → Wettbe-werb.

Konkurrenz bedeutet optionale Parallelität und kann auch sequenziell ausge-führt werden!

Definition 12.Parallelität. Parallele Ausführung auf Verarbeitungs- und Systemebene mitzeitlicher Überschneidung von Ereignissen und Operationen ohne zwangsläufigmit Wettbewerb.

ä Konkurrierender Zugriff auf geteilte Ressourcen wie z. B. Speicheroder Kommunikationskanäle müssen synchronisiert werden, z. B. mit mu-

PD Stefan Bosse 78


tualen Ausschluss (Mutex) und zeitlicher Sequenzialisierung→ Schutz kri-tischer Ausführungsbereiche

ä Zeitliche ereignisbasierte Synchronisation z.B. mit Semaphoren odereinfacher mit Events werden in Produzenten-Konsumenten Anwendungenbenötigt, z.B.

o Bei der Partitionierung und Verteilung von Eingabedaten aufmehrere Prozesse (Produzenten);

o Der Annahme und Verarbeitung durch die einzelnen Prozesse (Kon-sumenten); sowie

o Bei der Einsammlung von Ergebnis-/Ausgabedaten.

ä Synchronisation ist Kommunikation und dient der Bewahrung vonInvarianten der Datenverarbeitung (Datenkonsistenz)!

ä Synchronisationsobjekte sind ebenfalls geteilte Ressourcen!!!!!

9.2. Der Mutuale Ausschluss: Ein Problem und seine Def-inition

Definition 13.Kritischer Bereich. Sequenzielle Ausführung einer AnweisungssequenzK={I1,I2,..} in einem parallelen Programm darf nur von einem einzigen Prozesszur gleichen Zeit ausgeführt werden. Ein kritischer Bereich K ist daher einegeschützte Ressource.

Definition 14.Mutualer Ausschluss. Es muss einen Algorithmus geben der sicher stelltdass immer und maximal nur ein Prozess pi aus einer Menge von ProzessenP={p1,p2,..} den kritischen Bereich K ausführen darf (die Ressource zugeteiltbekommt).

Definition 15.Wettbewerb. Konkurrieren mehrere Prozesse um die Ressource K , so gewinntmaximal einer, die anderen verlieren den Wettbewerb.

9.3. Eigenschaften von Parallelen Systemen

..

Ein solches Wettbewerbsproblem ist gekennzeichnet durch die Eigen-schaften Sicherheit und Lebendigkeit.

PD Stefan Bosse 79


..

Sicherheit bedeutet: Bedingung Anzahl der Prozesse im kritischen Bere-ich K muss |{ p | I(p) &in; K}| ≤ 1 immer erfüllt sein.

Eigenschaft (Liveness) Lebendigkeit → Starvation Freiheit

ä Starvation Freiheit bedeutet dass ein Prozess pi der die Ressource/denkritischen Bereich anfragt maximal eine endliche Anzahl von Zeiteinheiten/ Wettbewerben n ̸= ∞ durch jeden anderen Prozess umgangen werdenkann (Bypass, haben den Wettbewerb gewonnen).

Eigenschaft Deadlock Freiheit

ä Wenn bis zu einem beliebigen Zeitpunkt t eine Reihe von Prozessen ver-sucht haben den kritischen Bereich zu erlangen, ihn aber nicht erhaltenhaben, zu wird es in der Zukunft eine Zeit t’ > t geben, wo sie erfolgreichsind (d.h. die Anfrage-Operation terminiert).

ä D.h. eine Anfrage der Ressource terminiert mit einem gewonnen Wettbe-werb garantiert irgendwann.

o Starvation Freiheit impliziert Deadlock Freiheit!

o Worst case eines Deadlocks: alle Prozesse verlieren den Wettbewerb,keiner kann die Ressource mehr nutzen/zugeteilt bekommen!

Eigenschaft Begrenztes (Bounded) Bypass Kriterium

ä Es gibt eine Funktion f (N) für N Prozesse die die maximale Anzahl vonverlorenen Wettbewerben (bei Konkurrenz) angibt.

Service gegen Klienten Sichtweise

Der Service ist die Ressource, der kritische Bereich. Der Klient ist der Prozess,der die Ressource anfragt.

ä Aus Sicht des Service (Ressource) ist die Deadlock Freiheit wichtigstes Kri-terium. Der konkurrierende Wettbewerb führt immer dazu, dass irgendeinProzess die Ressource nutzen kann → die Ressource gewinnt immer.

PD Stefan Bosse 80


ä Aus Sicht des Klienten (Prozesses) ist die Starvation Freiheit wichtigstesKriterium. Wenn immer ein Prozess die Ressource anfragt, wird er sie(eventuell) zugeteilt bekommen → der Prozess gewinnt immer.

ä Es gibt daher eine Hierarchie der Lebendigkeitseigenschaften(entsprechend ihrer Stärke):

1. Bounded Bypass f (N)=X ⇒

2. Starvation Freiheit ≡ Endlicher Bypass f (N) ̸= ∞ ⇒

3. Deadlock Freiheit

Deadlock

ä Tritt häufig ein wenn zwei (oder mehrere) Prozesse gegenseitig eineRessource (Lock) beanspruchen die aber jeweils vom anderen bereitsbelegt ist.

o Prozesse, die bereits Sperren halten, fordern neue Sperren an.

o Die Anforderungen für neue Sperren werden gleichzeitig gestellt.

o Zwei oder mehr Prozesse bilden eine kreisförmige Kette, in der jederProzesse auf eine Sperre wartet, die vom nächsten Prozess in derKette gehalten wird → Dining Philosopher Problem.

PD Stefan Bosse 81


Abb. 30. Deadlocksituation zweier Prozesse die wechselseitig gesperrteRessourcen anfordern

9.4. Lock und atomare Operationen

Mutualer Ausschluss mit LOCK Objekt

ä Ein LOCK Objekt ist ein geteiltes Objekt dass sich in zwei verschiedenenZuständen SLOCK={FREE,LOCKED} befinden kann und eine Ressourceschützt:

State FREEDie Ressource ist nicht in Verwendung

State LOCKEDDie Ressource wird bereits von einem Prozess verwendet, andereProzesse müssen warten

ä Ein LOCK Objekt stellt Prozessen zwei Operationen zur Verfügung:

Operation ACQUIRE / LOCKEin Prozess kann eine Ressource anfordern. Ist der LOCK im ZustandSLOCK=FREE, wird dem anfordernden Prozess die Ressource gewährt (Zu-standsübergang SLOCK: FREE ⇒ LOCKED), andernfalls wird er blockiert

PD Stefan Bosse 82


bis die Ressource (vom Eigentümer) freigegeben wird.

Operation RELEASE / UNLOCKEin Prozess gibt eine zuvor mit ACQUIRE beanspruchte Ressource wiederfrei (Zustandsübergang SLOCK: LOCKED ⇒ FREE).

..

Ein Prozess muss die Operation ACQUIRE und RELEASE immer paar-weise verwenden!

Abb. 31. Zustandsdiagramm des LOCK Objekts

..

OBJECT L: LOCKVAR VPARPROCESS P1 IS PROCESS P2 ISWHILE (True) WHILE (True)non-critical section non-critical sectionL.ACQUIRE() L.ACQUIRE()critical section(V) critical section(V)L.RELEASE() L.RELEASE()non-critical section non-critical section

DONE DONE

Abb. 32. Beispiel der Nutzung eines LOCK Objekts für den Schutz von kritis-chen Bereichen beim Zugriff auf geteilte Ressourcen

ä Das LOCK Objekt löst das mutuale Ausschlussproblem (mutual exclu-sion), und wird daher auch als Mutex bezeichnet.

ä Mehr als zwei Prozesse können mit einem LOCK synchronisiert werden.

PD Stefan Bosse 83


Synchronisation durch Blockierung

ä Ereignisbasierte Synchronisation blockiert die Ausführung von Prozessenbis das Ereignis auf das gewartet wurde eingetreten ist.

o Hier die Freigabe eines belegten LOCKs

Atomare Ressourcen: Register

ä Ein Lese/Schreib Register ist die einfachste Form einer geteilten Ressourceund wird für die Implementierung eine LOCK Objektes benötigt.

Definition 16.Atomares Register. Der Zugriff auf ein atomares Register R erfolgt mit-tels zweier Operationen OP={READ,WRITE}: R.READ(), welches den ak-tuellen Wert von R zurück liefert, und R.WRITE(v), welche einen neuen Wertin das Register schreibt. Dabei ist ein Konflikt durch konkurrierende Schreib-und Lesezugriffe von einer Menge von Prozessen durch mutualen Ausschlussaufgelöst!

Besipielssituation

..

VAR GLOBAL SHARED: R (VAR LOCAL NOTSHARED: x)P1: VAR x P2: VAR x P3: VAR x|x := ϵ(R)| |R := ϵ(x)| |R := ϵ(x)|

Eigenschaften eines atomaren Registers

Ein atomares geteiltes Register erfüllt dabei folgende Eigenschaften:

ä Zugriffe (op=READ/WRITE) erscheinen als wären sie zu einem einzigenZeitpunkt τ(op) ausgeführt worden.

ä Der Zeitpunkt der Ausführung der Operation liegt garantiert innerhalbdes Intervalls:τ(opS) ≤ τ(op) ≤ τ(opE), mit

o S: Start und E: Ende der Operation (gemeint ist: Aktivierung durchProzess)

ä Für zwei verschiedene Operationen op1 und op2 gilt:τ(op1) ̸= τ(op2)

PD Stefan Bosse 84


ä Jede Lese-Operation gibt den Wert zurück der von der am nächsten (inder Vergangenheit) liegenden Schreibe-Operation resultiert.

..

Das bedeutet: ein atomares Register verhält sich so als ob die Ausführungaller Operationen sequenziell ausgeführt worden wäre.

Komposition mit atomaren Objekten

ä Atomarität erlaubt die einfache Komposition von geteilten (atomaren)Objekten zu neuen geteilten und atomaren Objekten ohne zusätzlichen(Synchronisations-) Aufwand.

ä D.h. wenn eine Menge von für sich atomaren Registern {R1,R2,..} mitden Operationen {R1.READ,R1.WRITE}, {R2.READ,R3.WRITE}, .. zueinem neuen Objekt (R1,R2,…) zusammengefasst (komponiert) werden, soist dieses ebenfalls atomar.

Abb. 33. Beispiel von konkurrierenden und zeitlich überlappendenSchreib/Lese Zugriffen auf ein atomares Register

9.5. Mutex

ä Eine Mutex garantiert mittels eines LOCK Objekts den mutualen Auss-chluss durch Erfüllung einer Invariante, d.h. einer logischen Bedingung

PD Stefan Bosse 85


die niemals verletzt werden darf.

ä Angenommen eine Menge von Prozessen {P1,P2,..} wollen durch Mu-tualen Ausschluss sicher stellen dass immer nur ein Prozess sich im kritis-chen Bereich CS befindet (pi=True). Dann gilt für die Invariante derMutex:

Mutex : (p1 ⊕ p2 ⊕ ..⊕ pn ⊕ (¬p1 ∧ ¬p2.. ∧ ¬pn))

ä Das Prädikat Mutex muss eine globale Invariante sein, die mit atomarenRegistern implementiert werden kann.

ä Die Blockierung eines oder mehrere Prozesse beruht prinzipiell auf eineratomaren Schleife die auf das Eintreten einer booleschen Bedingungwartet, z.B. in der Form|await (cond) then (action)|

o Die Anweisung blockiert den Prozess solange cond nicht wahr ist unddann unmittelbar (atomar) die Anweisung action ausführt (Daten-zuweisung) → Test-and-set

Protokolle

ä Es muss in jedem Prozess der einen kritischen Bereich ausführen muss einEingangs- und Ausgangsprotokoll eingehalten werden damit der mutualeAusschluss garantiert werden kann.

ä Für die Implementierung dieses Protokolls soll gelten:

1. Mutualer Ausschluss und Einhaltung der LOCK Invariante (logische Be-dingung): Höchstens ein Prozess zur Zeit führt seinen kritischen Abschnittaus.

2. Keine Deadlocks und Livelocks: Wenn zwei oder mehr Prozesse versuchen,ihre kritischen Abschnitte zu betreten, wird mindestens einer erfolgreichsein.

3. Niedrige Latenz (niedrige Verzögerung): Wenn ein Prozess versucht, inseinen kritischen Abschnitt einzutreten, und die anderen Prozesse ihrenicht kritischen Abschnitte ausführen oder beendet haben, wird der ersteProzess nicht daran gehindert, in seinen kritischen Abschnitt einzutreten.

4. Garantierter Eintritt: Ein Prozess, der versucht, in seinen kritischen Ab-schnitt einzutreten, wird schließlich erfolgreich sein.

PD Stefan Bosse 86


Kritisches Abschnittsproblem: Grobe Lösung A.

..

bool in1 = false, in2 = false;## MUTEX: not(inl and in2) -- global invariantprocess CSl {while (true) {|await (!in2) then in1 = true|; /* entry */critical section|in1 = false|;noncritical section/* exit */

}}process CS2 {while (true) {|await (!in1) then in2 = true|; /* entry */critical section|in2 = false|;noncritical section/* exit */

}}

ä Die Lösung A. garantiert den mutualen Ausschluss aber nicht dieLebendigkeit einzelner Prozesse.

o Es können Wettlaufbedingungen eintreten (race conditions), wo im-mer nur einer oder einige wenige Prozesse den Wettbewerb gewinnen

PD Stefan Bosse 87


ä Ein fairer Scheduler ist erforderlich um Wettlaufbedingungen zu vermei-den!

Kritisches Abschnittsproblem: Grobe Lösung B. mit Spin Locks

ä Benötigt nur noch eine Variable → geringere Latenz!

..

bool lock = false;process CS1 {while (true) {|await (!lock) then lock = true|; /* entry */critical sectionlock = false;noncritical section;/* exit */

}}process CS2 {while (true) {|await (!lock) then lock = true|; /* entry */critical sectionlock = false;noncritical section/* exit */

}}

ä Da es nur zwei Zustände der Mutex gibt reicht eine Variable für die dieInvariante gilt:

lock = in1 ∨ in2

ä Weiterer Vorteil der Spin-Lock Lösung: Sie kann für beliebige N>2Prozesssysteme angewendet werden.

Test-and-set Operation

ä Die atomare await-then Anweisung ist prinzipiell eine atomare Test-and-set (TS) Operation, wie sie von vielen Mikroprozessoren als eigenständigerMaschinenbefehl zur Verfügung gestellt wird.

PD Stefan Bosse 88


..

bool TS (bool lock) {|bool initial = lock;lock = true;return initial|

}

ä Die bedingten atomaren Aktionen werdend ann durch Schleifen ersetzt,die erst dann enden, wenn die Sperre falsch ist, und TS gibt daher falsezurück.

ä Da alle Prozesse dieselben Protokolle ausführen, funktioniert die gezeigteLösung für eine beliebige Anzahl von Prozessen.

ä Wenn eine Sperrvariable als ein Spin Lock verwendet wird, heisst das,dass die Prozesse während des Wartens auf das Löschen der Sperre eineSchleife durchlaufen (rotieren).

ä Gegenseitiger Ausschluss ist sichergestellt:

o Wenn zwei oder mehr Prozesse versuchen, in ihren kritischen Ab-schnitt einzutreten, wird nur einer erfolgreich sein, der erste zu sein,der den Wert von lock von falsch auf wahr ändert

o Daher beendet nur einer sein Eintrittsprotokoll.

ä Die vorherigen Algorithmen können dann für N Prozesse mit einer TSOperation und einer bedingten Schleife implementiert werden, in der Art:

..

bool lock = false;process CS[i = 1 to n] {while (true) {while (TS(lock)) skip;critical sectionlock = false;noncritical section

}}

ä Es wird keine atomare Schleife mehr benötigt!

ä Aber auch hier ist der Eintritt (Lebendigkeit einzelner Prozesse) nichtgarantiert. Warum?

ä Weiterhin zeigt obiger Algorithmus bei Multiprozessorsystemen eineschlechte Performanz → Speicherzugriffe.

PD Stefan Bosse 89


Test-Test-and-Set Lösung

ä Besser eine geschachtelte und verkettete Kombination aus Test und Test-and-Set:

..

boo1 lock = false;process CS[i = 1 to n] {while (true) {while (lock) skip;while (TS(lock)) { while (lock) skip};critical sectionlock = false;noncritical section

}}

ä Diese Variante verbesserte den Speicherzugriff über die Cacheebene(probalistisch!)

Faire Lösung mit dem Tie-Breaker Algorithmus

ä Faires Scheduling durch “Fahrstuhlalgorithmus” und Iteration übermehrere (n-1) Ebenen:

..

int in[l:n] = ([n] 0), last[1:n] = ([n] 0);process CS[i = 1 to n] {while (true) {for [j = 1 to n] { /* entry protocol *//* remember process i is in stage j and is last */last[j] = i; in[i] = j;for [k = 1 to n st i != k] {/* wait if process k is in higher numbered stage and

process i was the last to enter stage j */while (in[k] >= in[i] and last[j] == i) skip;

}}critical sectionin[i] = 0;noncritical section}}

PD Stefan Bosse 90


Peterson-Algorithmus für das LOCK Objekt und zwei Prozessen

ä Algorithmus für die Operationen {ACQUIRE,RELEASE} des LOCKObjekts, der mutualen Ausschluss garantiert und Wettbewerb um einegeschützte Ressource ermöglicht.

ä Der Peterson Algorithmus besteht aus zwei Komponenten, die unter-schiedliche Eigenschaften des LOCK erfüllen.

ä Erfüllung des mutualen Ausschlusses

..

OPERATION ACQUIREA(i) IS OPERATION RELEASEA(i) ISAFTER_YOU := i RETURNWAIT UNTIL AFTER_YOU /= i END OPERATIONRETURN

END OPERATION

ä Dieser Teil garantiert den mutualen Ausschluss und löst das Wettbewerb-sproblem, d. h. maximal ein Prozess x von zwei Prozessen erlangt dieRessource und die Operation ACQUIRE(x) terminiert, der Operation AC-QUIRE(y) des anderen Prozesses y terminiert nicht.

ä Nachteil: Rendezvous ist erforderlich. Beide Prozesse müssen dieRessource anfordern, d.h. ein einzelner Prozess verliert seinen eigenenWettbewerb immer.

ä Erfüllung des Lebendigkeitskriteriums

..

OPERATION ACQUIREB(i) IS OPERATION RELEASEB(i) ISFLAG[i] := UP FLAG[i] := DOWNWAIT UNTIL FLAG[j] = DOWN END OPERATIONRETURN

END OPERATION

ä Dieser Teil löst das Problem, wenn nur ein Prozess zu gleichen Zeit an derRessource interessiert ist, und die ACQUIRE(i) Operation terminierenkann.

ä Nachteil: Deadlock wenn beide Prozesse gleichzeitig ACQUIRE Operationdurchführen. (beide setzen gleichzeitig ihr FLAG auf UP).

ä Zusammenführung beider Teilalgorithmen 1. und 2. führt zum Peter-son Algorithmus für die Implementierung der Operationen eines LOCKObjekts (Zwei Prozesse i und j).

PD Stefan Bosse 91


..

OBJECT LOCK ISREG FLAG[2],AFTER_YOUOPERATION ACQUIRE(i) IS OPERATION RELEASE(i) ISFLAG[i] := UP FLAG[i] := DOWNAFTER_YOU := i RETURNWAIT UNTIL FLAG[j] = DOWN OR END OPERATION

AFTER_YOU != iRETURN

END OPERATION

ä FLAG zeigt das Interesse an einer Ressource an mit Wertemenge {DOWN ,UP}.

ä AFTER_YOU besitzt die Wertemenge {1,2} und bezeichnet die Prozess-nummer.

ä FLAG und AFTER_YOU sind atomare Register (Single Write MultipleRead Verhalten).

ä Dieser Algorithmus erfüllt

o Mutuale Exklusion (max. ein Prozess erhält die Ressource)

o Bounded Bypass (ein Prozess gewinnt den Wettbewerb) mit f (n)=1

Mutual Exklusion Eigenschaft (I)

ä Der erste Prozess (i) führt FLAG[i] := UP und AFTER_YOU := *i aus

ä Der erste Prozess (i) terminiert durch FLAG[j]=DOWN

ä Der zweite Prozess (j) führt FLAG[j] := UP und AFTER_YOU := j aus

ä Der zweite Prozess (j) wartet

PD Stefan Bosse 92


Mutual Exklusion Eigenschaft (II)

ä Der erste Prozess (i) führt FLAG[i] := UP und AFTER_YOU := i aus

ä Der zweite Prozess (j) führt FLAG[j] := UP und AFTER_YOU := j aus

ä Der erste Prozess (i) terminiert durch AFTER_YOU = j

ä Der zweite Prozess (j) wartet

Bounded Bypass

ä Ein Prozess (j) besitzt die Ressource (FLAG[j] := UP)

ä Der andere Prozess (i) führt FLAG[i] := UP und AFTER_YOU := i aus

ä Eine zeit lang liest Prozess (i) FLAG[j] nicht.

PD Stefan Bosse 93


ä Während dessen gibt Prozess (j) die Ressource frei und führt FLAG[j] :=DOWN aus.

ä Danach beantragt Prozess (j) die Ressource erneut, und führt FLAG[j] :=UP und AFTER_YOU := j aus.

ä Der Prozess (i) liest AFTER_YOU=j und terminiert, Prozess (j) liestFLAG[i] = UP und wartet, d.h. f (n)=1 !

Peterson Algorithmus für N Prozesse

..

OBJECT LOCK ISREG FLAG_LEVEL[N],AFTER_YOU[N]OPERATION ACQUIRE(i) IS OPERATION RELEASE(i) ISFOR l = 1 TO (N-1) DOFLAG_LEVEL[i] := l FLAG_LEVEL[i] := 0AFTER_YOU[l] := i RETURNWAIT (∀ k != i:

FLAG_LEVEL[k] < l) ORAFTER_YOU[l] != i

RETURNEND OPERATION END OPERATION

ä Der N=2 Peterson Algorithmus erfüllt Deadlock Freiheit und starkenBounded Bypass!

ä Aber der N>2 Algorithmus erfüllt nur Deadlock Freiheit und schwachenFinite Bypass!

PD Stefan Bosse 94


Tournament tree

ä Ein einfaches Prinzip, um die Anzahl der Shared Memory-Zugriffe zu re-duzieren, ist die Verwendung eines Turnierbaumes. Ein solcher Baum istein vollständiger Binärbaum.

Abb. 34. N Prozesse führen Ebenenweise einen Lock jeweils mit einerZweiprozessmutex durch bis sie den finalen Wettbewerb gewonnen haben. DieZweiprozessmutex wird nur von zwei Prozessen geteilt und ist keine globaleRessource mehr!

9.6. Semaphore

Eigenschaften

ä Ein Semaphore Objekt S ist ein LOCK basiertes Synchronisationsobjektund ein geteilter Zähler mit Warteschlange S.counter, das folgendeEigenschaften erfüllt:

o Die Bedingung S.counter ≥ 0 ist immer erfüllt.

o Der Semaphorenzähler wird mit einem nicht-negativen Wert s0 ini-tialisiert.

o Es gibt zwei wesentliche Operationen {S.DOWN, S.UP} um denkonkurrierenden und synchronisierenden Zugriff auf eine Semaphorezu ermöglichen.

o Wenn #(S.DOWN) und #(S.UP) die Anzahl der Operationsaufrufeist, die terminiert sind, so gilt die Invariante:

S.counter = s0 + #(S.UP )− #(S.DOWN)

PD Stefan Bosse 95


Operationale Semantik

Operation WAIT/DOWNS.DOWN erniedrigt den Zähler S.counter atomar um den Wert 1 sofernS.counter > 0.Wenn S.counter=1 und mehrere Prozesse versuchen gleichzeitig die DOWNOperation anzuwenden, so wird einer den Wettbewerb gewinnen (MutualerAusschluss = LOCK). Wenn S.counter = 0 dann werden Prozesse blockiertund in einer Warteschlange S.Q eingereiht.

Operation SIGNAL/UPS.UP erhöht den Zähler S.counter atomar um den Wert 1. Diese Opera-tion kann immer ausgeführt werden, und blockiert nicht die Ausführung desaufrufenden Prozesses.Wenn S.counter = 0 ist und es blockierte Prozesse gibt, wird einer aus S.Qausgewählt und freigegeben (d. h. der Zähler ändert sich effektiv nicht).

..

Eine Semaphore mit s0=1 ist eine binäre Semaphore vergleichbar miteiner Mutex! Eine Semaphore ist stark wenn die blockierten (wartenden)Prozesse in der Reihenfolge wieder freigegeben werden in der sie blockiertwurden (First In First Out / FIFO Ordnung).

Algorithmus

..

OBJECT SEMAPHORE(init) ISVAR counter:INTOBJECT Q:QUEUE, L:LOCKOPERATION down(i) ISL.lock()IF counter = 0 THENQ := Q + {i}|L.unlock(),BLOCK(i)|

ELSEcounter := counter - 1L.unlock()

END IFRETURN

END OPERATION

PD Stefan Bosse 96


..

OPERATION up(i) ISL.lock()IF counter = 0 THENIF Q = {} THENcounter := counter + 1

ELSEj := Head(Q), Q := Tail(Q)UNBLOCK(j)

END IFELSEcounter := counter + 1

END IFL.unlock()RETURN

END OPERATION

9.7. Semaphore - Produzenten-Konsumenten Systeme

ä Semaphoren können eingesetzt werden um konkurrierende Produzenten-Konsumenten Probleme zu lösen. Beispiel ist ein Pufferspeicher mit First-In First-Out Reihenfolge, der eine endliche Anzahl von Speicherzelleneines geschützten Speichers Buf [0..k-1] mit k=size besitzt, und die bei-den Zustände S={FREE, FULL} annehmen kann.

o Schutz des Speichers bedeutet: gleichzeitiger Zugriff zweier Prozesseauf gleiche Speicherzelle Buf [x] muss verhindert werden.

o Schutz durch zwei Semaphoren FREE(k) und BUSY (0).

Implementierung eines Pufferspeichers mit Semaphoren

..

OBJECT BUFFER (size) ISVAR BUF: datatype[size], in,out: INTOBJECT FREE: SEMA(size),

BUSY:SEMA(0)OPEARTION produce(v) ISFREE.down()BUF[in].write(v)in := (in+1) mod sizeBUSY.up()

END OPERATION

PD Stefan Bosse 97


..

OPERATION consume ISBUSY.down()r := BUF[out].read()out := (out+1) mod sizeFREE.up()RETURN r

END OPERATIONEND OBJECT

Abb. 35. Synchronisation von Produzenten und Konsumenten von Daten mit-tels zweier Semaphoren

9.8. Semaphore - Dining Philosophers

ä Das Problem der fünf dinierenden Philosophen ist ein Beispiel für Dead-locks in verteilten und parallelen (asynchronen) Systemen mit dem Com-municating Sequential Processes Modell!

PD Stefan Bosse 98


ä 5 Philosophen an einem Tisch

ä 5 Gabeln, jeweils eine zwischen zwei Philosophen

ä Ein Philosoph braucht zwei Gabeln zum Essen!

ä Eine Gabel wird durch eine Semaphore repräsentiert (atomare Ressource,Startwert des Zählers ist 1)

Algorithmus

..

OBJECT ARRAY Forks [N]: SEMA(1)PROCESS ARRAY Philosopher [N]FOR try = 1 TO 10 DOTHINKING ...Forks[#id].down()Forks[#id+1 % N].down()EATING ...Forks[#id+1 % N].up()Forks[#id].up()

DONEEND

ä Klassisches Problems das zu Deadlocks führt!

Deadlockefreie Lösungen

1. Einführung einer zentralen Instanz die die Gabeln mittels Prior-itäswarteschlangen verwaltet

PD Stefan Bosse 99


ä Prozess fragt mit einer Nachricht zwei Gabeln an (Input Channel)

ä Verwalter prüft Verfügbarkeit und gewährt die Gabeln durch eineAntwortnachricht (Output Channel)

ä Ein Prozess gibt Gabeln mit einer Nachricht wieder zurück

2. Abfrage des Semaphorenwertes beider Gabeln bevor die Ressource ange-fragt wird ggf. über eine globale Mutex geschützt:

..

sema[left].down();if (sema[right].level() == 1) sema[right].down();else sema[left].up(),sleep(random time);

3. Münzwurf und Reihenfolge des Zugriffs: Eine Zufallszahl zwischen 0..1entscheidet ob zuerst die linke und dann rechte Gabel beansprucht wirdoder umgekehrt.

9.9. Monitor

ä Mutex und Semaphore sind low-level Synchronisationsobjekte

ä Monitore erlauben die Definition von konkurrierenden Objekten auf derAbstraktionsebene der imperativen Programmiersprachen → high-level.

ä Ein Monitor ist eine Generalisierung eines Objekts, welchesDaten und Operationen kapselt. Zugriff auf die interneRepräsentation erfolgt durch die Operationen mutual exklusiv.

PD Stefan Bosse 100


Konzepte

Mutualer AusschlussDer Monitor stellt sicher dass immer nur ein Prozess eine Operation desObjektes ausführen kann à geschützter kritischer Ausführungsbereich = mu-tualer Ausschluss.

..

Ein Prozess muss das Schloss des Monitors öffnen. Nachdem der Prozessden Monitor “betritt” (nutzt), schließt das Schloss automatisch wieder.Wenn der Prozess den Monitor verlässt wird das Schloss wieder automa-tisch geöffnet.

Events: Bedingungsvariablen mit Queues

ä Bedingungsvariablen C sind Objekte die interne Synchronisation er-möglichen sollen.

ä Bedingungsvariablen können nur innerhalb des Monitors durch folgendeOperationen verwendet werden:

Operation C.wait(cond)Diese Operation blockiert = stoppt den aufrufenden Prozess p und reiht ihnin die Warteschlange C.Q← C.Q + {p} ein. Für den Prozess der nicht mehraktiv ist, kann der Mutex LOCK aufgehoben werden.

ä Die Wait Operation stellte eine boolesche Bedingung cond dar auf derenErfüllung gewartet wird.

Operation C.signal()Ein Prozess p ruft diese Operation auf und erfüllt damit die Bedingung cond.

ä Wenn C.Q = ∅ ist dann hat die Operationen keinen Effekt

ä Wenn C.Q = {q,…} dann wird ein Prozess q aus Q ausgewählt und ak-tiviert, so dass C.Q ← C.Q \ {q}

Bewahrung des mutualen Ausschlusses in Fall ii.) erforderlich:

ä Der aktivierte Prozess q fährt innerhalb des Monitors fort (bekommt denEintritt wieder) und führt die Anweisungen nach C.wait() aus.

PD Stefan Bosse 101


ä Der aktivierende Prozess p wird blockiert, hat aber höchste Priorität denMonitor danach wieder zu erlangen um die Anweisungen nach C.signal()auszuführen.

Operation C.empty()Liefert das Ergebnis für die Bedingung C.Q = ∅

..

OBJECT CONDITION(M:MONITOR) ISOBJECT q: QUEUE

p: PROCESSOPERATION wait IS OPERATION signal ISp := MYSELF() IF q != {} THENq := q + {p} p := Head(q), q := Tail(q)|BLOCK(p) & M.l.unlock()| UNBLOCK(p)

END OPERATION END IFEND OPERATION

Abb. 36. Algorithmik der Bedingungsvariablen (vereinfacht)

..

MONITOR SEM ISVAR s:INTOBJECT c: CONDITIONOPERATION down IS OPERATION up ISIF s=0 THEN c.wait() s := s + 1s := s - 1 c.signal();

RETURN RETURNEND OPERATION END OPERATION

Abb. 37. Implementierung einer Semaphore mit Bedingungsvariablen (verein-facht)

ä Um den mutualen Ausschluss zu garantieren muss Vorrang der Prozes-sausführung und Aktionen mit Bedingungsvariablen definiert werden.

o Wartende bereite Prozesse (Menge W) deren Bedingung cond erfülltist.

o Signalisierende Prozesse (Menge S)

o Prozesse die noch keinen Eintritt in den Monitor erhalten haben(blockiert, Menge E)

o Prioritäten: Prio(W) > Prio(S) > Prio(E)

PD Stefan Bosse 102


..

Ein signalisierter (blockierter) Prozess der auf eine Bedingung C wartetwird sofort aktiviert (d. h. die Bedingung ist erfüllt).

Abb. 38. Verschiedene Prozessmengen bei Monitoren

ä Würde nach Aktivierung des wartenden Prozesses (cond=TRUE) auch dersignalisierende Prozess im Monitor aktiv sein könnte er die Bedingung, dieder Bedingungsvariablen zu Grunde liegt, wieder ungültig (cond=FALSE)machen und müsste ebenfalls wieder blockiert werden.

ä Es gilt daher für den Monitor die Erfüllung eines Prädikats P (boolescheBedingung), das die Datenkonsistenz des Objektes sicher stellen muss.

Varianten

signal-and-waitDer signalisierende Prozess wartet nach der Signalisierung und der mu-tuale Ausschluss ist sichergestellt und die Wahrung P=TRUE. Der wartendeProzess führt aus:IF ¬P THEN C.wait() END IF

signal-and-continue (re-check)Der signalisierende Prozess läuft weiter! Das könnte zur Verletzung desPrädikats P führen, daher muss der signalisierte Prozess nochmals dieGültigkeit P=TRUE prüfen so dass für ihn auszuführen ist:WHILE ¬P DO C.wait () END WHILE

PD Stefan Bosse 103


9.10. Event

ä Mit signal-and-continue Monitoren und Bedingungsvariablen lassen sicheinfache temporale ereignisbasierte Synchronisationsobjekte implemen-tieren.

ä Mehrere Prozess p1,p2,…,pN−1 können auf ein Event warten (OP E.await).Eine geordnete Warteschlange ist nicht erforderlich.

ä Dieses Event wird durch einen weiteren Prozess pN ausgelöst (OPE.wakeup), so dass alle blockierten inklusive des signalisierenden Prozessein der Ausführung fortfahren (auch zeitgleich).

Operationen

OPERATION awaitEin Prozess p wird blockiert bis das Ereignis (event) eintritt

OPERATION wakeupDie Operation aktiviert alle auf das Ereignis wartenden Prozesse {pi}.

..

MONITOR EVENT ISOBJECT c: CONDITIONOPERATION await IS OPERATION wakeupc.wait() c.signal();RETURN RETURN

END OPERATION END OPERATION

Abb. 39. Algorithmik des Event Objekts

Beispiel in JavaScript

PD Stefan Bosse 104


..

var ev = Event();var mem = Memory(16000);

ProcessArray(function () {var sum=0;ev.await();for(var i=0;i<mem.length;i++) sum += mem[i];print(sum);

},N,{waitForData: ev, data:mem, N:Value(N)});for(var i=0;i<mem.length;i++) mem[i]=Math.random()*256;ev.wakeup();

9.11. Barriere

ä Eine Barriere ist ein Rendezvous Objekt, oder auch ein selbst-auslösendesEvent. Es gibt eine (vorher) bekannte Gruppe aus N Prozessen{p1,p2,…,pN}

ä Jeder beliebige Prozess i=1..N -1 nimmt an der Barriere durch die B.awaitOperation teil und wird blockiert.

ä Der letzte (beliebige) Prozess pN ruft ebenfalls die Barriere mit derB.await Operation auf, wird jedoch nicht blockiert und aktiviert dabeidie wartenden Prozesse.

ä Alle Prozesse haben damit einen gemeinsamen Kontrollpunkt passiert.

Operationen

OPERATION awaitDer aufrufende Prozess p wird blockiert wenn #blocked(B) < N , ansonstenfährt er in der Ausführung weiter und aktiviert alle blockierten Prozesse.

OPERATION init(N :numebr)Setzt die Größe der Barrierengruppe (Anzahl der Prozesse N)

PD Stefan Bosse 105


..

MONITOR BARRIER (N) ISVAR counter: {0,1,..,N} := 0OBJECT q: conditionOPERATION await IScounter := counter + 1IF counter < N THEN q.await()ELSE counter := 0q.signal() END IFRETURN

END OPERATION

Abb. 40. Algorithmik der Barriere mit Monitor

9.12. Timer

ä Timer sind temporal selbstsynchronisierende Events.

ä Anstelle eines Auslöseprozesses führt der Timer nach Ablauf eines Zeitin-tervalls die wakeup Operation aus.

Operationen

OPERATION awaitDer aufrufende Prozess p wird blockiert bis der Timer ein wakeup ausführt.

OPERATION init(timeout:number,once:boolean)Setzt das Timerintervall und ein Flag ob der Timer einmalig oder periodischarbeitet

OPERATION startStartet den Timer

9.13. Channel

ä Anders als bei den vorherigen Synchronisationsobjekten dienen Kanäleund Warteschlangen der synchronisierten Nachrichtenübertragung zwis-chen Prozessen: Daten + Synchronisation

ä Kanäle werden auch häufig in der verteilten Programmierung eingesetzt.

ä Kanäle sind daher Semaphoren (Produzenten-Konsumenten System!) mitDaten

PD Stefan Bosse 106


ä Ein Kanal kann multidimensional sein (tupelbasiert)

Operationen

OPERATION read(x1,x2,..) / receive(x1,x2,..)Lesen eines Datenwertes oder Datensatzes und Übertragung der gelesenenWerte an die Variablenargumente (call-by-reference). Bedingung: Wennder Kanal leer ist wird der lesende Prozess solange blockiert und in eineProzesswarteschlange eingereiht bis ein schreibender Prozess teilnimmt.

OPERATION write(ϵ1,ϵ2,..) / send(ϵ1,ϵ2,..)Schreiben eines Datenwertes oder Datensatzes. Bedingung: Wenn der Kanalvoll ist wird der schreibende Prozess solange blockiert und in eine Prozess-warteschlange eingereiht bis ein lesender Prozess teilnimmt.

OPERATION emptyTestet den Kanal ob er leer ist (keine Daten enthält)

Abb. 41. Paralleler/Verteilter Map-reduce Algorithmus mit Kanälen zurSortierung von Listen

10. Parallelisierung und Metriken

10.1. Parallelität

ä Unterteilung in räumliche und zeitliche Parallelität

PD Stefan Bosse 107


ä Parallele Datenverarbeitung bedeutet Partitionierung eines seriellen Pro-gramms in eine Vielzahl von Subprogrammen oder Tasks

ä Weitere Unterteilung beider Dimensionen in Abhängigkeit von:

o Art der Tasks/Algorithmen

o Ausführungsmodell der Tasks und verwendete Rechnerarchitektur

o Art und Umfang der Wechselwirkung zwischen Tasks

o Kontroll- und Datenfluss eines Tasks

Räumliche ParallelitätDie Datenmenge D kann in Teilmengen di � D zerlegt werden. Die minimalerreichbare Größe der Teilmenge gibt Granularität bei der Parallelisierungwieder. Die Datenmenge D wird durch eine Verarbeitungsstufe in eineneue Datenmenge D’ transformiert, die dann von nachfolgenden Verar-beitungsstufen weiter verarbeitet wird. Beispiel : D=Bild ⇒ Glättung ⇒D’ ⇒ Objekterkennung ⇒ D‘’

Zeitliche ParallelitätZeitliche Parallelität ist vorhanden, wenn eine Folge von gleichartigen Daten-mengen D(n) repitierend mit dem gleichen Algorithmus verarbeitet werden→ Pipeline-Verfahren.

10.2. Datenabhängigkeit

ä Räumliche und zeitliche Parallelität führen zu räumlicher und zeitlicherDatenabhängigkeit.

ä Räumliche Datenabhängigkeit findet auf Intra- und Intertaskebene statt.

o Intrataskebene: Subtasks tauschen Daten aus → Sequenzielle Aus-führung. Beispiel: ST1: a=x+y; ST2: b=a+1; → b(a) → ST2(ST1)

o Intertaskebene: Übertragung von Daten zwischen Tasks in einerPipeline.

ä Zeitliche Datenabhängigkeit: Ergebnisse aus der Vergangenheit gehen inaktuelle Datenberechnung ein. Beispiel: Bewegungserkennung aus einerBild-Sequenz.

PD Stefan Bosse 108


Abb. 42. Räumliche und zeitliche Datenabhängigkeit ⇔ Vertikalen und hori-zontale Parallelisierung

10.3. Rechenzeit

ä Die Rechenzeit ttot für die Ausführung einer Pipeline T1…TM enthält:

1. Zeit zum Einlesen der Daten I(n),

2. Zeit für die Ausgabe der Daten und Ergebnisse,

3. Summe aller Ausführungszeiten der Tasks in der Pipeline, die sichaus Rechen- und Kommuniaktionszeiten zusammensetzten.

ttot =m∑i=1

τi +m−1∑i=1

td(Di,i+1) + tin + tout

τi = max{tcomp(Ti,j(dj))|1 ⩽ j ⩽ ni}+ tcomm(Ti)

als die Zeit die benötigt wird, einen Task i unter Berücksichtigung von Daten-abhängigkeiten der ni Subtasks T(dj) zu bearbeiten.

ä Längste Bearbeitungszeit eines Subtasks bestimmt Bearbeitungszeit desTasks τ i!

ä T i ist der i-te Task in der horizontalen Pipeline,

ä dj die Teildatenmenge eines Subtasks T i,i(dj) eines Tasks T i,

ä tcomp ist die Rechenzeit,

PD Stefan Bosse 109


ä tcomm die Intertaskkommunikationszeit,

ä tin und tout die Zeit zum Datentransfer in und aus der Pipeline, und

ä td(Di,i+1) die Datentransferzeit zwischen zwei Tasks.

ä In Vision-Systemen sind die ersten Tasks i.A. low- und mid-level Algorith-men, und die letzten Tasks high-level Algorithmen, die auf den Daten derunteren Ebenen aufbauen. Die einzelnen Datenströme Di können dahervon unterschiedlicher Größe und Art sein.

10.4. Klassifikation von parallelen AlgorithmenDatenabhängigkeit

Lokal, statischAusgangsdaten (�Ergebnisse) hängen nur von eng begrenzter kurzreichweit-iger Region der Eingangsdaten ab. Die Größe der Eingangsdatenregion istunveränderlich (statisch). → Kommunikationsbedarf ist gering.

Lokal, dynamischDie Größe der Eingangsdaten-Region ist parametrisiert und veränderlich(dynamisch). Z.B. bei mathematischer Faltung von Bildmatrizen ändertsich Größe der Region.

Global, statischDie Ausgangsdaten hängen gänzlich vom gesamter Eingangsdatenmenge ab.Abhängigkeit hängt nur von der Größe des Bildes, aber nicht von dessenInhalt ab. Z.B. Fouriertransformation oder Histogramm-Funktionen. →Kommunikationsbedarf ist groß.

Global, dynamischAusgangsdaten hängen von variierenden Ausschnittsregion der Eingangs-daten ab. Die Berechnung ist vollständig datenabhängig. Z.B. Hough-Transformation.

PD Stefan Bosse 110


Abb. 43. Klassifikation nach Kommunikationsbedarf aufgrund Datenab-hängigkeit zwischen einzelnen Tasks eines parallelen Programms

ä Weiterhin Klassifikation nach:

o Eingabedatenabhängigkeit

o Ergebnisabhängigkeit

10.5. Speedup

Bei der Datenverarbeitung gibt es drei Randbedingungen:

1. Gesamte Rechenzeit → Zeitdimension

2. Gesamte Ressourcenbelegung → Flächendimension

3. Bei der Parallelverarbeitung wird eine weitere Dimension hinzugefügt: An-zahl der Verarbeitungseinheiten sN

ä Die Nutzung von Parallelität führt zu einem Performanzgewinn (Speedup)durch Vergleich sequenzielles Programm (N=1) und paralleles Programm(N Prozessoren):

Speedup = S(N) =Performanz(N)

Performanz(1), St(n) =

Rechnenzeit(1)

Rechenzeit(N)

ä Die sog. Skalierung bei der Parallelisierung ist i.A. nicht linear:

0 < S(N) < N

ä Kommunikation ist weitere Randbedingung bei der parallelen Datenver-abeitung.

PD Stefan Bosse 111


10.6. Kosten und Laufzeit

Beispiel: Matrixmultiplikation

..

FUN matmult(A:ARRAY (p,q), B: ARRAY(p,q)) -> C:ARRAY (p,r)DEF matmult(A, B) =FOR i = 1 to p DOFOR j = 1 to r DOC[i,j] <- 0;FOR k = 1 to q DOC[i,j] <- C[i,j] + A[i,k] * B[k,j]END FOR k

END FOR jEND FOR i

END

ä Partitionierung kann beliebig erfolgen, da die einzelnen Ergebniswerte Ci,jnicht voneinander abhängen.

ä Datenabhängigkeit des Problems: Die Berechnung eines Ci,j Wertes hängtaußerhalb der FOR-k-Schleife von keinem anderen Wert Cn,m mit n ̸= iund m ̸= j ab.

ä Mögliche Partitionierungen der drei For-Schleifen auf N parallel arbeiten-den Verarbeitungseinheiten (VE):

1. Jede VE berechnet einen Ci,j-Wert. D.h. eine VE führt die FOR-k-Schleifefür ein gegebenes i und +j* durch.

ä Jede VE benötigt dazu die i-te Zeile von A und die j-te Spalte vonB.

ä Keine weitere Datenabhängigkeit!

ä Es werden N=p•r VEs benötigt.

2. Eine VE berechnet eine Ergebnisspalte, d.h. führt die FOR-k und FOR-j-Schleifen durch.

ä Jede VE benötigt A und eine Spalte von B.

ä Es werden N=p VEs benötigt.

3. Eine VE führt eine Multiplikation und Addition innerhalb der FOR-K-Schleife durch.

PD Stefan Bosse 112


ä Jede VE benötigt einen A und B-Wert.

ä Es werden N=p•r•q VEs benötigt.

ä Jeweils eine VE für einen gebenen Ci,j-Wert führt die Zusammen-führung der Zwischenwerte der FOR-k-VEs durch.

ä Zusammenführung der Ergebnisdaten in den Fällen 1&2 trivial. Im Fall3 besteht Zusammenführung im wesentlichen in der Summation der Zwis-chenergebnisse.

Abb. 44. Mögliche Partitionierungen der Matrixmultiplaktion

PD Stefan Bosse 113


Abb. 45. Kosten und Laufzeitanalyse der verschiedenen Parititioneirung

10.7. Kommunikation

ä Berechnung der Kommunikation mit Einheitswerten eines Nachrichtenaus-tauschs: Message Passing (MP) → Aufwand eine Zelle einer Matrix zuversenden ist MP=1.

PD Stefan Bosse 114


Abb. 46. Kommunikation Fall 1

Abb. 47. Kommunikation Fall 2

PD Stefan Bosse 115


Abb. 48. Kommunikation Fall 3ä Bisher konnten Matrizen ganzzahlig auf VEs verteilt werden. In der Re-

alität ist aber p=q=r,n!

ä Bisher wurde angenommen, dass alle VEs mit jeder anderen VE Datenmit einer Di- stanz/Ausdehnung D=1 austauschen kann. Nur möglichmit vollständig verbundenen Netzwerktopologien unter Verwendung vonKreuzschaltern.

ä Gängige parallele und ökonomische Rechnertopologie: Maschennetz

o Besteht aus n × n VEs.

o Jede VE kann mit seinem direkten Nachbarn kommunizieren.

o Eine Nachricht hat eine maximale Reichweite von (2n-1) VEs, Θ(n).

ä Bisherige statische Partitionierung resultiert in zu hohen Kommunikation-saufwand in der Verteilung der Matrizen A und B sowie in der Zusam-menführung der Matrix C .

o Dynamisch veränderliche Partitionierung passt sich effizienter anNetzwerktopologie an.

PD Stefan Bosse 116


o Bei Matrixoperationen mit zwei Matrizen (n=p=q=r) ist dafür ein2n × 2n Netz optimal geeignet.

Abb. 49. Zweidimensionales Maschennetzwerk

Dynamische Verteilung der Matrizen

ä Das 2n x 2n Netz wird in vier Quadranten der Größe n × n unterteilt.

o Die Matrizen A und B befinden sich initial im linken unteren undrechten oberen Quadranten

o Die Ergebnismatrix C wird schließlich im rechten unteren Quadran-ten zusammen- geführt.

ä Alle VEs die ein A1,j-Element besitzen werden dieses nach rechts ver-schieben.

ä Alle VEs die ein Bi,1-Element besitzen werden dieses nach unten ver-schieben.

o Dieser Vorgang wird für weitere Zeilen (A) und Spalten (B) fortge-setzt.

o Die einzelnen Elemente von A und B passieren die VEs im C-Quadranten. Die einzelnen C-Werte können mittels Summationberechnet werden.

PD Stefan Bosse 117


Abb. 50. Dynamische und überlagerte Verteilung der Matrizen A, B, und C

ä Die Laufzeit der Matrixmuliplikation auf dem Netz beträgt Θ(n), da nVerschiebungen durchgeführt werden.

ä Die Kosten betragen Θ(n3), vergleichbar mit sequenzieller Ausführung.D.h. diese Partitionierung und Architektur ist kostenoptimal.

ä Das 2nx2n Netz wird nur in drei Quadranten genutzt. Benötigt werdendaher nur 3n2 VEs.

ä Aus Sicht der Rechnerarchitektur ungünstig zu implementieren und nichtgenerisch, d.h. abhängig vom verwendeten Algorithmus.

ä Reduktion dieses Verfahrens auf n × n Netz möglich

o Dazu werden die Matrizen A, B und C überlagert, d.h. VE1,1 ⇒{A1,1,B1,1,C1,1}.

ä Die Zeilenelemente von A werden dann nach vorherigen Ablaufschemagegen den Uhrzeigersinn rotiert (nur horizontal), und die Spaltenelementevon B im Uhrzeigersinn vertikal).

ä Man erhält gleiche asymptotische Grenzwerte für die Laufzeit Θ(n) undKosten Θ(n3)!

Abb. 51. Überlagerte Verarbeitung der Matrizen A, B, und C auf einemMaschennetzwerk

PD Stefan Bosse 118


10.8. Maßzahlen für Parallele Systeme

BerechnungszeitDie Berechnungszeit Tcomp (computation time) eines Algorithmus als Zeit,die für Rechenoperationen verwendet wird.

KommunikationszeitDie Kommunikationszeit Tcomm (communication time) eines Algorithmus alsZeit, die für den Daten- bzw. Nachrichtenaustausch (Sende- und Empfang-soperationen) zwischen Subprogrammen und Verarbeitungseinheiten ver-wendet wird.

UntätigkeitszeitDie Untätigkeitszeit T idle (idle time) eines Systems als Zeit, die mit Warten(auf zu empfangende oder sendende Nachrichten) verbracht wird→ Prozess-blockierung trägt zur Untätigskeitszeit bei!

Es gilt:

Ttot = Tcomp + Tcomm + Tidle ≈ 1/N∑

i=1..n

Tcomp,i + Tcomm,i + Tidle,i

ÜbertragungszeitDie Übertragunszeit Tmsg (message time) ist die Zeit, die für das Übertrageneiner Nachricht mit der Länge L Datenwörter zwischen zwei Prozessen oderProzessoren benötigt wird.

ä Sie setzt sich aus einer Startzeit Ts (message startup time) und einerTransferzeit Tw für ein Datenwort zusammen.

ä Es gilt: Tmsg = Ts + L • Tw

ä Voraussetzung: Verbindungsnetz arbeitet konfliktfrei.

StartzeitDie Startzeit wird durch die Kommunikationshard- und software bestimmt,die zur Initiierung eines Datentransfers benötigt wird, z.B. Overhead desProtokollstacks bei einer Software-Implementierung.

Transferzeit

PD Stefan Bosse 119


Die Transferzeit wird durch die Bandbreite des Kommunikationsmedi-ums und zusätzlich bei Software-Implementierung durch den Protokollstack(Datenkopie) bestimmt.

Parallelisierungsgrad PDie maximalze Anzahl von binären Stellen (bits) pro Zeiteinheit (Taktzyk-lus) die von einer Datenverarbeitungsanlage verarbeitet werden kann.

ä Es gilt: P = W • B

Wortlänge WDie Wortlänge oder Wortbreite gibt die Anzahl der Bits eines Datenpfadesan.

Bitslice-Länge BDie Bitslice-Länge setzt sich zusammen aus der Anzahl von Verarbeitung-seinheiten VE, die parallel ausgeführt werden können, und der Anzahl derPipeline-Stufen einer VE.

ä Es gilt: B = NVE • NStages

Abb. 52. Illustration Parallelisierungsgrad und Beispiel

Beschleunigung S und Kosten CDie Beschleunigung gibt die Steigerung der Verabeitungsgeschwindigkeitbzw. die Re-duzierung der Verarbeitungszeit T an beim Übergang AnzahlProzessoren N=1 → N>1. Die Kosten C skaliert die Verarbeitungszeit(Komplexitätsklasse) mit den Ressourcen.

S(N) =T (1)

T (N), C(N) = T (N)N

Effizienz E

PD Stefan Bosse 120


Die Effizienz gibt die relative Verbesserung in der Verarbeitungs-geschwindigkeit an, da die Leistungssteigerung S mit der Anzahl der Prozes-soren normiert wird.

E(N) =S(N)

N, mit 1

N⩽ E(N) ⩽ 1

Mehraufwand RBezieht sich auf die Anzahl X der auszuführenden (Einheits-)Operationendes Programms:

R(N) =X(N)

X(1)

Parallelindex IDer Parallelindex gibt die Anzahl der parallelen Operationen pro Zeit-/Takteinheit an.

I(N) =X(N)

T (N)

Auslastung UEntspricht dem normierten Parallelindex:

U(N) =I(N)

N

Beispiel zur Auslastung

Ein Einprozessorsystem benötigt für die Ausführung von 1000 Operationengenau 1000 (Takt-)Schritte. Ein Multiprozessorsystem mit 4 Prozessorenbenötigt dafür 1200 Operationen, die aber insgesamt in 400 Schritten ausge-führt werden können:

..

X(1)=1000 und T(1)=1000, X(4)=1200 und T(4)=400S(4)=2.5 und E(4)=0.625,I(4)=3 und U(4)=0.75

Im Mittel sind 3 Prozessoren gleichzeitig aktiv, da jeder Prozessor nur zu 75%ausgelastet ist!

PD Stefan Bosse 121


10.9. Amdahl’s Gesetz

..

Eine kleine Zahl von sequenziellen Operationen kann den Perfor-manzgewinn durch Parallelisierung signifikant reduzieren.

ä Sequenzieller Anteil der Berechnungszeit T eines Algorithmus in [%]: η

ä Paralleler Anteil dann: (1-η)

ä Kommunikation (Synchronisation) zwischen nebenläufig ausgeführtenTasks oder Verarbeitungseinheiten verursacht immer η>0!

o Beispiel: Schutz einer geteilten Ressource mit einer Mutex.

o Beispiel: Datenverteilung über eine Queue

ä Zugriff auf geteilte Ressourcen verursacht immer η>0!

o Beispiel: Geteilte Ressource Hauptspeicher in einer PRAM

ä Der Kommunikationsanteil ist schwer im Voraus abzuschätzen, und dergenaue Wert hängt auch von temporalen Konkurrenzverhalten ab (wiehäufig gibt es verlorene Wettbewerbe)!

ä Es gilt dann für die gesamte Berechnungszeit eines parallelen Systems:

T (N, η) = ηT (1) +(1− η)T (1)

N

ä Daraus lässt sich eine Obergrenze der Beschleunigung S mit zusätzlicherAbhängigkeit von η ableiten:

S(N, η) =T (1)

T (N, η)⩽ N

(ηN − 1) + 1

Beispiel

Ein Algorithmus mit einem sequenziellen Anteil von η=10% und einem paralle-len Teil von 90% wird A.) mit N=10 Prozessoren, und B.) mit N=20 Prozessorenausgeführt. Die Obergrenze der Beschleunigung S ist dann:

..

A.) S(10)=5.26B.) S(20)=6.0

PD Stefan Bosse 122


ä Verdopplung der Prozessoren erhöht nicht mehr signifikant die Beschleu-nigung!

Abb. 53. Beschleunigung S in Abhängigkeit von η und Anzahl der ProzessorenN

11. Plattformen und Netzwerke

11.1. Eigenschaften von Parallelarchitekturen

RekonfigurierbarkeitUnterschiedliche Ebenen der Algorithmik erfordern unterschiedliche Rech-nerarchitekturen. Sowohl SI and MI-Ausführung muss dynamisch (re-)konfigurierbar möglich sein → Dynamische Anpassung der Architektur anAlgorithmen.

Flexible KommunikationFein granulierte und Hochgeschwindigkeitskommunikation ist für effizienteAusführung der Algorithmen und Tasks erforderlich. Kommunikation zwis-chen Tasks und den unterschiedlichen Verarbeitungsebenen.

Ressourcen Allokation und Partitionierbarkeit

PD Stefan Bosse 123


Gesamtsystem muss aus unabhängigen Teilsystemen bestehen, um effizienteImplementierung der (unterschiedlichen) Tasks zu ermöglichen. Ressourcen(Prozessoren, Speicher) müssen dynamisch und fein granuliert an dieTasks/Prozesse gebunden werden können.

Lastbalanzierung und Task SchedulingBesonders für high-level (=komplexe) Algorithmen mit starker Datenab-hängigkeit sind Lastverteilung und zeitliches Taskscheduling von großer Be-deutung, aber nicht trivial.

ä In low-level Algorithmen mit geringer Datenabhängigkeit erreicht manLastbalanzierung meistens durch Datenpartitionierung.

Unabhängigkeit von Topologie- und DatengrößeDurch die hohe Komplexität von Algorithmen (z.B. Vision) muss die Ar-chitektur unabhängig von detaillierten Annahmen bezüglich Datenstruktur(z.B. Matrixgrößen oder Datenbreite) und bestimmter Algorithmik sein!

ä Betrifft auch dynamisch konfigurierbare und skalierbare Kommunikation-sstrukturen.

FehlertoleranzBei der Bearbeitung von komplexen Aufgaben mit komplexen Systemenspielt Fehlertoleranz eine wichtige Rolle. Ein Ausfall einer einzelnen Kom-ponente darf nicht zum Ausfall des gesamten Systems führen. StatischeRedundanz ist aber teuer (Ressourcen- bedarf)!

Ein- und Ausgabe (IO)Neben geringer Bearbeitungs- und Rechenzeit ist der Datentransfer derEingangs- und Ausgangsdaten (Ergebnisse) gleichbedeutend. Performanzund Architektur von IO ist ein Kernbestandteil paralleler Systeme!

11.2. Klassifikation Rechnerarchitektur

- Eine Datenverarbeitungsanlage enthält:

VEVerarbeitungseinheit für Daten → Generischer Prozessor, Applikationspez-ifischer Pro- zessor, Applikationspezifische Digitallogik, Teileinheit

SMSpeichermodul → RAM, Registerbank, Cache

KE

PD Stefan Bosse 124


Kontrolleinheit für die Ablaufsteuerung, kann in VE enthalten sein.

ä Dabei sind diese drei Einheiten über Instruktionsströme und Daten-ströme gekoppelt:

Klassifikation nach Flynn

ä Durch Beschreibung von Daten- und Kontrollfluss:

SISDSingle-Instruction � Single-Data Stream

SIMDSingle-Instruction � Multiple-Data Stream

MISDMultiple-Instruction � Single-Data Stream

MIMDMultiple-Instruction � Multiple-Data Stream

11.3. SISD-Architektur Eigenschaften

ä Von-Neuman-Architektur gehört zur SISD- Klasse

ä SISD-Architekturen verarbeiten einen sequenziellen Daten- und Kontroll-strom.

ä Nur eine VE und KE wird benötigt.

ä Ein zentraler Speicher für Daten und Instruktionen

ä Keine algorithmische Parallelisierung implementierbar - nur implizit mit-tels Pipeline- Verfahren.

PD Stefan Bosse 125


ä Programmiermodell: explizite Ablaufsteuerung; simulierte konkurrierendeProgrammierung mit Software-Threads.

11.4. SISD-Architektur - Von-Neumann Architektur

Phasen der Befehlsausführung

I. Befehlsholphase: �(BZ) → BR

II. Dekodierungsphase: BR → {S1,S2,..}

III. Operandenholphase: � → R

IV. Befehlsausführung: �

V. Rückschreibephase: R → �

VI. Adreßrechnung: Ψ(BZ,SR,BR) → BZ

Architekturkomponenten

BZ, BR, SBefehlszähler, Befehlsregister, Steuersignale

SR,R,�Statusregister, Register, Speicher

A,DAdress- und Datenbus

PD Stefan Bosse 126


Abb. 54. Von-Neumann Architekturbild

11.5. SISD-Architektur - Harvard-Architektur

ä Getrennte Daten- und Instruktionsspeicher

ä Mehrere Datenbusse und Datenspeicher ä Spezialmaschine optimiert fürdatenintensive Algorithmen

ä Parallelisierung auf Instruktionsebene: Teilphasen der Befehlsausführungkönnen nebenläufig ausgeführt werden, z.B. Befehls- und Operandenhol-phase.

PD Stefan Bosse 127


11.6. SIMD-Architektur

ä Parallelität auf Datenebene

ä Ablaufsteuerung mit einer gemeinsamen Kontrolleinheit KE

ä Zentrales Speichermodell, aber jede Verarbeitungseinheit VE kann eigenenSpeicher besitzen

ä Jede VE bearbeitet gleiche Instruktion Datenoperation wird auf N VEsverteilt

ä Gleiche Operation kann auf verschiedenen Operanden oder einem Operan-den der Datenbreite W=N•W’ ausgeführt werden

ä Keine Programmsynchronisation erforderlich

Vektor- & Array-Struktur

ä Sind Subarchitekturen von SIMD

ä Die Programmierung der SIMD-Architektur hängt von der verwendetenSubarchitektur ab.

Vektorarchitektur

PD Stefan Bosse 128


Die Verarbeitungseinheiten VE sind linear als Vektorstruktur angeordnet.Jede VE verfügt über eigenen Speicher. Die einzelnen VEs sind mit ihremjeweiligen linken und rechten Nachbarn verknüpft, und können über dieseVerbindungen Daten austauschen.

ArrayarchitekturDie Verarbeitungseinheiten VE sind als zweidimensionale Matrixstrukturverknüpft. Jede VE besitzt Kommunikationsverknüpfungen mit bis zu max-imal vier Nachbareinheiten, so dass Zeilen und Spaltenverbindungen beste-hen.

ä Beide SIMD-Architekturen sind Spezialmaschinen.

ä Sie sind gut geeignet für Algorithmen auf regulären Datenstrukturen, beidenen die gleiche Operation auf eine Vielzahl von Operanden angewendetwerden soll.

o Numerische Matrixoperationen wie Matrix- und Vektormultiplika-tion

o Digitale Bildverabeitung mit zweidimensionalen Bildmatrizen

Abb. 55. Vektorrechner

PD Stefan Bosse 129


Abb. 56. Matrixrechner

11.7. MISD-Architektur

ä Diese Architektur verarbeitet mehrere Instruktionen parallel. Jede VEhat eigenen IS.

ä Alle Instruktionen operieren auf dem gleichen Datensatz oder über einenDatenstrom.

ä Pipeline-Computer (Instruktions-Pipeline in der CPU) gehören zur MISD-Klasse

ä Spezialmaschine;

o Anwendung in der digitalen Bildverarbeitung und der Robotik An-wendung.

o Z.B. Objektklassifikator: Das gleiche Video-Bild (oder Ausschnitt)wird auf verschiedene Algorithmen angewendet (Objektklassifika-tion).

o Z.B. Space Shuttle flight control computer!

PD Stefan Bosse 130


Abb. 57. MISD-Architekturaufbau; Der Hauptspeicher kann segmentiert sein(wie bei Harvard)

11.8. MIMD-Architektur

ä Jede VE arbeitet mit eigenen Instruktionsstrom.

ä Jede VE arbeitet mit eigenen Datenstrom.

ä Synchronisation zwischen den einzelnen VE ist erforderlich.

ä Synchronisationsobjekte sind von allen VEs geteilte Ressourcen.

PD Stefan Bosse 131


11.9. Speichermodelle

Exklusives Lesen (ER - ExclusiveRead)Pro Zyklus kann höchstens ein Prozessor dieselbe Speicherzelle lesen.

Exklusives Schreiben (EW - ExclusiveWrite)Pro Zyklus kann höchstens ein Prozessor dieselbe Speicherzelle beschreiben.

Konkurrierendes Lesen (CR - Concurrent Read)Pro Zyklus können mehrere Prozessoren dieselbe Speicherzelle lesen.

Konkurrierendes Schreiben (CW - Concurrent Write)Pro Zyklus können mehrere Prozessoren dieselbe Speicherzelle beschreiben.Es besteht Konfliktgefahr und Dateninkonsistenz, die mit verschiedenenMethoden gelöst werden können:

ä Common (C-CW) Gleichzeitige Schreibzugriffe auf dieselbe Speicherzellesind nur erlaubt, wenn alle Schreibzugriffe den gleichen Datenwert liefern.

ä Arbitrary (A-CW) Einer der schreibenden Prozessoren gewinnt und belegtdie Speicherzelle - Schutzmechanismus einer geteilten Ressource (MutualExclusion). Die anderen Schreibzugriffe werden ignoriert!

ä Priority (P-CW) Auswahl des Prozessors nach Prioritätengewichtung (z.B.Prozessorindex).

PD Stefan Bosse 132


11.10. Rechnerarchitektur für Vision-Systeme (I)

Gitternetzwerk

ä Über Maschennetz verbundene Prozessoren/Rechner

ä Reguläre zweidimensionale Verbindungsstruktur mit großer Anzahl vonVerarbeitungseinheiten (VE) quadratisch angeordnet.

o Häufig ist jede VE mit seinen direkten Nachbarn (4) verknüpft.

o Jede VE besitzt i.A. lokalen Speicher.

ä Zweidimensionale Datenstrukturen wie Bilder lassen sich einfach auf dieseStruktur abbilden.

ä Maximale Parallelität nur erreichbar bei Algorithmen und Operationenauf Pixel-Ebene, d.h. bei kurzer ”Berechnungslänge”.

ä Kommunikation in Netzen ist über weite Distanzen teuer (Zeit).

ä Algorithmen wie Gruppierung oder Mustererkennung erfordern langreich-weitige Berechnungen. Führt zu hohem Kommunikationsüberhang zwis-chen den VEs.

11.11. Rechnerarchitektur für Vision-Systeme (II)

Pyramidennetzwerk

ä Irreguläre dreidimensionale Verbindungsstruktur mit großer Anzahl vonVerarbeitungseinheiten (VE), mehrstufig in (quadratischen) Ebenen an-geordnet.

o Jede VE ist mit seinen (4) direkten Nachbarn auf gleicher Ebene,

o jeweils mit (4) VEs der unteren Ebene und (1) der oberen Ebeneverknüpft (Σ=9).

o Eine Pyramide besitzt 1/2log(N+1) Ebenen bei N VEs.

PD Stefan Bosse 133


ä Gut geeignet für Divide-and-Conquer-Verfahren, wo ein Problem immerweiter mit einem Teilungsfaktor 2 zerlegt wird.

ä Nachteil: hoher Verbindungsaufwand (Netzwerk).

ä Auf verschiedenen Ebenen können Bilder mit unterschiedlicher Auflö-sung/Matrixgröße parallel verarbeitet werden.

11.12. Rechnerarchitektur für Vision-Systeme - Netra

..

NETRA ist ein rekursiv definierter und hierarchischer Multiprozessorspeziell für Vision-Systeme entwickelt.

DSP (Distributing-and-Scheduling-Processors)Taskverteilung und Kontrolleinheiten. Erlauben dynamische Partitionierung(zeitlich- wie

räumlich) von Programmcode auf Verarbeitungseinheiten.

PE (Processing Element)Verarbeitungseinheiten. Organisiert in Clustern der Größe 16-64 PEs. Bis150 Cluster können gebildet werden. Jedes PE ist ein generischer High-Perfomance-Prozessor mit schneller FPU (Floating-Point-Unit).

C (Cluster)Bindung von PEs zu einer Einheit. Jeder Cluster teilt sich einen gemein-samen Datenspeicher. Dieser Speicher ist in einer Pipeline angeordnet. AllePEs können über einen Kreuzmatrixschalter C mit den Datenspeichern Mverbunden werden; die DSPs sind auch über C mit den PEs verknüpfbar.

IC (Interconnect)Globale Verbindungsmatrix die die Cluster mit Speichermodulen Mverbindet. Aufgebaut als vollständiges unidirektionales Verbindungsnetz

PD Stefan Bosse 134


M×N mit einer Kreuzschaltermatrix. Vollständiges Verbindungsnetzbenötigt keine Synchronisation (Mutex/Arbiter).

MSpeichermodul welches parallelen und geteilten Zugriff unterstützt. Die Spe-ichermodule M sind in einer Pipeline angeordnet. Die Zugriffszeit einesModuls sei T Taktzyklen. Jede Pipeline besteht aus T Speichermodulen. DieSpeicher-Pipeline kann daher einen Speicherzugriff pro Taktzyklus durch-führen!

Systemarchitektur

Prozessorcluster

PD Stefan Bosse 135


11.13. Kommunikationsstrukturen

ä Ein Verbindungsnetz (Netzwerk) ist das Medium, über das die Kommu-nikation der Verarbeitungs- und Kontrolleinheiten VE&KE (Prozessoren)untereinander und der Zugriff auf gemeinsame Ressourcen wie Hauptspe-icher stattfindet.

PD Stefan Bosse 136


Abb. 58. Verbinungsnetz der Parallel Random Access Machine (PRAM)

Metriken

KomplexitätHardware-Aufwand für das Verbindungsnetz gemessen an der Anzahl undArt der Schaltelemente und Verbindungen.

VerbindungsgradDer Verbindungsgrad eines Kommunikationsknoten beschreibt die Anzahlder Verbindungen, die von dem Knoten zu anderen Knoten bestehen.

Geometrische AusdehnungMaximale Distanz für die Kommunikation (Anzahl der Knoten oder Schal-telemente) zwischen zwei Kommunikationsteilnehmern (VE/KE) [maximalePfadlänge].

RegelmäßigkeitRegelmäßige Strukturen in der Verbindungsmatrix lassen sich i.A. einfacherimplementieren und modellieren (simulieren).

ErweiterbarkeitDynamische oder statische Anpassung an Veränderung der Parallelarchitek-tur.

Latenz, Durchsatz/ÜbertragungsbandbreiteMaximale, meist theoretisch errechnete Übertragungsleistung desVerbindungsnetzes oder einzelner Verbindungen in [MBits/s]

Skalierbarkeit

PD Stefan Bosse 137


Fähigkeit eines Verbindungsnetzes, bei steigender Erhöhung der Knotenzahldie wesentlichen Eigenschaften beizubehalten, wie z.B. den Datendurchsatzoder die Kommunikationslatenz.

BlockierungEin Verbindungsnetz heißt blockierungsfrei, falls jede gewünschteVerbindung zwischen zwei Kommunikationsteilnehmern (inklusive Speicher)unabhängig von bestehenden Verbindungen hergestellt werden kann.

Ausfalltoleranz oder RedundanzMöglichkeit, Verbindungen zwischen einzelnen Knoten selbst dann noch zuschalten, wenn einzelne Elemente des Netzes (Schaltelemente, Leitungen)ausfallen.

ä Ein fehlertolerantes Netz muss also zwischen jedem Paar von Knoten min-destens einen zweiten, redundanten Weg bereitstellen.

Komplexität der WegfindungArt und Weise, wie zwischen einem Kommunikationsstart- und endpunkteine Nachricht vom Sender zum Zielknoten bestimmt wird: Routing. DieWegfindung sollte einfach sein, und mittels eines schnellen Hardware- Algo-rithmus in jedem Verbindungselement implementierbar sein.

Kommunikationsklassen

Durchschalte-oder LeitungsvermittlungDirekte Verbindung zwischen Sender und Empfänger wird für die Zeit derInformationübertragung hergestellt.

ä Durchschaltnetze erreichen i.A. höhrer Durchsatzraten als Netze mitPaketvermittlung, aber Dauerverbindung reduziert u.U. Anzahl dermöglichen Verbindungen.

PaketvermittlungDaten werden in Nachrichten (Paketen) gekapselt, i.A. mit fester Länge,und vom Sender an der Empfänger übertragen. Eine Datenkodierung und-dekodierung ist notwendig. Weiterhin ist i.A. eine Datenfragmentierungund -defragmentierung erforderlich. Die Nachrichten werden vom Senderzum Empfänger entsprechend einem Wegfindealgorithmus zwischen einzel-nen Knoten geroutet.

ä Erhöhter Verwaltungsaufwand im Vergleich zu Durchschaltenetzen.

PD Stefan Bosse 138


Abb. 59. Kommunikationsklassen: Schalt- zu Paketvermittlung

Vorteile der Schaltnetze

ä Keine Protokollimplementierung für den Nachrichtenaustausch erforder-lich.

ä Die maximale Übertragungsbandbreite (Durchsatz) eines Kommunika-tionskanals kann erreicht werden.

Nachteile der Schaltnetze

ä Jeder Knoten muss mit N :1-Multiplexern ausgestattet werden.

ä Eine universelle N � N - Schaltmatrix (jeder KommunikationsteilnehmerN i kann mit jedem anderen Teilnehmer N j mit i ̸= j verbunden werden)erfordert großen Hardware-

ä Aufwand, und ist bei großen N nicht mehr wirtschaftlich. Synchronisationmuss explizit erfolgen.

Vorteile der Paketvermittlung und Nachrichtenaustausch

ä Über einen Kommunikationskanal können Verbindungen zwischen ver-schiedenen Kommunikationsteilnehmern aufgebaut werden.

PD Stefan Bosse 139


ä Auch komplexe Netze können mit geringen Hardware-Aufwand (Routing)realisiert werden.

ä Implizite Synchronisation bereits vorhanden.

Nachteile der Paketvermittlung und Nachrichtenaustausch

ä Implementierung eines Protokollstacks mit Datenfrag- und defragmen-tierung und Routing.

ä Geringerer Netto-Datendurchsatz durch Header- und Trailerdaten imNachrichtenpaket.

ä Höhere Übertragungslatenz durch Paketadministration und Routing.

Beispiel: Eine Implementierung eines IP-Protokollstacks mit Digitallogikbenötigt ca. 1M Gates (ca. 4 Millionen Transistoren)!

11.14. Netzwerkarchitekturen und Topologien

..

Ein Netzwerk besteht aus Knoten N={n1,n2,…} und Verbindungen (Kan-ten) C={c1,c2,..}, die die Knoten untereinander verbinden. Das Netzw-erk kann als ein Graph G(N,C) beschrieben werden, der i. A. zyklischund gerichtet ist.

Parameter und Metriken von Netzwerken

Knotenzahl NGesamtzahl der Knoten, die ein Netzwerk oder ein Subnetzwerk bilden

Knotengrad (Konnektivität) KJeder Knoten hat mindestens eine, maximal K Verbindungen zu Nachbar-knoten

SkalierbarkeitLässt sich das Netzwerk für belibiege Anzahl N von Knoten erweitern?

RoutingStrategie für die Weiterleitung und Zustellung von Daten von einem Sender-knoten ns zu einem oder mehreren Empfängerknoten {ne1,ne2,…}

PD Stefan Bosse 140



ä Unicast: nur ein Empfänger

ä Multicast: eine Gruppe von ausgezeichneten Empfängern

ä Broadcast: alle Knoten (in einem Bereich) sind Empfänger

Ausdehnung DMaximaler Abstand (Distanz) zwischen zwei Knoten

Kosten OAnzahl der Kanten NC

Effizienz �Anzahl der Kanten NC im Verhältnis zur Anzahl der Knoten N

Latenz �Verzögerung � bei der Zustellung von Daten durch Vermittlung (normiertund vereinfacht in Anzahl von Zwischenknoten)

Durchsatz BDatendurchsatz (Bandbreite)


ä In nachrichtenbasierten Vermittlungsnetzwerken ist ein Knoten eines Net-zwerkes:

1. Quelle von Nachrichten, die Daten kapseln,

2. Empfänger von Nachrichten, und

3. Vermittler (Router) von Nachrichten (Zwischenknoten)

ä In einem geschalteten Netzwerk mit direkter Datenvermittlung ist einKnoten eines Netzwerkes

1. Quelle von Daten, und

2. Empfänger von Daten

11.17. Dynamische Verbindungsnetzwerke

ä Direkte Schaltung von Verbindungen ermöglicht die Übertragung voneinem Sender- zu einem Empfängerknoten.

PD Stefan Bosse 141


Crossbar Switch

Abb. 60. Vollständiger Kreuzschalter (Crossbar Switch) mit Schaltelementen[PA, Vornberger,1998]; Hier Verbindung Prozessor P mit Speichermodul MParameter

ä Knotenzahl: N

ä Knotengrad: 1

ä Skalierbar: Ja

ä Routing: Nicht erforderlich - konfliktfrei

ä Ausdehnung: 1

ä Kosten: N2

Vorteile

ä Jeder Knoten kann mit jedem anderen Knoten jederzeit verbunden(geschaltet) werden → Dynamische Konnektivität des Netzwerkes

ä Ausdehnung optimal klein (und Latenz minimal)

ä Keine Nachrichtenkapselung und kein Kommunikationsprotokoll erforder-lich

ä Skalierung bezüglich Leistung ist gut

PD Stefan Bosse 142


Nachteile

ä Hohe Kosten und hoher Hardware-Aufwand, der quadratisch mit der An-zahl der Knoten wächst

ä Skalierung bezüglich Kosten ist schlecht

ä Fehlende Synchronisation zwischen Sender und Empfänger

Mehrstufen (Multistage) Verbindungsnetzwerke

ä Mehrstufiger Aufbau des Netzwerkes

ä Kompromiss bezüglich Skalierung zwischen Kreuzschaltern und Bussyste-men

Parameter

ä Knotenzahl: N

ä Knotengrad: 1

ä Skalierbar: Ja

ä Routing: Nicht erforderlich - aber nicht konfliktfrei!

ä Ausdehnung: 1 (oder n - Stufenzahl)

ä Kosten: Nlog2N

Abb. 61. Aufbau eines Mehrstufen Netzwerks (n-stufig) [PA, Vornberger, 1998]

PD Stefan Bosse 143


Mehrstufiges Permutations-Netzwerk

ä Jede Stufe besteht aus Binärschaltern, die entweder durchgeschaltet odergekreuzt geschaltet sind.

ä Die Ausgänge einer Stufe k werden über ein Permutationsverfahren mitden Eingängen der nächsten Stufe k+1 verbunden.

Abb. 62. Nicht konfliktfreies Mehrstufennetzwerk [PA, Vornberger, 1998]

Bus

ä Alle Knoten nutzen eine gemeinsame Kommunikationsverbindung

ä Bus-basierte Netzwerke skalieren bezüglich Kosten gut, aber nichtbezüglich der Leistung (Flaschenhals!)

Abb. 63. Topologie des Bus-basierten NetzwerkesParameter

ä Knotenzahl: N

PD Stefan Bosse 144


ä Knotengrad: 1

ä Skalierbar: Jein

ä Routing: Nicht erforderlich - aber nicht konfliktfrei

ä Ausdehnung: 1

ä Kosten: 1

Bus Arbiter und Architektur

Protokoll

LISTENAktueller Eigentümer des Busses (ACK=1) sendet eine Listen Nachricht analle Teilnehmer. Nachfolgend wird nur der adressierte Teilnehmer Datenempfangen.

TALKDer aktuelle Eigentümer des Busses gibt seine Adresse bekannt.

UNLISTEN

PD Stefan Bosse 145


Alle Teilnehmer warten auf KontrollkommandosUNTALK

Kein Teilnehmer ist Datensender.

Abb. 64. Skalierung von Kosten und Leistung der verschiedenen dyn.Verbindungsnetze in Abhängigkeit der Knotenzahl N [PA, Vornberger, 1998]

11.18. Statische Verbindungsnetzwerke

ä Nachrichtenbasierte Kommunikation, d.h. die zu übertragenen Daten wer-den in Nachrichten gekapselt

ä In den meisten Topologien ist die Vermittlung von Nachrichten durch an-dere Knoten entlang eines Pfades (S→ni1→ni2→…→E) erforderlich

Abb. 65. Zwei Grenzfälle: Vollständig verbundenes Maschennetzwerk undSternnetzwerk

PD Stefan Bosse 146


Sternnetzwerk

ä Master-Slave Netzwerk Hierarchie

ä Ein ausgezeichneter Knoten ist Master, der mit jedem anderen Knoten(Slave) verbunden ist

ä Kommunikation findet immer über den Master (=Router) statt

Parameter

ä Knotenzahl: N

ä Knotengrad: 1 (Slave), N-1 (Master)

ä Skalierbar: Ja

ä Routing: erforderlich - wähle Ziel in zwei Schritten über Master

ä Ausdehnung: 2

ä Geschlossen: nein

ä Kosten: N-1

Binärer Baum

Parameter

ä Knotenzahl: N

ä Knotengrad: 3

ä Skalierbar: Ja

ä Routing: erforderlich - laufe vom Start aufwärts zum gemeinsamen Vor-fahren und dann abwärts zum Ziel

ä Ausdehnung: 2*k (k - Höhe des Baums)

ä Geschlossen: nein

ä Kosten: Nlog2N

PD Stefan Bosse 147


Abb. 66. Topologie Binärbaum (a) und N-Baum (b) Netzwerk [PA, Vornberger,1998]

Lineares Array - Kette - und Ring

Parameter

ä Knotenzahl: N

ä Knotengrad: 2

ä Skalierbar: Ja

ä Routing: erforderlich - wähle Richtung und laufe in diese Richtung

ä Ausdehnung: N-1 (Kette), N/2 (Ring)

ä Geschlossen: nein (Kette), ja (Ring)

ä Kosten: N-1 (Kette), N (Ring)

Abb. 67. Kette und Ring (technologisch schwierig) [PA, Vornberger, 1998]

PD Stefan Bosse 148


2D Gitter

ä ökonomisch und techn. geeignet für material-integrierte verdrahtete Sen-sornetzwerke (elektrische und optische Kommunikationstechnologien)

Parameter

ä Knotenzahl: N

ä Knotengrad: 4

ä Skalierbar: Ja

ä Routing: erforderlich (Δ-Distanz Routing)

ä Ausdehnung: 2*(√N-1)(ohne wraparound), 1+(√N-1) (mit wraparound)

ä Geschlossen: nein (ohne wraparound), ja (mit wraparound)

ä Kosten: 2(N-√N) (ohne wraparound)

Abb. 68. 2D Gitter und Torus (technologisch schwierig) [PA, Vornberger, 1998]

Δ-Distanz Routing

ä Routing: Wandere horizontal (erste Dimension) bis zur Zielspalte, dannwandere vertikal bis zur Zielzeile (zweite Dimension)

ä Einfaches Δ-Distanz Routing in m-dimensionalen Gitternetzwerken:

o M: Nachricht

o moveto: vermittelt Nachricht an Nachbarknoten in Richtung DIR

PD Stefan Bosse 149


o Δ0: relative Distanz zwischen Sender und Empfänger in Knotenein-heiten

o Δ: bei jeder Vermittlung geänderter Vektor, anfänglich Δ0=Δ, amZiel: Δ=(0,0,..)

o Δi: i-te Komponente von Δ

o Nullvektor 0=(0,0,..) → Ziel erreicht!

..

TYPE DIM = {1,2,...,m}TYPE DIR = {NORTH,SOUTH,EAST,WEST,UP,DOWN,...}// Numerical mapping of directionsDEF dir = function(i) →match i with-2→NORTH | -1→WEST | 1→EAST | 2→SOUTH ...

// Routing and message passingDEF route_xy = function (Δ,Δ0,M) →if Δ � 0 thenfor first i � DIM with Δi � 0 doif Δi > 0 thenmoveto(dir(i));route_xy(Δ with Δi:=Δi-1,Δ0,M)

else if Δi < 0 thenmoveto(dir(-i));route_xy(Δ with Δi:=Δi+1,Δ0,M)

else deliver(M)

3D Gitter

ä ökonomisch und techn. geeignet für material-integrierte verdrahtete Sen-sornetzwerke

Parameter

ä Knotenzahl: N

ä Knotengrad: 6

ä Skalierbar: Ja

ä Routing: erforderlich (Δ-Distanz Routing)

ä Ausdehnung: 3*(√3N-1)

ä Kosten: 3(N-√3N)

PD Stefan Bosse 150


Zusammenfassung Gitternetzwerke

11.19. Kommunikationsstrukturen - Routing

Routing: Flusssteuerung bei nachrichtengekoppelten Netzen

PD Stefan Bosse 151


Store-and-forward

ä Nachricht wird von jedem Zwischenknoten in Empfang genommen

ä Nachricht wird vollständig zwischengespeichert

ä Sendung der Nachricht auf Pfad zum nächsten Knoten nach vollständigenEmpfang

Virtual-cut-through

ä Nachricht wird als Kette von Übertragungseinheiten transportiert

ä Kopfteil der Nachricht enthält die Empfängeradresse und bestimmt denWeg

ä Bei Ankunft der ersten Übertragungseinheit wird diese sofort an den näch-sten Knoten weitergeleitet (Pipeline-Verfahren)

ä Nachrichtenspeicherung nur im Konfliktfall (wenn Pfad belegt ist)

Wormhole-routing

ä Ist der Pfad zum nächsten Knoten nicht belegt, Verhalten wie Cut-through

ä Ist Kommunikationskanal belegt, müssen alle vorherigen Knoten ebenfallsDatentransfer einstellen, d.h. die Vorgänger-Knoten werden blockiert.

ä D.h. keine Nachrichtenspeicherung in den Verbindungsknoten

ä Es werden nur Puffer für eine Übertragungseinheit benötigt (Kopf).

PD Stefan Bosse 152


Abb. 69. Vergleich S&T und VC Routing: Das Cut-through Routing benötigtdeutlich weniger Kommunikationsschritte als das Store-and-Foreward Routing-Verfahren.

11.20. Kommunikation

Paketstruktur

Abb. 70. Aufbau eines Nachrichtenpakets: Header (Zustell- und Absendeinfo-mationen, Overhead), Nutzdaten (Datenlast), und optional Trailer (Prüfsumme,EOP Marker, .., Overhead)

Latenz

Die Zeit zum Übertragen einer Nachricht zwischen zwei Netzwerkknoten mit NByte setzt sich zusammen aus:

T (N)S→D = Toverhead + Trouting + Ttransfer + Tconflict

PD Stefan Bosse 153


Toverhead → Θ(1)Zeit die benötigt wird, ein Paket vom Speicher in den Kommunikationskanalund aus dem Kanal in den Speicher zu übertragen→ abhängig von Hardware

Ttransfer → Θ(N)Zeit die zur eigentlichen Datenübertragung benötigt wird.

Tconflict

Mittlere Zeit in der ein Kommunikationskanal blockiert ist. Abhängig vonAuslastung des Kanals.

ä Die Transferzeit von N Byte Nutzdaten erhöht sich durch die Paketad-ministration (Header & Trailer) NPA und ergibt sich aus der BandbreiteB [Byte/s] des Kommunikationskanals:

Ttransfer =N +NPA

B

ä Die Routingzeit (Latenz) hängt vom verwendeten Routing-Verfahren ab:

Trouting−SF (N,H) = H

(Npaket

B+∆

)Trouting−CS(N,H) =

Npaket

B+H∆

ä Dabei ist H die Anzahl von Knoten, die ein Paket auf seiner Route durch-laufen muss.

ä Ein Hardwareoverhead beim Senden und Empfangen eines Knotens wirdmit Δ gekennzeichnet.

Es gilt:Trouting−CS(N,H) < Trouting−SF (N,H)

11.21. Kommunikation - Zusammenfassung

Hardware

ä Es gibt zwei wesentliche Architekturklassen die parallele und verteilteDatenverarbeitung sehr stark beeinflusst → Performanz → maximaler /effektiver Speedup:

o Rechnerarchitektur (Horizontale und vertikale Parallelisierung, Spe-icher)

PD Stefan Bosse 154


o Kommunikationsarchitektur (Art und Topologie), Ein- und Aus-gabegeräte, Konflikte und Blockierung

Software

ä Auf der algorithmischen Seite beeinflussen folgenden Klassen die Perfor-manz, Effizienz, die Rechenzeit, und den Speicherbedarf von parallelenund verteilten Systemen:

o Partitionierung des Algorithmus in Prozesse

o Datenabhängigkeiten, Datenverteilung und Datenaggregation

o Synchronisation → Kommunikation → Nachrichtenaustausch (ex-plizit)

o Kommunikations- und Routingprotokolle!

..

Kommunikation erhöht den sequenziellen Anteil eines parallelen Pro-gramms und reduziert den (max.) Performanzgewinn gegenüber reinsequenziellen Programmen gleicher Art

12. Register Transfer Logik (RTL)

12.1. RT Architektur

..

Die Register-Transfer Architektur ist die Rechnerarchitektur der anwen-dungsspezifischen Datenverarbeitung

Register

Register dienen der Speicherung von Zwischen- und Endergebnissen von Berech-nungen. Digitallogik: transitorische Logik.

PD Stefan Bosse 155


Berechnungen

Arithmetische, relationale, und boolesche Berechnungen sind wesentlicher Be-standteil der Datenverarbeitung.

Datenpfad

Berechnungen und Register werden im Datenpfad zusammengefasst. Dabei sinddie Berechnungseinheiten (Digitallogik: kombinatorische Logik) zwischen Reg-isterebenen eingebettet.

..

Register-Transfer Architektur bedeutet die Partitionierung der Datenver-arbeitung in einen Daten- und Kontrollfluss.

Datenfluss

Der Datenfluss beschreibt den Fluss von Daten durch Verarbeitungs- undSpeichereinheiten (Register). Die Verarbeitungseinheiten sind Knoten einesgerichteten Graphens, die Kanten beschreiben den Datenfluss und bilden dieDatenpfade. Die Verarbeitungseinheiten müssen aktiviert werden.

Kontrollfluss

Der Kontrollfluss beschreibt die temporale schrittweise Verarbeitung vonDaten im Datenpfad durch zustandsbasierte selektive Aktivierung von Verar-beitungseinheiten. Der Kontrollfluss kann durch Zustandsübergangsdiagrammebeschrieben werden.

Programmfluss

Der Programmfluss setzt sich kombiniert aus Daten- und Kontrollfluss zusam-men.

ä Programmanweisungen i1,i2,.. werden Zuständen S1,S2,.. zugeordnet.

ä Einfache Anweisungen (Berechnungen) werden jeweils einem Zustand,komplexe Anweisungen zerlegt und i.A. mehreren Unterzuständen zuge-ordnet.

PD Stefan Bosse 156


Kontrollpfad

Zustandsbasierte zeitliche Steuerung des Datenpfades

ä Zustandsautomat

ä Komponenten:

i. Zustandsregister Z

ii. Eingangs-/Schaltnetzwerk Σ

iii. Ausgangsnetzwerk Π

ä Verhalten des Zustandsautomaten wird durch Zustandsübergangsdi-agramm/graphen beschrieben.

ä Ein Zustand ist gekennzeichnet durch eine Aktion (Aktivierung vonDatenpfadelementen) und Zustandsübergängen

ä Zustandsübergänge können bedingt (boolesche Bed.) oder unbedingt(immer wahr) sein.

Datenpfad

Führt die eigentliche Verarbeitung von Daten durch. Komponenten:

i. Funktionseinheiten: arithmetische, relationale, boolesche

ii. Datenpfadselektoren: Multiplexer:Join, Demultiplexer: Split

iii. Register (Daten)

ä Der Datenpfad kann Parallelität aufweisen (mehrere parallele Teilpfade).

ä Register trennen kombinatorische Bereiche (die eigentlichen Berechnun-gen) voneinander (Partitionierung des Datenpfades).

PD Stefan Bosse 157


Verknüpfung von Kontroll- und Datenpfad

Abb. 71. Zustandsbasierte Aktivierung im Datenpfad

Abb. 72. Zustandsautomat (Kontrollpfad) und Kommunikation mit Datenpfad

PD Stefan Bosse 158


12.2. RTL Synthese von Digitallogikschaltungen

ä RTL-Modellierung entspricht einer Spezifikation als gerichteter Graph,deren Knoten Schaltungsblöcke und die Kanten Verbindungsleitungendarstellen.

ä Die RTL-Spezifikation wird dann in eine Hardwareverhaltens-Beschreibung (VHDL,Verilog) umgesetzt: 1. per Hand, 2. automatischals Synthese-Verfahren.

ä Obwohl alle (imperativen) Algorithmen mit dieser Methode modelliertund spezifiziert werden können, steigt die Komplexität überlinear (ex-ponentiell) mit der Algorithmus- und Systemkomplexität.

ä Diese stark ansteigende Entwurfskomplexität resultiert in einementsprechenden Anstieg an Entwicklungszeit und Ressourcen.

ä Zudem steigt die Fehleranfälligkeit gleichzeitig mit einer reduziertenMöglichkeit, diese Fehler überhaupt feststellen und testen zu können.

ä Die RTL-Ebene bietet inhärent maximale Parallelität - die aber vomEntwickler explizit formuliert werden muss. Parallelität bedeutet aberauch Synchronisation - diese muss ebenfalls explizit modelliert werdenund ist nicht Bestandteil des Entwurfsmodells.

ä Die RTL-Ebene setzt weiterhin explizite Modellierung des zeitlichenAblaufs und aller Ressourcen voraus→ Diskretisierung des Kontrollpfades→ Scheduling und Allokation.

RTL-Implementierung aus algorithmischer Beschreibung

SchedulingZuordnung von Operationen zu Zeitschritten. Optimierung: Minimierungder Zeitschritte → Kontrollpfad / Zustandsautomat

Ressourcen-AllokationBestimmung von Typ und Anzahl der erforderlichen Hardware-Ressourcenwie Funktionselemente, Speicher, Busse.Optimierung: Minimierung der Funktionselemente, z.B. durch ALU-Blöcke,die über Multiplexern mit mehreren arithmetischen Operationen verwendetwerden können (Ressourcenteilung) → Datenpfad.

ä Erzeugung einer RTL bedeutet das Abbilden von Daten- und Kontrollflussin zwei Dimensionen: Zeit � FSM und Fläche � Hardware � Logik.

Ressourcen-Zuweisung

PD Stefan Bosse 159


I. Zuordnung von Funktionselementen zu einzelnen Instanzen und Oper-ationen → Datenpfad.

II. Abbildung auf eine Hardware-Verhaltensbeschreibung

ä Starke Wechselwirkung zwischen Scheduling und Ressourcen-Allokation

ä RTL-Scheduling- und Allokation kann per Hand, aber auch regel- undmodell-basiert mit automatischer High-Level-Synthese erzeugt werden.

Abb. 73. Zeitliche Partitionierung (Scheduling) und Ressourcenallokation mitZeit-Operationen Diagrammen

13. High-level Synthese von Digitallogik

13.1. Abbildung von Algorithmen auf RTL

Einfachstes Scheduling- und Allokationsmodell: Grundregeln

Regel IEs gibt nur Register als Datenspeicher mit beliebiger Datenwortbreite.

Regel IIKeine Ressourcenteilung: jedes Register R was definiert wurde wird auch alsHardware-Block � implementiert.

Regel III

PD Stefan Bosse 160


Jede elementare Anweisung � wird auf einen Zustand � des KontrollpfadesΓ=(Φ,Ε) als gerichteter Graph bzw. der Zustandsmenge Φ={�1,�2,..} desRTL-FSM abgebildet.

Regel IVDer Datenpfad Δ wird in Abhängigkeit der Zustände Φ zerlegt.

Regel VKeine Ressourcenteilung: jeder funktionale Operator (arithmetisch, rela-tional und Boolesch) � wird mit eigenen Hardwareblöcken � implementiert.

Regel VIKomplexe Anweisungen Κ (z.B. Schleifen) müssen in eine Menge {�} vonelementaren Anweisungen mit Transformationsregeln zerlegt werden.

Regel VIIZu jedem Zustand � gehört ein Folgezustand �+, der bedingt oder unbedingtdefiniert sein kann.

13.2. RTL Beschreibungssprache: µRTL

ä Symbolische Beschreibungssprache mit Mikrooperationen die als Zwis-chenrepräsentation dient (Programmiersprache → �RTL → Γ, Δ).

Operation Beschreibung

r ← expr Register Datentransfer und Berechnungi1 ; i2 ; i3 ; ... In mehreren Zeitschritten sequenziell

ausgeführte Anweisungen (; leitet nächstenZeitschritt ein)

i1 , i2 , i3 ... In einem Zeitschritt parallel ausgeführteAnweisungen

branch s Unbedingte Verzweigung zu einer anderenAnweisung s

branch cond:s Bedingte Verzweigung zu einer anderenAnweisung s wenn cond=true

s: Zuordnung eines Labels (Zustand) zu einerAnweisung

PD Stefan Bosse 161


13.3. RTL Beschreibungssprache: µRTL

ä Diese RTL Beschreibung ist eine lineare Liste von Anweisungen - keinGraph!

Beispiel

ä �RTL Code abgeleitet aus Programmbeispiel

Programm

..

var index,mean,data;data=[..];mean=0;for(index=0;index<100;index++)mean += data[index];

mean /= 100;

�RTL

..

s1: Index ← 0, Mean ← 0;s2: branch (Index=100):s6;s3: Mean ← Mean + Data[Index];s4: Index ← Index + 1;s5: branch s2;s6: Mean ← Mean / 100;

13.4. µRTL Hardware Synthese von sequenziellenProzessen

ä Ein sequenzieller Prozess P besteht aus einer Reihe von Anweisungen{i1,i2,..} die der Reihe nach ausgeführt werden.

ä Der Prozess kann Register R={r1,r2,..} als Datenspeicher nutzen.

ä Es gibt elementare Anweisungen die Berechnungen durchführen und Datenspeichern (Register-Transfer im Datenpfad):

PD Stefan Bosse 162


..r = expression �(r1,r2,...,+,-,*,...)

ä Es gibt komplexe Anweisungen die den Programmfluss steuern, wie z.B.bedingte Verzweigungen (IF) und Schleifen (WHILE, FOR).

ä Komplexe Anweisungen müssen in elementare Anweisungen und einfacheKontrollflussverzweigungen (branch) zerlegt werden.

ä Elementaren Anweisungen wird ein Zustand si zugeordnet, komplexe spal-ten in multiple Zustände si,j auf.

..

Ein sequenzieller Prozess P kann auf eine RTL Komponente C abgebildetwerden, die aus einem Datenpfad Δ und einem Zustandsautomaten (Kon-trollpfad Γ) besteht.

Transformationsregeln für Anweisungen

ä Datenanweisungen

Programm µRTL

x = �1;y = �2;

si: x ← �1si+1: y ← �2

ä Kontrollanweisungen

Programm µRTL

if (cond1) i1else if (cond2) i2;else if ..else i0;..

si,1: branch cond1: si,n;si,2: branch cond2: si,m;..si,n: i1;si,n+1: branch sx;si,m: i2;si,m+1: branch sx;..si,0: i0;sx: ..

ä Schleifen

PD Stefan Bosse 163


Programm µRTL

for(init(i,�1);cond(i,�2);i++)

i1;..

si: i ← e1si,2: branch not cond: sxsi,3: i1;si,4: i ← i + 1;si,5: branch si,2;sx: ..

while(cond)i1;

..

si,1: branch not cond: sxsi,2: i1;si,3: branch si,1;sx: ..

Hardware-Modell

ä Der Datenpfad Δ wird aufgespalten in einen reinen funktionalen Berech-nungsteil (Abbildung mit kombinatorischer Logik, Ausgangslogik Π desFSM) und einen datenspeichernden Berechnungsteil (Abbildung mit tran-sitorischer Logik/Registern).

ä Der Kontrollpfad Γ wird unterteilt in ein Zustandsübergangsnetzwerk Σ,welches den Folgezustand des Zustandsautomaten berechnet, und ein Zu-standsregister Z.

ä Die Ausgangslogik Π ist bereits im funktionalen Berechnungsteils desDatenpfades enthalten.

ä Jeder Teil wird auf Hardwarebeschreibungsebene miteinem eigenen Hardware Prozess H implementiert: H ={state_transition,control_path,data_path,data_trans}.

PD Stefan Bosse 164


Abb. 74. Vier-Prozess RTL Hardware-Implementierung eines sequenziellenProzessesVHDL Partitionierung der Datenverarbeitung eines sequenziellen Prozesses Pmit vier Hardware Prozessen H.

..

architecture RTL of P istype states is (S_i1, S_i2_1,S_i2_2,..);

signal s,s_next: states;signal r,d,..: <data>;beginstate_transition: process()if clk’event then s � s_nextcontrol_path: process()

case s is

PD Stefan Bosse 165


..

when S_i1 � s_next � ...data_path: process()case s iswhen S_i1 � d � �when S_i2_1 � null

data_trans: process()if clk’event thencase s iswhen S_i1 � null;when S_i2_1 � r � �

Berechnungen im Datenpfad mit Register Datentransfer

ä Berechnungen werden im Datenpfad direkt abgebildet und mit kombina-torischer Logik durchgeführt.

ä Ergebnis von Berechnungen werden Registern zugewiesen.

ä Daher Berechnungen im transitorischen Datenpfadprozess data_trans.

ä Möglichkeit der Bindung von Datenpfadoperationen in einem Zeitab-schritt, sofern Datenabhängigkeit dieses zulässt.

ä Wichtig: Zeitmodell einer transitorischen Datenspeicherung (Latenz).

o Rechte Seite einer Signalzuweisung evaluiert mit alten Wert einesRegisters!

o Erst nach Evaluierung der rechten Seite der Zuweisung findet Daten-transfer an Register statt!

µRTL

..

s1: r1 ← r2+r3;s2: r1 ← r2+r3, r2 ← r1+r3;

VHDL

PD Stefan Bosse 166


..

...signal r1,r2,r3: <datatype>;...data_trans: process()if clk’event thencase s iswhen s1 � r1 � r2+r3;when s2 � r1 � r2+r3;

r2 � r1+r3;

Bedingte Verzweigungen im Kontrollfluss

ä Verzweigungen im Kontrollfluss werden durch Auswertung von Aus-drücken im Datenpfad ausgeführt (ausgenommen unbedingte Verzweigun-gen).

ä Die Ausdrücke können entweder im kombinatorischen Datenpfadprozessdata_path oder direkt im Übergangsnetzwerkprozess control_path einge-bettet werden → benötigt keine Zwischensignale.

µRTL

..

s1: branch (r2=r3): s3;s2: -next-

VHDL

..

signal r1,r2,r3: <datatype>;control_path: process()case s iswhen s1 �if r2=r3 then s_next � s3;else s_next � s2; end if;

PD Stefan Bosse 167


13.5. m-µRTL: Multi-Prozess Systeme auf RT Ebene

ä Die Abbildung eines sequenziellen Prozesses auf RTL kann auf ein be-liebiges Multiprozesssystem erweitert werden (Konkurrierende Kommu-nizierende Sequenzielle Prozesse CCSP)

ä Dabei wird jeder Prozess p der Prozessmenge P={p1,p2,..} auf eine eigeneRTL Komponente C={c1,c2,..} abgebildet:

p1(i1, i2, ..)→ c1(∆,Γ)

p2(i1, i2, ..)→ c2(∆,Γ), ..

pn(i1, i2, ..)→ cn(∆,Γ)

o1 → co1(∆,Γ), ..

ä Hinzu kommen globale geteilte Objekte (Ressourcen) O={o1,o2,..}, derenkonkurrierender Zugriff (Operationen) durch mutualen Ausschluss syn-chronisiert werden soll.

o Auf globale Objekte wird durch Methoden (Operationen) zugegriffen→ Monitorkonzept!

ä Daher Erweiterung der �RTL Anweisungen um Objektzugriffe

13.6. m-µRTL: Multi-Prozess Systeme auf RT Ebene

Mikrooperation für den Zugriff auf globale geteilte Objekte (Ressourcen)

µRTL Operation Beschreibung

o→op(arg1,arg2,...) Anwendung der Operation op aufdas Objekt o mit optionalenArgumenten arg1,….

r ← �(o→op(arg1,arg2,...)) Anwendung der Operation op aufdas Objekt o mit optionalenArgumenten arg1,… und Rückgabeeines Ergebniswertes in einemAusdruck � mit Datentransfer.

PD Stefan Bosse 168


13.7. m-µRTL Hardware Synthese von Multi-Prozess Sys-temen

ä Die Ausführung (Zustandsübergang) eines Prozesses der mit anderenum eine Ressource konkurriert kann durch ein objektselektives Block-ierungssignal GD blockiert werden, bis die Ressource dem Prozess zugeteiltwird, d.h. die angeforderte Operation ausgeführt werden kann.

ä Eine Operation die auf ein Objekt von einem Prozess angewendet werdensoll (Zugriff) wird durch ein Requestsignal REQ signalisiert.

ä Für jede Operation eines Objekts gibt es ein eigenes AnfragesignalREQ_OP, aber nur ein Blockierungssignal GD!

ä Jedes globales Objekt besitzt daher einen Mutex-Scheduler, um konkurri-erenden Zugriff zu sequenzialisieren und Wettbewerb aufzulösen.

ä Globale Objekte sind daher genauso zustandsbasiert wie die eigentlichensequenziellen Prozesse.

Abb. 75. RTL Hardware-Implementierung eines Multi-Prozess Systems

Operationsaufruf und Wirkung auf Daten- und Kontrollfluss

Alle vier Hardwareprozesse sind bei einem Operationsaufruf aktiv. Prozess-Zugriff auf Objekt o (GD: default=1) setzt Requestsignale und empfängt Reply-und Guardsignale

PD Stefan Bosse 169


..

µRTL:s1: o→op(r1)s2: r2 ← o→op(r1)

VHDL:entity p isport (signal o_p_GD: in bit;signal o_p_REQ: out bit;signal o_p_WR: out bit_vector();signal o_p_RD: in bit_vector();...

architecturesignal r1,r2: <datatype>; ...beginstate_transition: process() ...

..

control_path: process()case s iswhen s1 �if o_p_GD =’1’ then s_next � s1;else s_next � s2; end if;

data_path: process ()o_p_REQ � ’0’; o_p_WR � 0;...case s iswhen s1 �o_p_REQ � o_p_GD;o_p_WR � r1;

data_trans: process ()if clk’event thencase s iswhen s2 � r2 � o_p_RD;

13.8. Globale Objekte mit Mutex-Scheduler

ä Der konkurrierende Zugriff auf ein globales Objekt O, z. B. ein Register,Speicher, oder Synchronisationsobjekt, erfolgt anfragebasiert mit Bestäti-gung (REQ-ACK/GD).

ä Der Wettbewerb wird durch mutualen Ausschluss aufgelöst wodurch einestrikte Sequenzialisierung der Ausführung der Operationen erreicht wird.

PD Stefan Bosse 170


ä Der aufrufende Prozess wird durch ein Guardignal GD solange blockiertbis er (einen möglichen) Wettbewerb gewonnen hat.

ä Mutualer Ausschluss lässt sich in Hardware durch einekaskadierte/geschachtelte IF-THEN-ELSE Folge erreichen, da einegeschachtelte Folge von bedingten Verzweigungen (im VHDL Modell)prioritisiert ist.

Komponenteninterface eines globalen Objekts O

..

entity O isport(p1_REQ, p2_REQ,... : in bit;p1_GD, p2_GD,.. : out bit;p1_RD, p2_RD,... : out bit_vector;p1_WR, p2_WR,... : in bit_vector;

...

Mutex-Scheduler mit IF-THEN-ELSE Folge in einem Hardware Prozess imple-mentiert und statischer Priorisierung der Prozesse (p1 > p2 > p3 …) - kein FIFOScheduling! Der Scheduler bedient verschiedene Operationen REQ1, REQ2, …

PD Stefan Bosse 171


..

O_SCHED: process()if clk’event thenp1_GD � ’1’;p2_GD � ’1’; ...if p1_REQ1 = ’1’ thenp1_GD � ’0’;-- do something --r � p1_WR;elsif p2_REQ1 = ’1’ thenp2_GD � ’0’;-- do something --r � p2_WR;

..

elsif p2_REQ2 = ’1’ thenp2_GD � ’0’;-- do something --p2_RD � r;

elsif ......end if;

end if;

Statische Prioritisierung

ä Bei der einfachen Implementierung des Mutex-Schedulers gewinnt immerder höchstrangige Prozess einen möglichen konkurrierenden Wettbewerb.

ä D.h. bei kurz aufeinander folgenden Operationsaufrufen eines Objektsdurch den gleichen Prozess können andere Prozesse immer verlieren →Race-Condition Gefahr!

ä Synchronisation durch Verzögerung von Prozessen kann erforderlich sein(z. B. mit Event oder Timer Objekten).

Dynamische FIFO Priorisierung

ä Um einen fairen und gleich verteilten Wettbewerb zu gewährleisten wirdeine Einreihung der bisher abgelehnten Abfragen in eine Warteschlangeerforderlich (FIFO Queue).

ä Ressourcenaufwand ist um einiges höher als bei der statischen Priori-tisierung.

PD Stefan Bosse 172


ä Bei einer Anfrage kann ein Prozess

1. den Wettbewerb gewinnen,

2. nicht gewinnen und warten in die Queue aufgenommen zu werden(WAIT),

3. in der Queue aufgenommen zu werden (PUSH), und schließlichwieder entnommen zu werden (POP).

14. Referenzen

14.1. Bücher

1. P. S. Pacheco, An introduction to parallel programming. Elsevier, MK,2011.

2. T. Bräunl, Parallel Image Processing. Springer Berlin, 2001.

3. T. Rauber and G. Rünger, Parallele und verteilte Programmierung.Springer Berlin, 2007.

4. G. R. Andrews, Foundations of Multithreaded, Parallel, and DistributedProgramming. Addison-Wesley, Pearson, 2000.

5. K. Hwang, G. C. Fox, and J. J. Dongarra, Distributed and Cloud Com-puting: From Parallel Processing to the Internet of Things. Elsevier B.V.,2012.

6. S. Ghosh, Distributed Systems - An Algorithmic Approach. Chapman &Hall/CRC, 2015.

7. D. Talia, P. Trunfio, and F. Marozzo, Data Analysis in the Cloud. ElsevierLtd, 2016.

14.2. Videos

A. Dining Philosophers, https://www.youtube.com/watch?v=fg-NiDlcoS8

PD Stefan Bosse 173

verteilte und parellele eingebettete...

Documents