Architektur verteilter Systeme

Koordination
Abstimmung zwischen Threads, um Datenkonsistenz bei gleichzeitigem Zugriff zu erhalten

Synchronisation
Zeitliche Abstimmung hinsichtlich der Benutzung von Ressourcen bzw. Herstellen von "Gleichzeitigkeit", von Gleichtakt

Kooperation
zielgerichtetes Zusammenwirken  z,B. zur arbeitsteiligen Erfüllung einer komplexen Aufgabe

Deadlock
Warten auf ein Ereignis, das nicht eintreten kann, da die das Ereignis signalisierenden Vorgänge auf eine Aktivität eines Threads warten, der selbst auf das Ereignis wartet.

ist ein strukturell bzw. logisches Problem, das durch ein zyklenhaftes Warten entsteht
Bsp: Verkehrskreuzung mit vier Autos   /   You-after-you-Problem

-----------------------

Starvation

Zu langes Warten auf ein mögliches Ereignis als Folge übermäßiger "Ungerechtigkeit" zwischen Prozessen/Threads

Starvation ist ein Scheduling-Problem, d.h. ein Problem der schlechten Zuweisung von Ressourcen an Threads (Scheduling)

Wenn 4 Autos an einer Kreuzung stehen und niemand weiß wer entsprechend der Rechts-vor-Links-Regel als erstes fahren "darf" und alle darauf gleichzeitig warten, dass irgendjemand losfährt.

Wechselseitiger Ausschluss = Mutual Exclusion

Ergebnis der Koordinierung zur Verhinderung von Problemen bei der gemeinsamen Benutzung von Variablen in kritischen Abschnitten
 

Threads daran gehindert, eine Ressource zu benutzen, wenn diese durch einen anderen Thread belegt ist. Ressource ist hier die Menge der gemeinsam benutzten Variablen einer Klasse.
Erst nach Freigabe kann ein anderer Thread die Ressource belegen.

Synchronisation

Durch Realisierung von wechselseitigen Ausschlüssen wird der Zugriff auf gemeinsam benutzte Betriebsmittel so auf einander abgestimmt, dass die Konsistenz der Daten und damit die Korrektheit der Implementierung erreicht wird.

enter(Klassenname):

Betreten eines kritischen Abschnitts

leave(Klassenname):

Verlassen eines kritischen Abschnitts

optimistisches Verfahren = Im kritischen Abschnitt 

Während der Aktivitäten innerhalb des kritischen Abschnittes wird auf Probleme geprüft. Gibt es sie, werden Verfahren durchgeführt, die den alten Zustand vor dem Konflikt wieder herstellen, und alles beginnt von vorn.

Bsp: Ethernet

pessimistisches Verfahren = Vor dem kritischen Abschnitt 

Vor dem Betreten wird sichergestellt, dass später keine Probleme auftreten können. 

Bsp: Semaphoren

Die Realisierung von enter() und leave() mit Implementierungen, die mit Busy Waiting arbeiten, werden auch lock() und unlock() genannt, manchmal auch spinlock genannt.

Busy Waiting
Aktives Warten = Vorgang, bei dem eine CPU auf das Eintreten eines Ereignisses dadurch wartet, dass sie in einer Endlos-Schleife abfragt, ob es eingetreten ist. (das gibt es auch bei I/O)
 

Lock-Operation = spinlock
Realisierungen des Eintritts (Prolog) in einen kritischen Abschnitt mit Hilfe von Busy Waiting

Nein,  enter() und leave() realisiert der Algorithmus von Dekker

Semaphoren:

Datenstruktur, die aus einer Ganzzahl und den Nutzungsoperationen „Reservieren/Probieren“ und „Freigeben“ besteht. Sie eignet sich insbesondere zur Verwaltung beschränkter (zählbarer) Ressourcen, auf die mehrere Prozesse oder Threads zugreifen sollen, wie etwa Erzeuger und Verbraucher, sowie zur Koordination asynchroner Abläufe

Operationen der Semaphore S:
- p(S) realisiert das Betreten p steht für passeer, probeeren (Niederländisch).
- v(S) realisiert das Verlassen v steht für vrijgeven, verhogen (Niederländisch).

Idee:
Anstatt den gesamten kritischen Abschnitt mit einem lock()- unlock()-Paar zu sperren, wird nur der Code von enter() und leave() gesperrt.

Eine Semaphore S besteht aus:
– Es gibt eine globale Variable state zur Repräsentation des Belegungszustandes.
   Diese hat initial die Anzahl der gleichzeitig im kritischen Abschnitt erlaubten Threads, z.B. 1.
– Weiterhin gibt es eine Warteschlange q mit den wartenden Threads ohne eine Priorität.
    Diese Warteschlange ist initial leer.
 

Wenn die maximale Anzahl der Threads im kritischen Abschnitt 1 ist, werden diese Semaphoren binär genannt, da es nur zwei Zustände für den Zustand state gibt. 

Nein.

-----------------

Der kritische Abschnitt ist dann immer noch geschützt, wird aber wie normaler Code ausgeführt.
Wir haben damit zwei „Stufen“:
- Innerhalb der Routinen enter() und leave()
- Zwischen den Aufrufen enter() und leave()

• Alle in enter() wartenden Threads verlieren die CPU und erhalten sie erst dann wieder, wenn der Thread den kritischen Abschnitt betreten darf. D.h. das Warten in enter() wird wie das Warten auf I/O realisiert.

Monitor

Abstrakter Datentyp mit allen dafür notwendigen Operationen sowie der Bedingung, dass immer nur ein Thread eine der Operationen zu einem Zeitpunkt ausführen kann.

Hat ein Thread den Monitor betreten, so gehört er ihm bis er ihn verlassen hat oder in einer Warteschlange wartet.

Gründe:
Das Programmieren mit Semaphoren ist
- aufwändig
- relativ fehlerhaft, da die kritischen Abschnitte über den Code verteilt sind

Idee: In die Programmiersprache ein "sicheres" Konstrukt integrieren und den Compiler die p()- und
v()-Operationen generieren lassen: der Monitor

Entry-Queue

Threads, die den Monitor betreten wollen, aber nicht dürfen

Condition Queues
Hier warten Threads auf bestimmte Ereignisse
 

Urgent Queue
Hier warten Threads, die aufgrund des Eintretens von Ereignissen zusammen mit anderen aktiv werden wollen

Wenn ein Thread innerhalb des Monitors auf die Arbeit eines anderen Threads in diesem Monitor warten muss, gibt er den Monitor dadurch frei, dass er in eine Condition-Queue kommt und dort schläft. Dadurch kann der andere Thread den Monitor betreten.

----------------------------------------

Wenn der andere Thread gearbeitet hat, weckt dieser einen der Threads auf, die in der korrespondierenden Condition-Queue auf ihn gewartet hatten.

Da aber nur ein Thread zu einem Zeitpunkt im Monitor sein darf, kommt der aufweckende Threads in die Urgent-Queue.

Verlässt ein Thread den Monitor, so betreten die Threads der Urgent-Queue mit Priorität gegenüber der Entry-Queue jeweils einzeln den Monitor.

Ziel:

Hersteller unabhängige, Architektur unabhängige sowie Netz unabhängige Schnittstelle zwischen beliebigen Rechnern

Konzeptioneller Rahmen

Das Basis Referenzmodell legt einen Bezug (Reference) fest, der gerade so gestaltet ist, dass mit so wenigen Vorgaben wie nur möglich ein Maximum an Kompatibilität erreicht wird

Behandlung des Aspektes der Datenübermittlung, d.h. es geht nicht um die Verarbeitung, sondern nur um den Datenaustausch
 

Anzahl Schichten:  7


Schichten:

Anwendung
Darstellung
Steuerung
Transport
Vermittlung
Sicherung
Übertragung

An der Schnittstelle zwischen direkt benachbarten Schichten erbrachte Leistung der unteren Schicht durch Ausführen geeigneter Protokolle.

Ein Dienst kann auch als Angabe, was zu leisten ist, verstanden werden, während das Protokoll angibt, wie dieses Was realisiert wird.

Ein Dienst ist damit die Spezifikation der Leistung eines Protokolls.

Daher kann es mehrere Protokolle geben, die dieselbe Leistung erbringen, d.h. denselben Dienst realisieren.

Modell der Implementierung einer Komponente

Modell eines aktiven kommunizierenden Elements innerhalb einer Schicht und gleichzeitig innerhalb eines Systems

Entities können in Hardware, z. B. LAN-Karten, oder in Software, z. B. als Threads im Kernel oder als Prozesse, realisiert werden.

Dienste:

an der Schnittstelle zwischen direkt benachbarten Schichten

Protokolle: 

an der Schnittstelle zwischen Instanzen verschiedener Systeme derselben Schicht

PDU = Protocol Data Units

Bei Ausführen von Protokollen werden über die nächst unterliegende Schicht Einheiten von Daten ausgetauscht (=PDUs)

Segmentierung der Pakete in Frames und Hinzufügen von Prüfsummen

[Die Sicherungsschicht sorgt für eine zuverlässige und funktionierende Verbindung zwischen Endgerät und Übertragungsmedium. Zur Vermeidung von Übertragungsfehlern und Datenverlust enthält diese Schicht           Funktionen zur Fehlererkennung, Fehlerbehebung und Datenflusskontrolle.

Auf dieser Schicht findet auch die physikalische Adressierung von Datenpaketen statt.]

Aufgabe:
Funktionen für Anwendungen, sowie die Dateneingabe und -ausgabe

Beispiele: ???

.

Umwandlung der systemabhängigen Daten in ein unabhängiges Format

Darstellungsschicht wandelt die Daten in verschiedene Codecs und Formate/
Hier werden die Daten zu oder von der Anwendungsschicht in ein geeignetes Format umgewandelt.

Prozess

Sequentiell ablaufendes Programm

Thread

Sequentiell arbeitendes Programm(teil) als Teil eines Prozesses

Thread, der die Zuteilung der CPU zu den Threads nach einem Verfahren (Scheduling Strategie) realisiert

- in der Threadtabelle mitschreiben, welche Threads existieren

- vermerken, welcher Thread zu welchem Anteil die CPU schon bekommen hat

- vermerken des Thread-Zustandes (state):

- ändern des Threadzustands entsprechend einer neuen Situation

- zuteilen der CPU dem nächsten Thread

 Ein Timer ist ein spezielles Gerät, das nach einer eingestellten Zeit bzw. in zyklischen Abständen einen Interrupt sendet. Dieser wird immer mit dem Aktivieren des Schedulers behandelt.

 Dauer zwischen zwei Timer-Interrupts

Informationen zu jedem Thread:m

Identifikation,

Datensegment,

Zustand