beschreibende Parameter Laufparameter

3 P

-

P

3.1 Prozeßverwaltung

3.1.1 Prozeßbegrif Prozeß:

- Ausführung eines logisch zusammengehörigen Programms - Verwaltungseinheit des Betriebssystems

* Prozesse belegen Betriebsmittel

* Prozesse sind aktive Komponenten des Gesamtsystems Mehrprozeßsystem:

- bei einem Prozessor: Quasi-simultane / simultane Ausführung mehrerer Prozesse

- bei mehreren Prozessoren: Parallelarbeit auf Prozeßebene Prozeß <-> Unterprogramm

- Unterprogramm

* Ausführung in Aufrufumgebung eingebettet

* Unterprogramm greift i. a. auf Betriebsmittel des Hauptprogramms zu HP

U P

Das Unterprogramm ist Bestandteil des Prozesses.

- Prozeß

* Ablauf dem Ablauf der übrigen Prozesse gleichgeordnet

* Jeder Prozeß belegt Betriebsmittel i. a. individuell

3.1.2 Prozeßparameter

- beschreibend

* Name

* Art

* Basispriorität

* Codedatei-Verweis

* Speicherbedarf

* Bedarf an sonstigen Betriebsmitteln

* Rechenzeit-Angaben

=> Vorgaben bei Definition des Prozesses - Laufparameter

* Prozeßzustand

* aktuelle Priorität

* Prozeßidentifikation

* Betriebsmittel-Verweise

* verbrauchte Zeit

=> Bearbeitung des Prozesses durch Betriebssystem - Prozessor-Zustand

* Spezialregister-Inhalte - Befehlszähler - Status-Wort

- Unterbrechungsmasken - Schutzmasken

- Adreßumsetzungsdaten - Kellerzeiger

* Daten- und Adreßregister-Inhalte

=> Bearbeitung des Prozesses durch Prozessor-Hardware

3.1.3 Prozeßleitblock (Process Control Block PCB)

- Zusammenfassung der Prozeßparameter

- repräsentiert Prozeß gegenüber BS-internen Mechanismen - enthält

beschreibende Parameter Laufparameter

Prozessor-Zustand Verwaltungsdaten

Prozeßverwaltung

- durch Tabelle der PCBs

P1 wartend P2 bereit P3 rechnend P4 bereit P5 bereit P6 definiert P7 wartend

- durch Verkettung der PCBs in diversen Listen

P1 P2 P3 P4 P5 P6

existent rechnend

P7 x x

bereit

wartend x

Speicherung der PCBs

Die Speicherung der Prozeß Control Blocks erfolgt i. a. im für das Betriebssystem reservierten Datenbereich im Zentralspeicher.

- bei PCBs konstanter Länge i. a. nichtgestückelte Speicherung von PCBs

PCB P1

alle Parameter von Prozeß P1

u. U. Verweise auf Sekundärinformationen (e. g. Gerätekontrolle)

- bei komplexeren Betriebssystemen i. a. Aufteilung der PCBs in durch Verweise verbundene Teile

Primäre Laufparameter beschreibende Parameter

sekundäre Laufparameter

Prozessorzustand Adreßumsetzung

3.2 Prozessor

3.2.1 Blockbild eines Prozessors

Datenregister Adreßregister

Interrupt- maske

Kellerzeiger Befehlszeiger Statuszeiger

Adreßtafelzeiger Kontextzeiger Betriebsart Interruptregister

Unterbrechungs- werk

Befehlsregister Steuerwerk Taktregister

Hilfsregister Verknüpfungs- werk

Interrupts Adressen

Steuerung Daten

Befehle

3.2.2 Prozessorzustand

Bei Betrachtung der Zeitpunkte zwischen je zwei aufeinanderfolgenden Befehlsbearbeitungen sind die Inhalte folgender Register für die Zukunft des aktuell bearbeitenden Prozesses relevant:

- Daten- und Adreßregister

=> Zwischenergebnisse (Daten, Adressen) - Kellerzeiger

=> Zwischenergebnisse (Daten, Adressen) - Statusregister

=> Zwischenergebnisse (Daten, Adressen) - Betriebsart

=> Arbeitsweise - Befehlszeiger

=> nächster Befehl - Adreßtafelzeiger

=> Adreßumsetzung

3.2.3 Prozeßumschaltung aus Prozessorsicht

t P1

P2 a) b)

a) P1 -> P2

1) Prozessor hat soeben Bearbeitung eines Befehls beendet, im Befehlszähler steht die Adresse des Folgebefehls, übrige Register enthalten für nachfolgende Befehle benötigte Daten.

2) Retten aller dieser Registerinhalte im Zentralspeicher.

3) Laden der Register mit vorher von P2-Bearbeitung gespeicherten Daten aus dem Zentralspeicher.

b) P2 -> P1

1) Der Prozessor hat soeben die Bearbeitung eines Befehls beendet.

2) Retten der Registerinhalte in den Zentralspeicher.

3) Laden des Befehlszählers und der übrigen Register mit unter a2) geretteten Daten aus dem Zentralspeicher.

4) Bearbeitung des Prozesses P1 wird fortgesetzt.

Kontext-Switching aus Prozessorsicht:

-> Registerinhalte in den für bisherigen Prozeß reservierten Speicherbereich retten.

-> Registerinhalte mit Werten aus für zukünftigen Prozeß reservierten Speicherbereich laden.

3.2.3 Befehlsabarbeitungszyklus des Prozessors

Unterbrechungsbearbeitung:

- minimal:

Quelle erkennen,

Befehlszähler und Status retten,

Befehlszähler mit für Quelle definierter Adresse laden - weiterhin möglich:

alle Register in für aktuellen Prozeß reservierten Bereich retten, Register aus Bereich[Quelle] laden

Unterbrechung ? ja Befehl holen Operanden holen

Verknüpfen Ergebnisse speichern Befehlszähler aktualisieren

nein Seitenfehler

Unterbrechung auch aus laufendem Befehl heraus, jedoch immer vor Ergebnis- speicherung!

Unterbrechungsarten 1) externe Unterbrechungen - Geräte-Interrupts

* Fertigmeldungen von E/A-Steuerungen / -Geräten

* Alarme von Spezialperipherie

* Konsol-Eingriffe (e. g. Reset) 2) interne Unterbrechungen - Fehlersignale

* Verknüpfungsfehler (e. g. Division durch Null)

* Privileg-Verstöße

* Unbekannter Befehl

* Adressierungsfehler

- durch Spezialbefehle erzeugt

* Betriebssystem-Aufrufe ( SVCs)

* Befehlssimulation - Testhilfe-Unterbrechungen

* Einzelschrittmodus

* Sprungmodus

* Zugriffsmodus

3) Interprozessor-Signale

- im Mehrprozessorsystem von fremdem Prozessor per Spezialbefehl erzeugt

Beispiel: Unterbrechungsbehandlung IBM /370, Siemens 7.500

old PSW new PSW

INT-Code Unterbrechungs- Analyse

current PSW nächster Befehl Unterbrechung 1. Sichern

2. Bereitstellen 3. Laden 4. Laden (old PSW + Status)

Sichern Prozessorstatus analysieren des INT-Codes entsprechend reagieren

PSW = Program Status Word (enthält u. a. Befehlszähler)

Mehrere Interrupts gleichzeitig sind nicht möglich, da OLDPSW und NEWPSW Speicherbereiche darstellen

Lösung:

Die Speicherbereiche OLDPSW, NEWPSW und INT-Code sind mehrfach vorhanden:

- je einmal pro Unterbrechungsklasse

- die Unterbrechungsklassen sind je einmal vorhanden pro Prozessor - es gibt 6 Unterbrechungsklassen

1) Maschinenfehler 2) SVC = Supervisor Call

3) programmabhängige Unterbrechungen

(z. B. Division durch 0, Adressierungsfehler) 4) externe Unterbrechungen (Zeitgeber, ...) 5) Ein-/Ausgabe

6) Restart

Beispiel: Unterbrechungsbehandlung bei µP

Code der U-Routine Systemkeller

Unterbrechungsvektor

Systemkellerzeiger Prozessor interne U-Quellen

3 4 5

Interrupt-Eingänge 0 1 2 0

1 ...

- beim Auftreten eines Interrupts

* retten von Befehlszähler und Status in Systemkeller

* einschalten des System-Modus

* laden des Befehlszählers mit der Adresse der entsprechenden U-Routine

- U-Routine

* befehlsgesteuertes Retten der übrigen Register

* Interrupt-Analyse

* Interrupt-Reaktion

* befehlsgesteuertes Wiederherstellen der Register

* Befehl: Return from Interrupt:

Laden des Befehlszählers und der Statusregister aus Systemkeller, Umschalten in Nutzer-Modus

Durch den System-Keller ist die Schachtelung von U-Routinen-Bearbeitung möglich, aber nicht immer sinnvoll:

Priorisierung von Interrupts, Maskierung von Interrupts.

Beispiel: Unterbrechungsmechanismus bei Prozeßrechnern (Realzeit- Verarbeitung)

Zentralspeicher Prozessorstatus E1 Prozessorstatus E2 Prozessorstatus E3 ...

Prozessor Register, BZ aktuelle Ebene Ebenenanforderungen Interrupt-Maske Interrupt-Register

interne Unterbrechung

Interrupt-Eingänge

- Prozessor schaltet selbstätig (abhängig von der aktuell höchstpriorer Anforderung) zwischen z. B. 16 Ebenen um.

- Der Prozessorstatus für jede Ebene liegt im Zentralspeicher in fest reservierten Bereichen.

- Nicht-maskierte Interrupts führen zum Setzen von Ebenen-Anforderungsbits.

- Nach jedem Befehl wird die aktuelle Ebene mit der höchsten angeforderten Ebene verglichen, falls höhere Ebene angefordert: Umschaltung per

Prozessor-Hardware.

- Die Ebenenanforderung kann per Spezielabefehl gelöscht werden:

Umschaltung auf höchste angeforderte Ebene.

- Die Anforderung für die unterste Ebene ist nicht löschbar.

3.3 Prozeßumschaltung

3.3.1 Prozeßzustände

nicht definiert Prozeß existiert noch nicht bzw. nicht mehr PCB ist nicht existent

nicht aktiv Prozeß ist definiert => PCB, aber nicht laufbereit Betriebsmittel i. a. noch nicht zugeordnet

bereit Prozeß ist definiert und laufbereit:

Speicher und Betriebsmittel sind zugeordnet Prozessor noch nicht zugeordnet

rechnend Prozeß ist definiert und laufbereit Prozessor ist zugeordnet

Fortschritt in Programmablauf wartend Prozeß ist definiert

Betriebsmittel sind zugeordnet

Prozessor wartet auf ein Synchronisationsereignis (z. B. E/A-Ende)

i. a. Unterzustände von "wartend":

- warten auf E/A-Ende

- warten auf Signal von anderem Prozeß

- warten auf Fortsetzung durch anderen Prozeß - warten auf Zeitsignal

nicht

definiert nicht

aktiv erzeugen

vernichten

bereit starten

beenden

rechnend zuordnen

wartend aufgeben

blockieren (eigen) fortsetzen

blockieren beenden (eigen)

Zustandsübergänge:

erzeugen 1) PCB erzeugen (fork) => Zustand "nicht aktiv"

2) PCB mit beschreibenden Parametern belegen - Name

- Art

- Basispriorität - Codedate-Verweis - Speicherbedarf - Betriebsmittelbedarf - Rechenzeitangaben - ggf. Umgebung vernichten PCB löschen (terminate)

Bei vielen Betriebssystemen sind die Operationen Erzeugen mit Starten und Vernichten mit Beenden gekoppelt.

starten 1) Belegen von Betriebsmitteln - Speicher

- u. U. Geräte, Dateien (je nach Strategie) 2) Initialisierung der Laufparameter in PCB:

- Prozeßzustand: "bereit"

- aktuelle Priorität - Prozeßidentifikation - Betriebsmittelverweise - Zeit-Zähler

3) Initialisierung des Prozessorzustandes für Prozeß in PCB - Befehlszähler, Status, Schutzmasken,

Adressiertabellenzeiger, Kellerzeiger - u. U. Daten- und Adreßregisterinhalte 4) Umschalten (s. u.)

beenden 1) Freigabe ven Betriebsmitteln - offene Dateien schließen - Speicher freigeben 2) PCB: Zustand "nicht aktiv"

zuordnen / zuordnen <--> aufgeben: umschalten aufgeben 1) aktuellen Prozeß aufgeben

- PCB: Zustand "bereit"

- Prozessorstatus --> PCB 2) neuen Prozeß bestimmen

- Auswahl des neuen Prozesses aus Menge der "bereiten"

Prozessen 3) neuen Prozeß zuordnen

- PCB: Zustand "rechnend"

- Prozessorstatus von PCB --> Prozessor

Optimierung: - zunächst neuen Prozeß bestimmen

- bei Pneu = Palt: keine Aktion, sonst umschalten

zuordnen Bereit --> Rechnend Zustand: Prozeß bereit Ereignisse:

- ein Prozeß verschwindet aus Rechnend; Bereit ist nicht leer

* Prozeß wird verdrängt (von SIH nach Interrupt, z. B. Timer)

* Prozeß gibt auf, blockiert sich (durch Erzeugung von Interrupt, z.

B. SuperVisorCall)

- ein Prozeß kommt nach Bereit

* und Leerlaufprozeß aktiv

* der neue Prozeß hat höhere Priorität als ein rechnender Prozeß und verdrängt diesen

Initiator: Prozeß selbst oder SIH Ausführender: SIH

verdrängen Rechnend --> Bereit Ereignisse:

- nachdem Verdrängungsprüfung sich für neuen Prozeß entschieden hat

=> wann Verdrängungsprüfung?

a) neuer Prozeß nach Bereit b) bei jedem Interrupt c) bei Zeitscheibenende - Regeln für Verdrängungsprüfung

a) Prozeß mit höherer Priorität in Bereit

b) nach Zeitscheibenende und Prozeß in Bereit

Initiator: SIH des eigenen Prozesses oder eines anderen Ausführender: SIH des eigenen Prozesses als Unterroutine von Zuordnen

aufgeben Rechnend --> Bereit

- wie verdrängen, aber ohne Verdrängungsprüfung blockieren Rechnend --> Wartend

1) PCB: Zustand "wartend"

2) Wartegrund in PCB vermerken Ereignisse:

- warten auf E/A-Ende - warten auf Betriebsmittel - warten auf Nachricht / Auftrag

Initiator: der betroffene Prozeß selbst

Ausführender: SIH (weil auf Blockieren stets Zuordnen folgt)

fortsetzen 1) PCB: Zustand "bereit"

2) Wartegrund in PCB löschen

3) Umschalten: der fortgesetzte Prozeß könnte neuer höchstpriorer

"bereiter" Prozeß sein

blockieren 1) Wartegrund in PCB vermerken

(eigen) 2) Umschalten (Zielzustand: "wartend") beenden 1) Betriebsmittelfreigabe

(eigen) 2) Umschalten (Zielzustand: "nicht aktiv") Realisierung:

Die Prozesse werden unterteilt nach Zuständen. Jede Prozeßmenge ist realisiert als verkettete Liste von PCB's.

Beispiel:

1.) für Zustand "bereit", "nicht aktiv"

a) Liste mit FIFO-Organisation

Kopfanker P9 Endeanker

entfernen

P8 P2

P4 einfügen

b) Liste mit linearer Prioritätszuordnung

Kopfanker

entfernen

einfügen P3

Prio 8 P5

Prio10 P6

Prio 4 P9

Prio 1

P5 Prio 3

2.) Rechnend: Pro Prozessor 1 Prozessorblock --> PCB x rechnend

3.) Wartend: Verkettete Liste:

a) LIFO (beim Aufnehmen)

P4 P2

P5 P6

neuen Prozeß einfügen Ereignis für P4:

aus Warteschlange entfernen

Kopfanker W Endeanker W

b) geordnet nach Wartezeit (falls bekannt)

Zustandsübergänge werden implementiert, indem ein Prozeß aus einer Liste entfernt und in eine andere Liste aufgenommen wird.

Probleme bei der Realisierung der Routinen:

a) Wie werden die ersten Prozesse erzeugt

b) Bei welchem Ereignis-/Zustandspaar wird ein Übergang ausgeführt?

c) Welcher Prozeß empfängt und verarbeitet das Ergebnis d) Welcher Prozeß führt den Übergang durch?

e) Was passiert, wenn mehr Prozessoren als bereite Prozesse vorhanden sind?

Lösungsansätze:

zu a) Startup - Prozeß

- wird von Hard-/Firmware erzeugt - lädt Betriebssystem

- erzeugt Systemprozesse zu b) Ereignis-Zustandstabelle

- wird statisch im System definiert

- wird bei Unterbrechungen ausgewertet - erzeugt Systemprozesse

zu c) Prozeß zur Behandlung von Unterbrechungen

- pro Prozessor wird ein Unterbrechungsprozeß kreiert SIH (System-Interrupt-Handling) - Prozeß

- SIH nimmt alle Unterbrechungen an dem Prozessor entgegen - SIH wird durch Hard-/Firmware in Zustand "Rechnend" versetzt,

wobei der aktuelle Prozeß verdrängt wird - SIH gibt auf, wenn seine Aufgaben erfüllt sind zu d) SIH-Prozess bzw. Prozess der von SIH beauftragt wird zu e) Leerlaufprozeß (WAIT-Prozeß)

- existiert einmal pro Prozessor

- wird zugeordnet, wenn es keinen bereiten Prozeß mehr gibt - wird verdrängt, wenn neuer Prozeß bereit wird

- implementiert z. B. als Sprung auf sich selbst

Initialisierungsproblem:

Wie wird das Betriebssystem "hochgefahren" ?

ROM Initialroutine Speicher

Befehlszähler Prozessor

Reset-Interrupt Betriebsspannungsinterrupt

Code des BS Parameter u.U. Wiederanlauf

Daten Initialroutine

- lese Code ein

- konfiguriere nach Parametern - stelle u. U. alten Zustand her

3.3.2 Strategien Ziele:

- gute Auslastung des Gesamtsystems

- gleichmäßige Aufteilung der Betriebsmittel auf die Nutzer

3.3.2.1 Startstrategien

nicht aktiv bereit

zurückgestellt

Betriebsmittel: Speicher, Geräte

- zusätzlicher Prozeßzustand zurückgestellt - beim Starten

* Untersuchung des Betriebsmittelbedarfs - Speicherüberlastung

- Konflikte bei exklusiv belegten Betriebsmitteln

- Erzielung geeignetes mittleres Lastprofil (E/A-intensiv <-->

rechenintensiv)

* davon abhängig:

--> bereit

--> zurückgestellt

- periodische Untersuchung der zurückgestellten Prozesse z. B. wenn ein Prozeß beendet wird

3.3.2.2 Umschaltstrategien

bereit rechnend

Betriebsmittel: Prozessor

Beurteilungskriterien

- CPU-Auslastung (Zeit der Nutzprozesse/Gesamtzeit) möglichst maximal

- Durchsatz (Anzahl bearbeiteter Prozesse pro Zeiteinheit) möglichst maximal

- Verweildauer (Dauer der Verarbeitung eines Prozesses zwischen Start und Ende;

Rechenzeit und Wartezeit) möglichst minimal

- Wartezeit (Zeit in Zustand "Bereit") möglichst minimal

Optimiert wird i. d. R. über Mittelwert.

Mittlere Verweildauer mVW = 

CPU-Bedarf-Endezeiten / Anzahl der Prozesse

1) FCFS - First Come First Served - zeitgesteuerte Strategie

- keine Verdrängung - Einreihung FIFO Beispiel:

Prozeß nächste CPU-Zeit

1 24

2 3

3 3

Wenn die Prozesse in der Reihenfolge P1->P2->P3 eintreffen, kann man den Ablauf in folgendem "Gantt-Chart" darstellen:

0 24 27 30

P1 P2 P3

Die mittlere Verweildauer ist hier: (24+27+30) / 3 = 27 (Konvoi-Effekt) Ist die Reihenfolge aber P2->P3->P1,

P1

P2 P3

0 3 6 30

so ist die mVW = (3+6+30) / 3 = 13 2) SJF - Shortest Job First

- keine Verdrängung

- Einreihungskriterium in "Bereit": nächster CPU-Bedarf bzw. Rechenzeit bis Ende

- optimal bezüglich der mittleren Verweildauer und Wartezeit Probleme:

- die nächste CPU-Zeit ist unbekannt

- keine Verdrängung => "Langläufer" können trotzdem "Kurzläufer"

blockieren, wenn sie zum Entscheidungszeitpunkt allein in "Bereit" sind.

Beispiel:

Prozeß nächste CPU-Zeit

1 6

2 3

3 8 mVW = (3+9+16+24) / 3 = 13

4 7

P2 P1 P4 P3

0 3 9 16 24

3 6 7 8 Einreihung nach CPU-Bedarf

Probleme und Lösungsmöglichkeiten:

- keine Verdrängung

neue Strategie SRTF (=SJF mit Verdrängung) - nächste CPU-Zeit unbekannt

Lösung 1:

Beim Start eines Jobs wird ein Zeitlimit angegeben (z. B. TIME=500), das als Maß für die Strategie gilt.

Lösung 2:

Prognose des nächsten CPU-Bedarfs aus voran gegangenen Werten z. B. exponentieller Durchschnitt

Sei tn die gemessene Größe des n'ten CPU-Bedarfs, sei sn die geschätzte Größe des n'ten CPU-Bedarfs.

Davon definiert (mit 0<=  <= 1)

geschätzter nächster CPU-Bedarf sn+1 =  * tn + (1-) * sn eine Prognose für den (n+1)'ten CPU-Bedarf.

Oft:  = 0,5

 steuert das Gewicht der jüngsten und der ältesten Vergangenheit.

3) SRTF - Shortest Runtime First - entspricht SJF mit Verdrängung

- Verdrängungsprüfung, wenn neuer Prozeß nach "Bereit" kommt

=> Zeit für Verdrängungsprüfung

- Prozeß mit kürzester Rechendauer wird bearbeitet

Beispiel:

Prozeß Ankunftszeit CPU-Verbrauch

1 0 8

2 1 4

3 2 9

4 3 5

Prozeßwechsel W = 0,2

Verdrängungsprüfung V = 0,1

P1

0 1

V W 1,3

P2 2

V 2,1

P2 3 V

3,1

P2 W P4 W P1 W P3

5,5 5,7 10,7 10.9 17,9 18,1 27,1

mVW = (17,9 + 4,5 + 25,1 + 7,7) / 4 = 13,7 zum Vergleich:

SJF: mVW = (8 + 11,2 + 24,6 + 14,4) / 4 = 14,5

4) Round Robin

- Zeitscheibenverfahren - mit Verdrängung

- zyklisch: nach Ablauf einer "Zeitscheibe" wird der rechnende Prozeß verdrängt, falls ein anderer Prozeß bereit ist.

- Prozessorzuteilung über Intervallgröße an Prozeßverhalten anpaßbar - keine selbstätige Bevorzugung E/A-intensiver Prozesse

Die Performance von Round Robin ist abhängig von:

- der Zeit, die für einen Prozeßwechsel benötigt wird (Anzahl minimieren =>

Zeitscheibe groß)

- der Größe der Zeitscheibe (Zeitscheibe groß => gleiche Strategie wie First Come First Served)

Faustregel: 80% der CPU-Beanspruchung <= Zeitscheibe Realisierung:

- Bereitliste, wie bei FIFO-Strategie

- mit Zuordnen wird Uhr entsprechend gew. Intervall eingestellt (Wecker) - Interrupt von Uhr löst Umschaltvorgang aus

Beispiel:

Prozeß CPU-Bedarf

1 24 Zeitscheibe = 4

2 3 Prozeßwechsel = 0,2

3 3 Zeitscheibenende=0,1(für Verdrängungsprüfung)

P1 4

4,3 P2

7,3 7,5

P3 10,5

10,7 P1

14,7

kein Zeitscheibenende, da kein Prozeß mehr bereit P1

18,8 P1

22,9

P1 P1

27 31,1

mVW = (31,1 + 7,3 + 10,5) / 3 = 16,3 zum Vergleich: FCFS => mVW ca. 27,1

Übung:

Wie groß müßte die Zeitscheibe zu wählen, damit die mVW minimal wird?

1. Versuch: Zeitscheibe=3 mVW= (31,5 + 6,3 + 9,6) / 3 = 15,8 2. Versuch ???

5) Prioritätsgesteuerte Strategien

Zweck:

Bestimmte Klassen von Prozessen sollen (auf Kosten anderer) bevorzugt werden.

z. B. - Prozesse mit großer Wichtigkeit (Systemprozesse) - Prozesse mit gutem Betriebsmittelverhalten

Arten:

- statische Prioritäten werden beim Erzeugen festgelegt und bleiben während der Lebensdauer konstant

- dynamische Prioritäten werden aus geeigneten Eigenschaften (Wartezeit, I/O-Routinen) periodisch neu berechnet

Statische Prioritäten:

Jedem Prozeß wird beim Erzeugen eine Prioritätsstufe  [0..pmax]

zugewiesen. Der höchstpriore "bereite" Prozeß wird als nächster

"behandelt".

Problem: Bestimmung der sinnvollen Priorität zum Erzeugungszeitpunkt

Realisierung: sortierte Bereitliste

Dynamische Prioritäten:

Jedem Prozeß wird beim Erzeugen eine Basispriorität statisch zugewiesen.

Zum Beispiel:

0 Leerlaufprozeß

1 BS-Hintergrundprozesse 4 Batch-Prozesse

8 Dialog-Prozesse

12 dringende BS-Prozesse 16 Realzeit-Prozesse

Die aktuelle Priorität wird dynamisch aus dem Verhalten des Prozesses in der Vergangenheit und der Basispriorität ermittelt.

Möglichkeiten:

- Bestrafung bei Verlassen des Zustands "Rechnend"

- Belohnung bei Betreten des Zustands "Wartend"

- Belohnung für Wartezeit - Bestrafung für Rechenzeit

- Förderung von Dialog-Prozessen Beispiel:

Sei t ein Maß für die Ein-/Ausgabe-Intensität t = ( => 0 < t < 1),

dann kann mit

PD = t * Pmax

eine dynamische Priorität berechnet werden.

Zweck: E/A-intensive Prozesse werden bevorzugt => gute Auslastung der Peripherie

Beispiel: Berechnung einer dynamischen Priorität in UNIX

PD = Puser + Pcpu / 2 + Pnice Puser = Basispriorität

Pcpu = Pcpu / 2

Pnice = Wert den der Anwender vergibt

Pcpu wird bei dem rechnenden Prozess bei jeder Zeitgeber- unterbrechung (z.B. jede 1/60 sek.) um 1 erhöht.

Pcpu wird mit 0 initialisiert.

z.B. gelte für Prozess P1: Puser = 60, Pcpu = 0, Pnice = 10 Nach 1 Sekunde Rechenzeit gilt: PD = 60 + 15 + 10 = 85 Nach 2 Sekunden Rechenzeit gilt: PD = 60 + 22 + 10 = 92

Übung:Klausuraufgabe

Prozeß n. CPU-Verbrauch Priorität

1 1 1 (schlechteste)

2 1 2

3 3 3

4 7 4

5 9 5 (beste)

Prozeßwechselzeit = 0,2 Verdrängungsprüfung = 0,1 Zeitscheibenende = 0,1 a) Welche der 3 Strategien

- Arbeiten nach Priorität

- Round Robin mit Zeitscheibe = 2 - FCFS

liefert das beste Ergebnis bezüglich der mVW?

b) Gibt es eine Strategie, die ein besseres Ergebnis liefert, als die in a) genannten?

3.4 Kritische Abschnitte

3.4.1 Probleme und Lösungsansätze

Problem: Inkonsistenzen in (Verwaltungs-)Daten durch zeitlich überlagerte Zugriffe nebenläufiger Prozesse auf diesselben Daten.

verallgemeinert: nebenläufiger Zugriff auf geteiltes Betriebsmittel Nebenläufigkeit:

- Mehrprozessor-System:

Prozessoren bearbeiten unabhängig voneinander verschiedene Prozesse - Einprozessor-System und Mehrprozessor-System:

Interrupt kann asynchron zum Prozeßablauf die Bearbeitung einer Unterbrechungsroutine bewirken. Prozeßumschaltung kann unvorhergesehen im Prozeßablauf auftreten.

Beispiel: Banksystem

Zeit Prozeß P1: Einzahlungen Prozeß P2: Abhebungen

T0 liest : -500,- DM

T1 liest: -500,- DM

T2 bucht: -500,- DM

T3 schreibt: -1000,- DM

T4 bucht:+3000,- DM

T5 schreibt: +2500,- DM

==> Kontostand: +2500,- DM richtig wäre: +2000,- DM

Die Transaktion "Lesen-Buchen-Schreiben" wird daher auch als "Kritischer Abschnitt" (KA) bezeichnet.

Lösungsansatz: P2 wird solange verzögert, bis P1 den kritischen Abschnitt verlassen hat

P1:

P2:

KA

KA

Verzögerung/

Sperre

Beispiel: Zugriff auf gemeinsamen Zähler A .

Jeder Durchlauf eines der Prozesse P1, P2 soll A um 1 erhöhen.

var A : global integer;

P1: P2:

... ...

I := A; J := A;

I := I + 1; J := J + 1;

A := I; A := J;

... ...

=> A kann wiederum verfälscht werden, wenn die Prozesse ungünstig ablaufen. (Konstruieren Sie ein Ablaufbeispiel!)

Lösungsansatz: Gegenseitiger Ausschluß (Mutual Exclusion) der Prozesse var A: global integer;

B: global boolean;

P1: P2:

... ...

BELEGE; BELEGE;

I := A; J := A;

I := I + 1; J := J + 1;

A := I A := J;

GIBFREI; GIBFREI;

... ...

procedure BELEGE;

begin

while B do ;

B := true;

end;

procedure GIBFREI;

begin

B := false;

end;

Problem: BELEGE enthält selbst kritischen Abschnitt (nämlich Zugriff auf B!)

Lösung von Dijkstra (1965)

Semaphorvariable:

P(S): die Ganzahl S wird um 1 erniedrigt wenn S < 0 => Prozeß muß warten

wenn S >= 0 => betreten des kritischen Abschnittes V(S): die Ganzzahl S wird um 1 erhöht

wenn S <= 0 => ein wartenden Prozeß darf den kritischen Abschnitt betreten.

P(S)

S := S - 1

S >= 0 ?

warten J

N

J N

V(S)

S := S + 1

S <= 0 ?

einmal warten lösen

|S| = Anzahl der wartenden Prozesse

Mit der Initialisierung S := 1 ergibt sich folgende Gesamtlösung:

P(S)

KA

V(S)

Qualitätsanforderungen an Lösungen:

Unabhängig von der konkreten Aktionsfolge des Prozesssystems und unabhängig von der Geschwindigkeit von Prozessen und Prozessoren werden folgende

Anforderungen an eine Lösung gestellt:

1.) Sicherheit (auch partielle Korrektheit)

Es muß garantiert sein, daß sich stets nur ein Prozess in einem kritischen Abschnitt (derselben Klasse) befindet.

2.) Lebendigkeit (auch totale Korrektheit)

Jeder Prozess, der den kritischen Abschnitt betreten möchte, erhält Zutritt in endlicher Zeit.

Es gibt drei Hauptursachen, daß sich eine Lösung nicht als lebendig erweist:

2a) Fernwirkungen:

Ein Prozess, der sich weder in einem kritischen Abschnitt befindet noch in in einem kritischen Abschnitt eintreten möchte, darf den Zutritt von anderen Prozessen in den kritischen Abschnitt derselben Klasse nicht verhindern.

2b) Verklemmungen:

Die Lösung muß stets entscheiden können, welcher von mehreren

daran interessierten Prozessen einen kritischen Abschnitt zuerst betreten darf.

2c) Ausgrenzungen: (auch Behinderungen oder Benachteiligungen)

Die Lösung schließt einen Prozess beliebig lange vom Zutritt aus. Z.B. wird einem Prozess der Zutritt ständig zugunsten von anderen Prozessen

verwehrt.

Kriterien für die Realisierung des gegenseitigen Ausschlusses

Die Realisierung ist abhängig von:

- der zeitlichen Länge des kritischen Abschnitts

* kurze KA (aktives Warten möglich)

* lange KA (Warten durch Blockieren) - der Umschaltstrategie

* mit Verdrängung

* ohne Verdrängung - der Anzahl der Prozessoren

* Einprozessorsystem

* Mehrprozessorsystem - der Eigenschaft der Prozessoren

* Eigenschaften von Maschinenbefehlen

* Befehl "Testen und Setzen" vorhanden?

3.4.2 Algorithmen Annahmen:

- Multiprozessorsystem

- Umschaltstrategie mit Verdrängung - 2 Prozesse P0 und P1

- 2 binäre Semaphore B0 und B1 als globale Variable - Integervariable TURN

1. Lösungsversuch

KA

P0 P1

J TURN = 0 N

TURN = 1 3. Lösungsversuch

KA J TURN = 1 N

TURN = 0

Sicherheit: Ja

Verklemmung: Nein Ausgrenzung: Nein

Fernwirkung: Ja, wenn ein Prozeß beendet wird, kann der andere den KA höchstens noch einmal durchlaufen!

B := 00 B := 10 KA

P0 P1

B = 1 ?1 J N

B := 0 B := 1

KA

B = 1 ? J N

0

1 1 2. Lösungsversuch

Fernwirkung: Keine

Sicherheit: Nicht gegeben, z.B.:

Sei B0 = 0 ; B1 = 0

Zeit: P0 P1

T0 B1 = 1? (N)

T1 B0 = 1? (N)

T2 B1 = 1

T3 KA

T4 B0 = 1

T5 KA

Beide Prozesse befinden sich im kritischen Abschnitt!

B := 00 1

0

B = 1 ? B := 1

J N KA 3. Lösungsversuch

B := 0 J N

KA

P0 P1

B := 11

B = 1 ?0

1

Sicherheit: Ja, da jeder Prozeß Pi nur bei Bj = 0 den KA betreten kann Fernwirkung: Nein

Ausgrenzung: Nein

Verklemmung: Möglich, z.B.:

Sei B0 = 0 ; B1 = 0

Zeit: P0 P1

T0 B0 = 1 B1 = 1

T1 B1 = 1? (J) B0 = 1? (J)

Die Prozesse sind verklemmt!

4. Lösungsversuch

B := 10

J B := 00

B = 1 ?1 N

B = 1 ?1 N

KA B := 00 P 0

B := 1

J B := 0

B = 1 ? N

N

KA P 1

1 0

1

B = 1 ?0 B := 01

J J

Sicherheit: Ja Verklemmung: Nein Fernwirkung: Nein Ausgrenzung: Ja, z.B.:

Sei B0 = 0 ; B1 = 0

Zeit: P0 P1

T0 B0 = 1 B1 = 1

T1 B1 = 1? (J) B0 = 1? (J)

Wenn beide Prozessoren immer in derselben Geschwindigkeit laufen, wird der KA von keinem Prozeß erreicht!

B := 10

J

B := 00

B = 1 ?1 N

N

KA

B := 00 P 0

J 5. Lösungsversuch

N TURN = 0 ?

TURN = 1 ?

TURN = 1 J

B := 1

J

B := 0

B = 1 ? N

N

KA P

J

N J

1

1 0

TURN = 1 ?

1 TURN = 0 ?

TURN = 0 B := 01

Sicherheit: Ja

Lebendigkeit: Ja

Erweiterung auf n Prozesse

var flag: array[0,...,n-1] of (idle, want_in, is_in) turn: 0,...,n-1

i,j

flag[i] := want_in

N TURN = i ?

flag[turn] = idle ? N

TURN := 1 J

flag[i] := is_in j := 0 j < n AND i=j OR flag[j] + is_in

J j := j + 1 N

j >= n J KA flag[TURN] := idle

P i

Welche Qualitätsanforderung wird von dieser Erweiterung nicht erfüllt?

3.4.3 Kurze kritische Abschnitte

Die Lösungskonzepte verwenden (kombiniert):

- aktives Warten - Spezialbefehle

- Verhindern von Verdrängung

Verbieten Erlauben von Unterbrechungen

Setzen von Priorität auf Maximalwert und zurück

KKA braucht nicht geschützt

werden

B <> 0 ? N

J B := 1 KKA B := 0

Voraussetzungen:

- unteilbar (1 Befehl) - multiprozessorfest d. h. Prozessor sperrt B für 1 Maschinenbefehl aktives Warten

Mehrprozessorsystem ohne Verdrängung Einprozessorsystem

ohne Verdrängung

KKA Verdrängung verbieten

Verdrängung erlauben

B <> 0 ? N

J B := 1

B := 0 KKA

Verdrängung erlauben Verdrängung verbieten

Voraussetzungen:

- unteilbar (1 Befehl) - multiprozessorfest d. h. Prozessor sperrt B für 1 Maschinenbefehl Einprozessorsystem

mit Verdrängung Mehrprozessorsystem

mit Verdrängung

Für den Standardfall "Mehrprozessorsystem mit Verdrängung" muß der Lösungsansatz weiter spezifiziert werden

1. Versuch

Unterbrechung verbieten

B = 0 ? N

J B := 1

KKA

B := 0 Unterbrechung erlauben

keine Verdrängung möglich

Problem:

Das aktive Warten kann nicht unterbrochen werden und somit ein anderer Prozeß u. U. nicht mehr drankommen => Endlosschleife!

Unterbrechung verbieten B = 0 ? N

J B := 1

KKA Unterbrechung erlauben 2. Versuch

B := 0

Verdrängung möglich

Verdrängung möglich

Problem:

- nach der Prüfung "B = 0 ?" kann der Prozeß verdrängt werden

=> KKA nicht geschützt

- nachdem die Unterbrechung erlaubt wurde kann der Prozeß verdrängt werden, B ist aber noch nicht zurückgesetzt

=> KKA wird blockiert, ohne daß er benutzt wird

Unterbrechung verbieten

B := 1

KKA

Unterbrechung erlauben B := 0 B = 0 ? N

J Unterbrechung

erlauben 3. Versuch

3.4.3 Lange kritische Abschnitte

Besonderheiten:

- Bearbeitungszeit des KA groß

- Aufrufe komplexer Betriebssystemoperationen möglich - Wartestellen möglich

Hieraus folgt:

- Interrupt sperren: unzulässig ( schlechte Reaktionszeit usw.) - aktive Warteschleife: unzulässig; belegt Prozessor zu lange Lösungsansatz:

Semaphor S mit Warteliste

S.B: Datentyp Bool, Schützt kritischen Abschnitt S.L: Liste mit wartenden Prozessen

M: Binäres Semaphor, Schützt zugriff auf S (kurzer kritischer Abschnitt)

N

procedure Passieren (S:Semaphor)

TuS(M)

# 0 ?

S.B # 0 ? J

S.B := 1

Loe(M)

P nach S.L

Blockiere P und Loe(M) J

N

N TuS(M)

# 0 ? J

Loe(M) J

N procedure Verlassen (S:Semaphor)

S.L leer ? S.B := 0

U: 1.P aus Liste

Deblockiere U und Loe(M)

Beispiel: auf den Systemen IBM/370, Siemens 7500 gibt es den Befehl TS

TS Testen und Setzen eines adressierten Bytes

a) ist Byte = '00' -> Anzeige (Condition Code) = 0 -> Byte = 'FF'

b) ist Byte = 'FF' -> Anzeige = 1

Im BS2000 wurde hiermit lange Zeit die folgende Lösung (z.B. für den Zugriff auf den Dateikatalog) verwendet:

P1 P2

LA R14, CONT1 LA R14, CONT2 ; Load Adress

L1: TS LOCKBYTE L2: TS LOCKBYTE

BE KA BE KA

PASS PASS ; 1 Sek. warten

B L1 B L2

CONT1: ... CONT2: ...

KA: ....

....

MVI LOCKBYTE, X'00' ; LOCKBYTE = 0

BR R14 ; Springe nach CONT1 bzw. CONT2

Kritik:

- Algorithmus ist "unfair", da durch warten mit PASS die Reihenfolge des Betretens des KA zufällig ist - stürzt Task in KA ab ohne Lockbyte zurückzusetzen

=> Endlosschleife für alle nachfolgenden Prozesse

3.5 Interprozeßkommunikation

=> Operationen zur Synchronisation und zum Datenaustausch

zwischen verschiedenen Prozessen.

Kommunikation erfordert:

- Synchronisation (Zeitabstimmung zwischen Sender und Empfänger) - Datenaustausch (Daten als Informationsträger)

3.5.1 Reine Synchronisationsoperationen - Blockieren / Fortsetzen

- Semaphor-Operationen

- allgemeine Belegungs- und Freigabe-Operationen

Mit den Semaphoroperationen P(B) und V(B) bzw. allgemeiner

WARTE (B) und SENDE (B) läßt sich auch die Synchronisation von Prozessen realisieren.

1) Reihenfolgensynchronisation Beispiel:

2 Prozesse Intitialisierung: B := 1

Modul X1 P1

Sende (B)

P2

Warte (B)

Modul X2

Warte auf B = 0 B = 0 ?

B := 1 N

J

2) Gleichlaufsynchronisation

P1 P2

Sende (B2)

Warte (B1)

Modul X1

Sende (B1)

Warte (B2)

Modul X2

3) Reader/Writer - Problem

Prozeß: Lohnberechnung

Prozeß: Urlaubsberechnung

Prozeß: Personaldatenänderung

Personaldaten- datei

schreiben lesen lesen

Zulässig sind:

entweder n Leser

oder 1 Schreiber

type ls_sema = record

sB: boolean;

lA: integer;

sL: list of Prozeßname;

lL: list of Prozeßname;

end;

procedure P_leser(S);

procedure P_schreiber(S);

procedure V_leser(S);

procedure V_schreiber(S);

Strategie 'Schreiber-Vorgang':

TuS(M)

# 0 ? J

N

sB ? J

N lA := lA + 1

Loe(M)

P -> lL Blockiere P und Loe(M) P_leser

TuS(M)

# 0 ? J

N sB ?

J

N

Loe(M)

Blockiere P und Loe(M) N

J

lA = 0 ? P -> sL

sB := true P_schreiber

TuS(M)

# 0 ? J

N

sB ? J

N

Loe(M)

TuS(M)

# 0 ? J

N J

Loe(M) lA := lA - 1

U := 1.P aus sL sB := true

Deblockiere U und Loe(M)

sL leer ? N

sB := false lL leer ? N

U := 1.P aus sL

J

Deblockiere alle P aus lL, lL := leer

und Loe(M)

V_leser V_schreiber

Beispiel: Shared-Private-Disk (SPD)

ZE 1

sB,lA,sL,lL SPD ZE 3

ZE 2

ZE 4

ni Reader mi Writer

- Wo befinden sich sB, lA, sL, lL?

- Wie wird der Zugriff auf sB, lA, sL, lL geschützt?

=> Semaphore auf Platte

Problem: Unteilbarkeit der Operationen (z. B. TuS) -> ohne Hardwareunterstützung nicht möglich

=> E/A Befehle

* Device Reserve: Gerät ist für eine ZE reserviert;

für alle anderen BUSY

* Device Release: Reservierung aufheben

Device Reserve BUSY ? J

N lese Block mit sB, lA, sL, lL

TuS (M)

# 0 ? J

N sB ?

N lA = 0 ? J sB := true

Loe (M)

Device Release Writer ZE

ZE -> sLi N

J

P -> ZE - sL i

Problem: Wie kann eine ZE blockiert werden?

3.5.2 Reiner Datenaustausch

Schreib-/Lesezugriffe auf gemeinsame Speicherbereiche:

- 'Datei-Kopplung': Benutzung gemeinsamer Dateien (s.o.) - Common Memory: Zentralspeicherbereich

Die Speicherverwaltung des Betriebssystems bietet folgende Operationen an:

- Richte Common Memory-Bereich ein (Name, Länge) - Lösche Common Memory-Bereich (Name, Länge)

- Binde Common Memory-Bereich in logischen Adreßraum des Prozesses P ab Adresse x ein

P1 P1

P1

C1

C2 P2

P1

Speicher P1

0 1 2 3 4 5

P2 0

1 2 3 P2

Nach dem Einbinden können Inhalte von C mit üblichen Schreib-/Lesebefehlen erreicht werden.

3.5.3 Datenaustausch mit integrierter Synchronisation 3.5.3.1 Kanäle

Kanäle sind vom Betriebssystem verwaltete Kommunikationsobjekte, die über Namen identifizierbar bzw. adressierbar sind.

Operationen:

- ErzeugeKanal (Name, Kapazität) - LöscheKanal (Name)

- Write (Name, Nachricht) - Read (Name, var Nachricht) - Test (Name, var Leer?)

P1 P4

K1 read

write read

K2

P2

P3

read read

K3 write

write

write

Synchronisation von Kanalzugriffen:

Kanal voll ? J N

Nachricht ablegen

write

J N

read

Kanal leer ?

1. Nachricht entnehmen

- Blockieren des Senders, wenn Kanalkapazität erschöpft (Rückstau).

- Blockieren des Empfängers, wenn keine Nachricht im Kanal verfügbar (Warten auf Nachricht).

Sonderfall: Kanalkapazität = 0

- Kanalobjekt verfügt über keine Pufferkapazität und wird so zur reinen Wartestelle.

- Sender wird blockiert, bis Empfänger empfangsbereit.

- Empfänger wird blockiert, bis Sender sendebereit.

- Nachricht kann ohne Zwischenspeicherung direkt vom Sender zum Empfänger transferiert werden.

Zusätzliche Funktionen:

- Time Outs: maximale Wartezeiten

write (Kanalname, Zeitdauer, Nachricht, var Erfolg) read (Kanalname, Zeitdauer, var Erfolg, var Nachricht)

Nach Ablauf der maximalen Wartezeit, wird die Blockierung beendet, auch wenn keine Nachricht empfangen bzw. gesendet werden konnte. Der aufrufende Prozeß kann dann eine Sonderfallbehandlung durchführen (z. B. Partnerprozeß wurde wegen Laufzeitfehler beendet).

Time-Out-Mechanismen sind immer dann ratsam, wenn auf Unzuverlässigkeitsfaktoren reagiert werden soll!

- Prioritäten: Dringlichkeitsstufen von Nachrichten write (Kanalname, Priorität, Nachricht)

read (Kanalname, var Priorität, var Nachricht)

Die Nachrichten werden im Kanal entsprechend ihrer Priorität einsortiert.

3.5.3.2 Ports

Ports sind Endstellen für Nachrichtenwege, die bei einzelnen Prozessen angesiedelt sind.

Aus Sicht des Prozessors: Tor zum Nachrichtenweg

Aus Sicht des Betriebssystems: Objekt zur Verwaltung eines E/A-Stromes, das einem Prozeß zugeordnet ist.

Operationen:

- ErzeugePort (Name) - LöschePort (Name)

- Verbinde (Name, Portname2 / E/A-Gerätename) - Write (Name, Nachricht)

- Read (Name, var Nachricht)

P1 T1

T3

T2 P1

T5 T4

3.5.3.3 Kombination von Ports und Kanälen

Beispiel: VAX / VMS

Port: Kommunikationsendstelle beim Prozeß (Channel) Kanal: Geräte-/Datei-Charakter (Mailbox)

Ports werden mit Geräten/Kanälen verbunden.

P1 T1

T6

P2 T4

T2 P1 T3

T5 M2

M1

Terminal

Operationen:

- Erzeuge / Lösche Kanal - Binde Port an Gerät / Kanal - Gib an Port aus

- Lies von Port ein

Vorteil:

Anpaßbarkeit bzw. Änderbarkeit von Programmen bezüglich Kommunikationspartnern (Geräte, Dateien, andere Prozesse)

3.5.3.4 Einordnung der Operationen zur Interprozeßkommunikation Synchronisation

Passieren (Semaphor) Verlassen (Semaphor)

Erzeugen / Löschen (Semaphor) Kommunikation

write (Port/Kanal, Nachricht) read (Port/Kanal, var Nachricht) Erzeuge / Lösche (Port/Kanal) Verbinde (Port, Port)

Die Grundoperationen sind im Kern des Betriebssystems, u. U. bei

Prozeßverwaltung, u. U. in einer eigenen Komponente

("Interprozeßkommunikation") angesiedelt.

Die Interprozeßkommunikationsoperationen werden in der Schale auch vom Betriebssystem selbst genutzt.

Beispiel:

E/A-Auftragsabwicklung

P1 T1

Nutzersicht

P1 T1

Treiber- prozeß

TT

phys.

E/A Realisierung

3.5.4 Asynchrone Eingrife in den Ablauf fremder Prozesse (Prozeßinterrupts, Exception-Signale)

3.5.4.1 Laufzeit-Besonderheiten-Behandlung Beispiel:

program test (input, output);

var In, Out: integer;

begin

readln(In);

Out := 1000 / In;

writeln(Out);

end.

Programmablauf:

readln(In);

=> In := 0;

Out := 1000;

Out := Out / In

=====> INTERRUPT: DIVISION DURCH NULL

Analysiere Ursache (Arithmetischer Fehler in P) Auftrag an Fehlerbehandlungsprozeß

Blockiere P

Fehlerbehandlungsprozeß:

Melde Fehler an Dialoggerät von P Beende P

=> Laufzeit-Besonderheit tritt unvorhergesehen auf und führt zum Abbruch des Programms.

- Der Prozeß vereinbart für Besonderheitstyp eine Behandlungsprozedur.

- Das Betriebssystem bewirkt beim Auftreten von Besonderheiten eine Verzweigung in die betreffende Behandlungsprozedur.

im Beispiel:

program Test (input, output);

var In, Out : integer;

procedure DivDurchNull;

begin

Out := -111 end;

procedure Eingabefehler begin

In := 1 end;

begin

Vermerke_als_B_Prozedur (DivDurchNull, 1000); { 1000 = Typ, z. B.

Fehlernr. }

Vermerke_als_B_Prozedur (Eingabefehler, 1005);

readln(In);

Out := 1000 / In;

writeln(Out);

end.

Programmablauf:

readln(In);

=> In := 0 Out := 1000;

Out := Out / In;

====> INTERRUPT-ROUTINE Analysiere Ursache

in P B_Prozedur hierfür vereinbart?

falls ja:

Bewirke Aufruf der B_Prozedur in P und fahre fort falls nein:

Auftrag an Fehlerbehandlungsprozeß blockiere P

Out := -111;

return

writeln(Out);

end.

3.5.4.2 Benutzung des Besonderheiten-Mechanismus, um in fremde Prozesse einzugreifen

- Bestimmte Besonderheits-Typen sind für Interprozeßeingriffe reserviert (z. B. Fehlernummern > 5000).

- Operation, um in fremden Prozessen Besonderheits-Reaktion zu veranlassen:

Signalisiere (Prozeßname, Fehlernummer) Problem:

Eingriffe fremder Prozesse erfolgen asynchron und i. a. unvorhersehbar zum Prozeßablauf.

Beispiel:

program P1;

var B: boolean;

prozedure S6000;

begin

B := true;

end;

begin

B := false;

Vermerke_als_B_Prozedur (S6000, 6000);

...

if B then

writeln ('P2 hat signalisiert!');

end.

program P2;

...

begin

Signalisiere (P1, 6000);

...

end.

Beispiel: BS 2000

Ein Task ist beschrieben durch eine Kette von Teilprozessen:

Task- Leitblock

TCB

Befehlszähler und Kontext aktueller PCB

PCB 1

Befehlszähler und Kontext

Befehlszähler und Kontext

PCB 2 PCB 3

Befehlszähler -> Asynchron-

routine

Beim Zuordnen eines Tasks wird immer der PCB1 auf den Prozessor geladen.

Für Asynchronroutinen werden spezielle PCB's bereitgestellt. Beim Auftreten des zugehörigen Ereignisses wird:

a) falls Prozeß rechnet:

- aktuellen Prozeß-Kontext in PCB abspeichern - PCB x an den Anfang der Kette einhängen - Prozessor aus PCB x laden

b) falls Prozeß nicht rechnet:

- PCB x einhängen

- Prozessor aus PCB x laden z. B. /CANCEL task, KILL

3.6 Prozeßsysteme 3.6.1 Allgemeines

Prozeß:

- aus Betriebssystem-Sicht:

Verwaltungseinheit, Ablaufobjekt

- als Struktureinheit der Nutzerprogrammierung:

* logische Strukturierung

weitgehend selbständiger, in sich abgeschlossener Vorgang, der parallel zu übrigen Vorgängen abläuft und mit ihnen über ausgezeichnete Schnittstellen interagiert.

* Implementierungseinheit

Einkapselung von Code und Daten; externe Schnittstellen werden durch Prozeßkonzept eines Betriebssystems unterstützt:

- prozeßeigene Speicherbereiche und Adreßräume - getrennte Erzeugung

- IPC als Schnittstellenmechanismus Prozeßsystem:

System aus zum Zweck der Kooperation interagierenden Prozessen.

Vorteile der Realisierung einer Anwendung als Prozeßsystem:

- Änderungsfreundlichkeit, Konfigurierbarkeit

- problemnahe Systemstruktur bei nebenläufigen Vorgängen - durch IPC-Mechanismus der Betriebssystems wohldefinierte

Schnittstellendisziplin

Vereinfachtes Beispiel:

Lager-Steuerung

Bereich: Realzeitdatenverarbeitung für ein hierarchisches Prozeßsystem

Aus einem Regal soll ein Greifer Gegenstände in einen Korb legen. Der Greifer befindet sich auf einem Gestell, das in x- und y-Richtung bewegbar ist. Der Greifkopf ist ebenfalls beweglich.

Problemebenen:

Gesamtauftragsabwicklung - Bedienerdialog

- Kontrolle des technischen Prozesses zum Stücktransport

* x-Bewegung

- Motoransteuerung - Meßfühleransteuerung

* y-Bewegung

- Motoransteuerung - Meßfühleransteuerung

* Greifer-Bewegung

- Motoransteuerung - Meßfühleransteuerung Prozeßsystem zur Lager-Steuerung

P: Auftragsabwicklung

P: E/A P: Fachverwaltung

E/A Suche,

Aktualisierung

P: Stücktransport Transport-

aufträge, Quittungen

Px Py Pgreifer

Bewegungs- aufträge,

Quittungen Bewegungs-

aufträge, Quittungen

Bewegungs- aufträge, Quittungen

Mx Motor- steuer- signale

Sx Positions-

fühler- signale

Motor- steuer- signale

Positions- fühler- signale

Motor- steuer- signale

Positions- fühler- signale

My Sy Mg Sg

Die Parallelarbeit von P_x , P_y und P_Greifer wird durch PStücktransport koordiniert.

PAuftragsabwicklung koordiniert PE/A ,PStücktransport ,PFachverweis

Vereinfachtes Beispiel für ein Prozeßsystem aus gleichgeordneten Prozessen:

Auftragsbearbeitung

Sachbearbeiter P: A1

Sachbearbeiter Sachbearbeiter

P: A2 P: A3

P: Auftragsabwicklung

P: Einkauf Aufträge

Familie gleichartiger Prozesse zur Auftragsannahme

P: Versandabwicklung P: Lagerverwaltung

Anfragen Reservierungen

P: Abrechnung

Konventionelle Struktur:

Sachbearbeiter; Informationsfluß zwischen Sachbearbeitern kann auf rechnergestützte Lösung weitgehend übertragen werden.

Kontroll- und Koordinationsfunktionen sind über alle Mitglieder des Prozeßsystems verteilt.

3.6.2 Interaktionsmuster

Auf der Basis der Standard-IPC-Operationen, z. B. write (IPC-Kanal, ...), read (IPC- Kanal, ...) sind je nach Einbettung die verschiedenartigsten logischen Interaktionsmechanismen realisierbar.

3.6.2.1 Monitor

Abstrakte, geteilte Datenstruktur, deren Zugriffsoperationen implizit nach dem Prinzip des gegenseitigen Ausschlusses synchronisiert werden.

Problemnahes Konzept zur Kommunikation über gemeinsame Daten:

zugreifende Prozesse

P1 P2 P3

Datenstruktur

Zugrifsoperationen Monitor

Aufruf / Rückkehr der Zugriffsoperationen

Monitor:

- Einkapselung der Daten -Synchronisation der Zugriffe

3.6.2.2 Dienstleistungsprozeß Beziehung zwischen 2 Prozessen:

Auftraggeber vergibt spezifische Aufträge an Auftragnehmer (Dienstleister), der nur für die Abwicklung solcher Aufträge ausgelegt ist.

Auftraggeber

Dienstleister Auftrags-

beschreibung

Rück-

meldung

Zeitablauf:

Auftraggeber Dienstleister

.... ...

sende Auftrag ...

---> übernehme Auftrag

... führe Auftrag aus

... ...

erwarte Rückmeldung <--- quittiere Rückmeldung

... ...

Sonderfälle:

- ohne Rückmeldung - nur Rückmeldung

3.6.2.3 Sekretär

Dienstleister für eine Menge unterschiedlicher Auftragstypen.

3.6.2.4 Team

Prozeßmenge, die insgesamt die Aufgabe eines Sekretärs oder eines Dienstleisters erfüllt.

1) Symmetrisches Team

gemeinsame Auftragsschlange

Menge gleichartiger Dienstleistungsprozesse:

Parallelabwicklung von Aufträgen

2) Spezialistenteam

gemeinsame Objekte

- Unterschiedliche Dienstleistungsprozesse für spezielle Auftragsklassen - Auftragsabwicklung bedingt Kooperation der Teammitglieder über IPC

oder geteilte Objekte

2.6.2.5 Rendez-Vous-Interaktion

P1: P2:

... ...

sende Daten <-- Gleichlauf --> erwarte Daten

erwarte Bestätigung sende Bestätigung

... ...

2.6.2.6 Alternierung (Erzeuger-Verbraucher-Beziehung) Abwechselnde gegenseitige Abhängigkeit zweier Prozesse:

P1 P2

erzeuge X1 verbrauche X1

erwarte Bestätigung X1 bestätige X1

erzeuge X2

erwarte Bestätigung X2

verbrauche X2

bestätige X2

Verallgemeinerung:

Pufferung: - Wechselpuffer - Ringpuffer 2.6.2.7 Gleichläufer

Zwei Prozesse P1 und P2 sollen ihren Abschnitt A1 bzw. A2 erst betreten, wenn der ander Prozeß den vorangegangene Abschnitt V1 bzw. V2 verlassen hat.

P1 P2

V1 V2

Sende X1

Erwarte X2 Sende X2

Erwarte X1

A1 A2

Synchronisation

3.6.3 Parallelisierung

Konzepte zur Einführung von Parallelarbeit.

Gegeben: Prozeß P, der einen Algorithmus A (mit Wartezeiten) sequentiell ausführt.

A

Prozeß P Algorithmus A

Warte

Warte

Externe Paralellität:

Paralelle Überlagerung des Gesamtalgorithmus

_ _ _ P1: | P2: | P3: | A A A

| | | --- --- ---

Interne Paralellität:

Paralelle Überlagerung von Teilalgorithmen

_

P1: |

AT1

---+---+--- | | |

AT2 AT3 AT4 | | |

---+---+---

AT5 | ---

3.6.3.1 Externe Parallelität

=> Paralelle Überlagerung des Gesamtalgorithmus 1) Mehrfachaktivierung

Statt eines Prozesses werden mehrere gleichartige Prozesse aktiviert.

Gesamtzeit t = tAuftrag + tVerteilung + tSynchronisation (für n-Prozessor-System)

Beispiel: Symmetrisches Team von Dienstleistungsprozessen

gleichartige Dienstleistungsprozesse gemeinsame Auftragsschlange

2) Pipelining - Fließbandprinzip

Ein Auftrag kann ein eine Sequenz von n Teilaufträgen gegliedert werden.

Anstelle eines Prozesses bearbeiten n Spezialisten die einzelnen Teilaufträge.

Auftrag annehmen

A

B

C

Bestätigen

P: Auftrag

annehmen

A

Auftrag weitergeben

PA:

Auftrag annehmen

B

Auftrag weitergeben

Auftrag annehmen

C

PB:

PC:

Bestätigen

3.6.3.2 Interne Parallelität

=> Parallele Überlagerung von Teilalgorithmen 1) Auslagerung eines Teilalgorithmus

Der Prozeß lagert einen Teilalgorithmus aus seiner Algorithmusfolge aus.

Es liegt allerdings keine echte Parallelität vor, wenn nachfolgende

Teilalgorithmen Ergebnisse von dem ausgelagerten Teilalgorithmus benötigen.

Beispiel:

P A B C

P A

B C

P1

aus: wird:

Echte Parallelität liegt vor, wenn Ergebnisse aus B erst später benötigt werden (z. B. durch Verschieben der Ergebnissynchronisation):

P 1 C1

Verschieben der Ergebnissynchronisation

2) Mehrfache Parallelität

Es werden mehrere Teilalgorithmen ausgelagert und die Ergebnissynchronisation entsprechend verschoben.

Gabelung: Auslagerung der Teilalgorithmen Vereinigung: Rückkehr der Teilalgorithmen

3) Auftragspuferung

Der Prozeß setzt in einer Schleife eine Folge von Aufträgen an

einen Dienstleistungsprozeß ab.

sende Auftrag erwarte Bestätigung

erwarte Auftrag sende Bestätigung

D:

P:

P D

t

Zweifache Pufferung ermöglicht Parallelarbeit:

sende 1. Auftrag

erwarte Bestätigung

erwarte Bestätigung

sende nächsten Auftrag P

D P:

n-fache Pufferung gleicht variierende Bearbeitungszeiten aus:

erwarte Bestätigung

sende nächsten Auftrag P D P:

sende (n-1) Aufträge

erwarte (n-1) Bestätigungen

t

3.6.3.3 Prozeßinterne Auftragsumschaltung Parallele Auftragsabwicklung:

- Mehrfachaktivierung - Pipelining

=> gegenseitige zeitliche Entkoppelung von Aufträgen

=> echte Parallelität bei Mehrprozessor-Maschine

auf Kosten von:

- IPC-Aufwand

- Aufwand zur Verwaltung mehrerer Prozesse - Prozeß-/ Prozessorumschaltungen

Keine echte Parallelität, aber die gegenseitige zeitliche Entkopplung von Aufträgen ist u. U. günstiger durch prozeßinternes Umschalten zwischen Teilaufträgen erreichbar.

Beispiel:

Aufträge bestehend aus Unteraufträgen A, B

P1 P2 P3 P4 Team,

z. B. Datei-Treiber

Spezialisten, z. B. Platten-Treiber

DA DB

PL1 PL2

Aufträge bestehend aus Unteraufträgen A, B

Spezialisten, z. B. Platten-Treiber

DA DB

PL1 PL2

ein einziger Dateitreiber, der gleichzeitig mehrere Aufträge bearbeitet

Struktur der Prozesse

warte auf Auftrag setze Unterauftrag A ab warte auf Rückmeldung setze Unterauftrag B ab warte auf Rückmeldung melde Auftragsabwicklung an Aufrufer zurück Pi:

warte auf Auftrag oder Rückmeldung von Unterauftrag

verzweige entsprechend Auftrag / Unterauftragsrückmeldung

setze Unterauftrag B ab

setze Unterauftrag A ab melde an Aufrufer zurück

P:

Ablauf eines Auftrags:

- Unterauftrag A - Unterauftrag B - Rückruf an Aufrufer