BT Formelsammlung WS2002/2003 Index: Beschreibung: Seite: 1

BT Formelsammlung WS2002/2003

Index: Beschreibung: Seite:

1

^FAT

2

2

^iNode

4

3

Monoprozessorsystem – Prioritätssteuerung – SRTF – SJF – SRTN – Robin-Hood

6 3.1

Definition - Formel – Mittlere Wartezeit – Mittlere Verweildauer - GANT

10

4

Prozessgeschehen - Theorie

11

5

Prozesse & Betriebsmittel (Bankiers-Algorithmus):

13

5.1

Formeln zu Prozesse & Betriebsmittel

17

5.2

Theorie - Deadlocks

18

6

Binäres Buddy-System

19

7

FIFO(First In First Out) – LRU(Last Recently Used) – Optimale Ersetzung -

Speicherverwaltung

20

7.1

Speicherverwaltung – Adressierung – Theorie

22

7.2

Speicherverwaltung – Formeln

23

7.3

Aufgaben – Größe – Breite – Seitentauschrate – krititsche Schranke

24

8

Semaphoren – Theorie – kritische Abschnitte

26

9

UNIX Programme – Fragen zu C-Code:

27

10

UNIX Programme - Semaphoren

29

11

UNIX Programme - Pipes

32

Was in der Prüfung WS02/03 dran war ist mit *** gekennzeichnet!

- Zusätzlich das Möchnproblem mit 5 Mönchen, - Unix A – Auftraggeber zu 2 Server S1 & S2:

Wieviele Pipes sind minimal und von wem erzeugt?

Kompl. Code struct RESULTAT gegeben…

1. FAT:

z.B. FAT (Clustergröße 2KB = 4 Sektoren zu je 512Bytes):

Nr=0 1 2 3 4 5 6 7 8 9 10 11 12

Res. Res. EOF 2 12 11 8 frei 9 EOF EOF 10 3

Dateikatalog (root):

Name A AA AAA

Startcluster 4 5 6

Antwort:

Cluster A 4 12 3 2 EOF

Cluster AA 5 11 10 EOF

Cluster AAA 6 8 9 EOF

Ist die FAT in Ordnung?

Ja, da kein Cluster von den 3 Dateien gleichzeitig benötigt wird. Außerdem existieren keine verlorenen Cluster. Der Cluster Nr. 7 ist frei. ?????????

Die Datei AA wird versehentlich gelöscht. Können die Inhalte noch gerettet werden?

Beim Löschen werden die Cluster freigegeben. Das löschen ist nur bedingt möglich, nur durch Spezialverfahren.

Hat die Datei AA eine Größe von mindestens 7900Bytes?

Wenn ja: wie kann das Byte mit dem Offset 7900 in der Datei auf dem Datenträger gefunden werden?

Datei AA = 3 Cluster -> 3*Cluster -> 3* (4*512Bytes) -> 6144 Bytes

Dateisystem nach Optimierung?

Nr=0 1 2 3 4 5 6 7 8 9 10 11 12

Res. Res. 3 4 5 EOF 7 8 EOF 10 11 EOF frei

Dateikatalog (root):

Name A AA AAA

Startcluster 2,3,4,5 6,7,8 9,10,11

z.B. FAT (Clustergröße 2KB = 4 Sektoren zu je 512Bytes):

Nr=0 1 2 3 4 5 6 7 8 9 10 11 12

Res. Res. EOF EOF 7 12 9 3 frei EOF 2 10 11

Dateikatalog (root):

Name A B C

Startcluster 4 5 6

Antwort:

Cluster A 4 7 3 EOF

Cluster AA 5 12 11 10 2 EOF

Cluster AAA 6 9 EOF

Ist die FAT in Ordnung?

Nein, da Cluster 8 in keiner Kette hängt (frei)???????????

Die Datei A wird versehentlich gelöscht. Können die Inhalte noch gerettet werden?

Dateisystem nach Optimierung?

Nr=0 1 2 3 4 5 6 7 8 9 10 11 12

Res. Res. 3 4 EOF 6 7 8 9 EOF 11 EOF Frei

Dateikatalog (root):

Name A AA AAA

Startcluster 2,3,4 5,6,7,8,9 10,11

Nennen Sie 2 Nachteile des FAT-orientierten Dateisystems:

- Fehleranfällig (z.B. Virus in Tabelle), - Fehlerwirkbreite hoch,

- Größenbeschränkung Festplatte.

2. iNode:

In Unix werden die Attribute einer Datei in einem iNode (außer der Inhalt) zusammengefasst. Wieso treibt man diesen Aufwand, wenn man – ähnlich wie bei DOS – die Attribute auch gleich in den Katalog übernehmen könnte?

Vorteile:

- schnell für kleine & große Dateien, - niedrige Fehlerwirkbreite.

Da mehrere Dateien die gleiche Beschreibung besitzen können (kopie-> nur Namen unterschiedlich) muss die Beschreibung nur einmal gespeichert werden.

Gegeben ist ein iNode unter Unix mit 10 direkten Einträgen (32-Bit-Blocknummer) für Blöcke und jeweils einem Eintrag für einfach, zweifach bzw. dreifach indirekte Blöcke. Die Größe eines Blockes beträgt 2048Bytes. Wie können die Bytes in der Datei mit den Offset 6135 sowie 974850 gefunden werden? (Nummerierung der Bytes ab 0)

32-Bit-Blocknummer 4 Byte

Blockegröße beträgt 2048Bytes 512 Adressen pro Block 10 Adressen im festen Block

512 Adressen im 1. indirekten Block 512 * 512 Adressen im 2. indirekten Block

6135 – 10 –512 = 5613 10 fester Block und 1. indirekter Block voll 5613 / 512 = 10 die ersten 10 Blöcke voll

5613 – 10 * 512 = 493 im 11. Block an der Stelle 493

Blockgröße: 2048 Bytes, Blocknummer 0…9 -> direkter Block:

10…10 +2048

+2048 * 2048 -> Die Datei mit dem Offset 6135 befindet sich im 2. indirekten Block an der Stelle 6125.

Blocknummer 0…9 10…10 +2048

+2048 * 2048 -> Die zweite Datei befindet sich ebenfalls im 2. indirekten Block an

Gegeben ist ein iNode unter Unix mit 10 direkten Einträgen (32-Bit-Blocknummer) für Blöcke und jeweils einem Eintrag für einfach, zweifach bzw. dreifach indirekte Blöcke. Die Größe eines Blockes beträgt 512Bytes. Wie können die Bytes in der Datei mit den Offset 1561, 3657 sowie 67041

gefunden werden? (Nummerierung der Bytes ab 0) Blockgröße: 512 Bytes,

Blocknummer 0…9 -> direkter Block:

10…10 +512

+512 * 512 -> Die Datei mit dem Offset 1561 befindet sich im 2. indirekten Block an der Stelle 1551.

Blocknummer 0…9 10…10 +512

+512 * 512 -> Die zweite Datei befindet sich ebenfalls im 2. indirekten Block an der Stelle 3647.

Blocknummer 0…9 10…10 +512

+512 * 512 -> Die zweite Datei befindet sich ebenfalls im 2. indirekten Block an der Stelle 67031.

3. Monoprozessorsystem – Prioritätssteuerung – SRTF – SJF – SRTN – Robin-Hood – GANT:

Prozeß: Ankunftszeit / Start: Zeitbedarf: Priorität:

P1 10 40 1

P2 20 30 3

P3 30 20 4

P4 0 60 2

(Priorität 4 = höchste) Reine Prioritätssteuerung:

0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160

P1 X X X X

P2 X X X

P3 X X

P4 X X X X X

Mittlere Wartezeit =

75

4 300 4

100 ) 30 50 ( ) 20 70 ( ) 10 140

(

− + − + − + = =

SJF – Es rechnet immer der Prozeß mit der geringsten Restlaufzeit = eigene Laufzeit – bisherige eigene Laufzeit.

Bei Gleichheit: Es rechnet der zuletzt gestartete Prozeß (Startzeit = Ankunftszeit):

0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160

P1 X X X X

P2 X X X

P3 X X

P4 X X X X X X

Mittlere Wartezeit =

77 , 5

4 310 4

150 ) 30 50 ( ) 20 70 ( ) 10 100

(

− + − + − + = =

Prozeß: Ankunftszeit / Start: Zeitbedarf: Priorität:

P1 0 50 1

P2 30 30 4

P3 20 30 3

P4 10 50 2

(Priorität 4 = höchste) Reine Prioritätssteuerung:

0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160

P1 X X X X X

P2 X X X

P3 X X X

P4 X X X X X

Mittlere Wartezeit =

90

4 360 4

) 10 120 ( ) 20 80 ( ) 30 60 (

160

+ − + − + − = =

SJF – Es rechnet immer der Prozeß mit der geringsten Restlaufzeit = eigene Laufzeit – bisherige eigene Laufzeit.

Bei Gleichheit: Es rechnet der zuletzt gestartete Prozeß (Startzeit = Ankunftszeit):

0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160

P1 X X X X X

P2 X X X

P3 X X X

P4 X X X X X

Mittlere Wartezeit =

85

4 340 4

) 10 160 ( ) 20 50 ( ) 30 80 (

110

+ − + − + − = =

*** mit anderen Werten (Robin mit 5 Zeiteinheiten)

In einem Einprozessorsystem treffen die Prozesse P1 , P2 , P3 und P4 zu den angegebenen (relativen) Zeiten ein und stehen zur Bearbeitung an.

Anmerkung: Die Angabe relative Zeiten sollte in der Prüfung erfragt werden was gemeint ist. Ich habe mit absoluten Zeiten ab Zeitpunkt 0 gerechnet. Es war vermutlich aber gemeint P3 trifft 1 Einheit nach P2 ein.

Die Zeit für eine Verdrängungsprüfung beträgt 0.1 Zeiteinheiten.

Ein Prozeßwechsel kostet zusätzlich 0.2 Zeiteinheiten.

a. Welche der 3 Strategien:

- feste Prioritäten mit Verdrängung

(Verdrängungsprüfung jeweils beim Eintreffen eines Prozesses; 10 beste 0 schlechteste Priorität) - SRTF (Verdrängungsprüfung bei Eintreffen eines Prozesses)(Shortest Remaining Time First) - Round Robin mit Zeitscheibe 2 Zeiteinheiten (Anmerkung: RR ohne Prioritäten)

liefert das beste Ergebnis, wenn jeweils die mittlere Wartezeit minimiert werden soll.

Geben Sie diese jeweils an.

Entwerfen Sie eine Strategie die ein noch besseres Ergebnis liefert als die in a. genannten FCFS = First come First Served (mit Verdrängung wenn neuer Prozess eintrifft)

Î kurze Wartezeit= Fragestellung (!! aber lange Verweilzeit = war aber nicht gefragt !!)

3.1 Definition - Formel – Mittlere Wartezeit – Mittlere Verweildauer:

Definitionen:

Reine Priorität:

SJF „Shortest Job First“

SRTF „Shortest Runtime First“

Round Robin Mittlere Wartezeit:

ozessoren Der

Anzahl

zeit START Bedarf

mWZ CPU

Pr _ _

∑

^{− − −}

=

Mittlere Verweildauer:

ozessoren Der

Anzahl

zeit END Bedarf

mWZ CPU

Pr _ _

∑

^{− − −}

=

4. Prozessgeschehen - Theorie:

In bestimmten Varianten des BS Unix wird die Priorität von Prozessen dynamisch ermittelt. Hierzu hat jeder Prozess in seinem TCB Felder für das gemittelte Maß an CPU-Belegung sowie einen Zähler für die aktuelle CPU-Belastung. Zur Ermittlung der aktuellen CPU-Belegung wird das

Prozessgeschehen n-mal pro Sekunde abgetastet (Möglicher Wert für n z.B. 60). Wird ein Prozess rechnend angetroffen, so wird der für ihn vorgesehene Zähler erhöht. Nach Ablauf einer jeden Sekunde wird aus dem Wert dieses Zählers sowie dem Wert der vorherigen CPU-Belegung die neue CPU-Belegung ermittelt. Diese neue CPU-Belegung hat Einfluss auf die Priorität des Prozesses:

Hohe CPU-Belegung führt zu einer Erhöhung des Priorität, niedere zu einer Verringerung (Vorsicht:

Niederpriore Prozesse haben Vorrang).

Warum treibt man diesen Aufwand, wenn man die Priorität auch einfach statisch vergeben könnte?

- Damit niederpriore Prozesse auch mal rechnen dürfen.

Warum lässt man in die Ermittlung der neuen CPU-Belegung auch noch alte CPU-Belegung einfließen? Würde es nicht reichen, nur die über den Zähler gefundene aktuelle Belegung zu benutzen?

- Damit ein Gesamtbild über die Prozessaktivitäten erstellt werden kann.

- Somit wird eine Gerechtere Priorisierung erreicht.

*** mit 1,5*(…)

Eine Prozeßumschaltungsstrategie arbeitet mit dynamischen Prioritäten und Verdrängung. Das Rechenzeitverhalten eines Prozesses wird mittels einer sogenannten Mikrozeitscheibe beurteilt.

Diese Zeitscheibe wird nach folgender Formel berechnet.

T(MS) = 2*(Zeit(Start letzte E/A) – Zeit (Ende vorletzte E/A))

Anmerkung: (entspricht doppeltem der tatsächl. Vorher gebrauchten Rechenzeit)

Beim Zuordnen eines Prozesses wird ein “Wecker” mit der Größe der Mikrozeitscheibe aufgezogen.

Was sagt ein Mikrozeitscheibenauslauf über das Verhalten des Prozesses aus?

Anmerkung: Zeitsscheibenauslauf bedeutet daß die Zeitscheibe voll genutzt wurde und nun eine Verdrängungsprüfung erfolgen muß.

Diese Zeitscheibenrechnung ermittelt den CPU Bedarf der Prozesse indem es die effektiv genutzte Rechenzeit zwischen den Prozesswechseln (hervorgerufen durch E/A operationen) verbraucht wurde.

Bei dieser Formel wird durch das 2*(...) das doppelte der bisher eigentlich benötigten CPU-Zeit zur Verfügung gestellt. D.h. Ein Prozess der vor Ablauf der Zeitscheibe fertig ist war entweder sehr kurz oder hat blockiert wegen einer E/A-Funktion.

Wenn die Zeitscheibe allerdings ausläuft also das System den Prozess unterbrechen muß hat der Prozess in dieser Zeit keine E/A-Operationen durchgeführt und nur gerechnet. Somit müßte bei wiederholtem Auftreten dieses Effektes evt. Die Zeitscheibengröße angepasst werden weil der Prozess nun allgemein möglicherweise weniger E/A-Operationen durchführt.

Der Prozess hat nach Ablauf des Zeitintervalls bereits doppelt so lange gerechnet, wie im Intervall davor, welches durch IO-Aktivitäten begrenzt war. Der Prozess hatte zuletzt weniger E/A Aktivität (Prozesswechsel) und rechnet nun mehr.

Daraus folgt Zeitscheibenauslauf.

Wie sollte das Betriebssystem Ihrer Meinung nach auf den Mikrozeitscheibenauslauf Reagieren?

(Standardreaktion: Verdrängungsprüfung->nächsten Prozess starten).

Da offensichtlich mehr Rechenzeit benötigt wird sollte das Betriebssystem prüfen ob bei allen Prozessen die E/A Aktivitäten zurückgegangen sind und damit eine Vergrößerung der Zeitscheibe angebracht wäre, um den Prozesswechsel-Overhead zu verringern.

Zwischen die Rechenintensiven Prozesse sollten E/A lastige Prozesse geschoben werden damit die während der Rechenzeit der anderen Prozesse ihre E/A-Zugriffe (z.B langsame Plattenzugriffe) vorbeireiten/durchführen können.

Das würde die System-Effektivität erhöhen Alternaive I:

E/A -intensive Prozesse dazwischen schieben Alternative II:

Bei Rechenintensiven Prozessen ändert sich die Größe der Zeitscheibe nicht mehr Häufige Prozesswechsel verursachen aber unötigen Overhead daher sollte das Betriebssystem die Zeitscheibe vergrößern.

Eine Variante der Strategie “Round Robin” besteht darin, einen Prozeß, der eine volle Zeitscheibe verbraucht hat, ans Ende der Warteschlange zu setzen, einen Prozeß der nur die Hälfte verbraucht in die Mitte usw.

Was bezweckt dieses Verhalten?

Wenn ein Prozess vor dem Ende der Zeitscheibe einen Prozesswechsel verursacht dann ist er entweder zu Ende oder hat eine E/A Operation gestartet.

Durch die häufigere Zuteilung von Rechenzeit an E/A intensive Prozesse ( z.B. Interaktive Programme wie Telnet ) wird die reaktionszeit auf Ein-/Ausgaben verbessert was dem Benutzer entgegen kommt der nicht vor dem Bildschirm wauf Reaktionen zu lange warten muß.

Das Reaktionsverhalten E/A-intensiver Prozesse verbessert sich, da sie mehr Rechenzeit zugeteilt bekommen. rechenintensive Prozesse kommen nun seltener zum Zug.

(Gefahr der Ausgrenzung von Rechenintensiven Prozessen ) -> bessere mWZ

-> bessere Auslastung der CPU (keine E/A-Prozesse zum Schluß aufheben) -> bei RR nicht der Fall

Manche Unix-Systeme: Die CPU wird max. 1sek. Vergeben: In dieser Zeit wird das

Prozessgeschehen 60x abgetastet (Zeittakt). Für jeden Prozess gibt es einen Zähler CPU. Dieser Zähler wird bei jedem der oben aufgeführten Zeittakte (d.h. 60x pro Sek.) erhöht.

Nach 1Sek. Wird CPU = CPU / 2 gesetzt...

Dannach: Dynamische Priorität = Statische Priorität + CPU / 2

Geben Sie die Werte für Felder CPU sowie die dynamische Priorität für die Prozesse A, B bzw. C mit den statische Prioritäten 40, 50 bzw. 30 nach jeweils 1Sek., 2Sek. & 3Sek. an.

Welcher Prozess erhält die CPU?

0Sek. 1Sek. 2Sek. 3Sek.

A 40 ---Ready--- 40

40 ---Run--- 40

75 *1---Ready--- 75

67 *2 CPU = 0 0

0

0 60

30 30

15 B 50 ---Ready---

50

50 ---Ready--- 50

50 ---Run--- 50 75 *1 CPU = 0 0

0

0 0

0 60

30 C 30 ---Run--- 30 75 *1---Ready---

75

67 *2---Ready--- 67

63 *3 CPU = 0 0

60

30 30

15 15

7

Zur Berechnung:

*1: 60 + (30/2) = 75,

*2: 60 + ((30/2)/2) = 67,5 ≈ 67,

*3 60 + (((30/2)/2)/2) = 63,75 ≈ 63.

Nach 3Sek. erhält Prozess B die CPU! ?????????? nicht doch eher C????

5. Prozesse & Betriebsmittel (Bankiers-Algorithmus):

In einem System gibt es vier Prozesse P1,P2,P3,P4 & vier verschiedene Betriebsmittel M1,M2,M3,M4 von denen jeweils 10 Exemplare vorhanden sind. Zu einem Zeitpunkt belegt:

P1 3 Exemplare von M1, und je 2 Exemplare von M2, M3 & M4.

P2 belegt 1 Ex. von M1 & M2, 3 Ex.von M3 sowie 1 Ex.von M4.

P3 belegt je 1 Ex.von M1 & M3 sowie 2 Ex.von M2 & M4.

P4 belegt je 1 Ex.von M1, M2, M3 und M4.

P1 benötigt noch 5 Exemplare von M1, 4 Ex. von M2, 1 Ex. von M3 und 2 Ex. von M4.

P2 benötigt noch 3 Ex. von M1, 3 Ex. von M2, 1 Ex. von M3 und 4 Ex. von M4.

P3 benötigt noch 2 Ex. von M1, 2 Ex. von M2, 2 Ex. von M3 und 8 Ex. von M4.

P4 benötigt noch 1 Ex. von M1, 2 Ex. von M2, 4 Ex. von M3 und 6 Ex. von M4.

Erstellen Sie die für die Verklemmungsanalyse mit dem Bankiers-Algorithmus benötigten Matrizen.

Belegte BM Noch ausstehende BM

M1 M2 M3 M4 M1 M2 M3 M4

P1 3 2 2 2 P1 5 4 1 2 12

P2 1 1 3 1 P2 3 3 1 4 11

P3 1 2 1 2 P3 2 2 2 8 14

P4 1 1 1 1 P4 1 2 4 6 13

-> 6 6 7 6

-> frei 4 4 3 4 (Summe der belegten BM – vorhandene BM = freie BM)

Protokollieren Sie hier die Lage nach der ggfs. Möglichen Aktivierung eines Prozesses (Zuteilung & Freigabe):

Vorgehensweise:

- Summe der belegten BM errechnen,

- Summe der freien BM errechnen (belegte BM – vorhandene BM = freie BM), - Summe der noch ausstehenden BM errechnen,

- Abarbeitung nach kleinsten noch ausstehenden BM…

Belegte BM? Freie BM?

Ausgangslage (6, 6, 7, 6) (4, 4, 3, 4) Nach Prozess P2 (5, 5, 4, 5) (5, 5, 6, 5) Nach Prozess P1 (2, 3, 2, 3) (8, 7, 8, 7) Nach Prozess P4 (1, 2, 1, 2) (9, 8, 9, 8) Nach Prozess P3 (0, 0, 0, 0) (10, 10, 10, 10) Am Ende (0, 0, 0, 0) (10, 10, 10, 10)

Ist das System in einem sicheren Zustand?

Def.: Sicher, wenn es eine Reihenfolge der Zuteilungen gibt, mit der alle Anforderungen erfüllt werden können. Algorithmus gleich 1.

Î

Ja, das System ist sicher!

In einem System gibt es vier Prozesse P1,P2,P3,P4 & vier verschiedene Betriebsmittel M1,M2,M3,M4 von denen jeweils 4,4,6 bzw. 8 Exemplare vorhanden sind. Zu einem Zeitpunkt belegt:

P1 1 Exemplare von M1, und je 2 Exemplare von M2.

P2 belegt 2 Ex. von M1 & M3, sowie 4 Ex.von M4. P3 belegt 2 Ex.von M2 sowie 2 Ex.von M4.

P4 belegt 1 Ex.von M3.

P1 benötigt noch 3 Exemplare von M1, je 2 Ex. von M2,M3 & M4.

P2 benötigt noch 1 Ex. von M1 & M3 sowie 2 Ex. von M4.

P3 benötigt noch 2 Ex. von M2, 3 Ex. von M3, 6 Ex. von M4.

P4 benötigt noch 1 Ex. von M1, je 2 Ex. von M2 & M3 sowie 4 Ex. von M4.

Erstellen Sie die für die Verklemmungsanalyse mit dem Bankiers-Algorithmus benötigten Matrizen.

Belegte BM Noch ausstehende BM

M1 M2 M3 M4 M1 M2 M3 M4

P1 1 0 2 0 P1 3 2 2 2 9

P2 2 0 2 4 P2 1 0 1 2 4

P3 0 2 0 2 P3 0 2 3 6 11

P4 0 0 1 0 P4 1 2 2 4 9

-> 3 2 5 6

-> frei 1 2 1 2 (Summe der belegten BM – vorhandene BM = freie BM)

Protokollieren Sie hier die Lage nach der ggfs. Möglichen Aktivierung eines Prozesses (Zuteilung & Freigabe):

Belegte BM? Freie BM?

Ausgangslage (3, 2, 5, 6) (1, 2, 1, 2) Nach Prozess P2 (1, 2, 3, 2) (3, 2, 3, 6) Nach Prozess P1 (0, 2, 1, 2) (4, 2, 5, 6) Nach Prozess P4 (0, 2, 0, 2) (4, 2, 6, 6) Nach Prozess P3 (0, 0, 0, 0) (4, 4, 6, 8) Am Ende (0, 0, 0, 0) (4, 4, 6, 8)

Ist das System in einem sicheren Zustand?

Î

Ja, das System ist sicher!

In einem System besteht folgender aktueller Zustand:

- Von den Betriebsmitteln M1, M2 & M3 sind insgesamt jeweils 15 Exemplare verfügbar, - Der Prozess P1 belegt 3Ex. von M1 & 6Ex. von M2.

Seine Gesamtforderungen betragen 3Ex. von M1, 9Ex. von M2 & 0Ex. von M3, - Der Prozess P2 belegt 3Ex. von M1 & 6Ex. von M3.

Seine Gesamtforderungen betragen 3Ex. von M1, 12Ex. von M2 & 6Ex. von M3.

Erstellen Sie die für die Verklemmungsanalyse benötigten Vektoren und Matrizen!

( 15 , 15 , 15 )

erfügbar =

V ;



 



=

6 0 0 6 3 3

elegt

B ;



 



=

6 0 12 9 3 3

rung esamtforde

G

->





 



=



 





−

−

−

−

−

= −

0 0 12

3 0 0 6 6

0 0 0 12

6 9 3 3

3 3

ustehend

A

-> F

_orderung =

( 15

−

( 3

+

3 ) 15

−

( 6

+

0 ) 15

−

( 0

+

6 ) ) (

=

9 9 9 )

Warum befindet sich das System in einem sicheren Zustand?

(

0 3 0

) (

9 9 9

)

1 ≤F → ≤

A

-> P1 kann abgearbeitet werden!

->

F =F+B₁

->

F =

(

9+3 9+6 9+0

) (

= 12 15 9

) (

≥ 0 12 0

)

= A₂

-> P2 kann abgearbeitet werden!

Î

Es gibt eine Möglichkeit, dass die Prozesse abgearbeitet werden können,

Î

Sicherer Zustand!

Der Prozess P2 fordert nun 7Ex. von M2. Bleibt das System in einem sicheren Zustand, wenn diese Anforderung gewährt wird?

( 15 , 15 , 15 )

erfügbar =

V ;





 



=

6 0 7 6 3 3

elegt

B ;





 



=

6 0 12 9 3 3

rung esamtforde

G

->





 



=



 





−

−

−

−

−

= −

0 0 5 3 0 0 6 6

0 0 7 12

6 9 3 3

3 3

ustehend

A

-> F

_orderung =

( 15

−

( 3

+

3 ) 15

−

( 6

+

7 ) 15

−

( 0

+

6 ) ) (

=

9 2 9 ) (

0 3 0

) (

9 2 9

)

1 ≥F → ≥

A

-> P1 kann NICHT abgearbeitet werden!

(

0 5 0

) (

9 2 9

)

2 ≥F → ≥

A

-> P2 kann NICHT abgearbeitet werden!

Î

Das System wird unsicher -> nicht zuweisen!

*** genau so

In einem System besteht folgender aktueller Zustand:

- Von den Betriebsmitteln M1, M2 & M3 sind insgesamt jeweils 10 Exemplare verfügbar, - Der Prozess P1 belegt 2Ex. von M1 & 4Ex. von M2.

Seine Gesamtforderungen betragen 2Ex. von M1, 6Ex. von M2 & 0Ex. von M3, - Der Prozess P2 belegt 1Ex. von M1 & 2Ex. von M3.

Seine Gesamtforderungen betragen 2Ex. von M1, 8Ex. von M2 & 4Ex. von M3.

Erstellen Sie die für die Verklemmungsanalyse benötigten Vektoren und Matrizen!

( 10 10 10 )

erfügbar =

V ;



 



=

2 0 0 4 1

2

elegt

B ;



 



=

4 0 8 6 2 2

rung esamtforde

G

->





 



==

2 0 8 2 1 0

ustehend

A

-> F

_orderung =

( 10

−

( 2

+

1 ) 10

−

( 4

+

0 ) 10

−

( 0

+

2 ) ) (

=

7 6 8 )

Warum befindet sich das System in einem sicheren Zustand?

(

2 4 0

) (

7 6 8

)

1 ≤F → ≤

A

-> P1 kann abgearbeitet werden!

->

F =F+B₁

->

F =

(

7+2 6+4 8+0

) (

= 9 10 8

) (

≥ 1 0 2

)

= A₂

-> P2 kann abgearbeitet werden!

Î

Es gibt eine Möglichkeit, dass die Prozesse abgearbeitet werden können,

Î

Sicherer Zustand!

Der Prozess P2 fordert nun 2Ex. von M2. Bleibt das System in einem sicheren Zustand, wenn diese Anforderung gewährt wird?

( 10 10 10 )

erfügbar =

V ;





 



=

2 0 2 4 1

2

elegt

B ;





 



=

4 0 8 6 2 2

rung esamtforde

G

->





 



==

2 0 6 2 1 0

ustehend

A

-> F

_orderung =

( 10

−

( 2

+

1 ) 10

−

( 4

+

2 ) 10

−

( 0

+

2 ) ) (

=

7 4 8 ) (

2 4 0

) (

7 6 8

)

1 ≤F → ≤

A

-> P1 kann abgearbeitet werden!

->

F =F+B₁

->

F =

(

7+2 4+4 8+0

) (

= 9 8 8

) (

≥ 1 2 2

)

= A₂

-> P2 kann abgearbeitet werden!

Î

Es gibt eine Möglichkeit, dass die Prozesse abgearbeitet werden können,

Î

Sicherer Zustand!

5.1 Formeln zu Prozesse & Betriebsmittel:

1. Vektoren & Matrizen aufstellen (bei 2Prozessen & 3Betriebsmittel):

( V

₁

V

₂

V

₃

)

V

_erfügbar =

;

_



 



=

3 3 2 2 1 1

2 1 2 1 2 1

B B B B B

B_elegt B

;

_



 



=

3 3 2 2 1 1

2 1 2 1 2 1

G G G G G G_{esamtforderung} G

->

_



 



=



 





−

−

−

−

−

= −

3 3 2 2 1 1 3

3 3 3 2 2

2 2 1 1

1 1

2 1 2 1 2 1 2

2 1 1 2 2

1 1 2 2

1 1

A A A A A A B

G B G B G

B G B G

B A_ustehend G

-> F

_orderung =

( V

₁−

( B 1

₁+

B 2

₁

) V

₂ −

( B 1

₂ +

B 2

₂

) V

₃ −

( B 1

₃ +

B 2

₃

) ) (

=

F

₁

F

₂

F

₃

)

2. System sicher wenn:

(

_{1 2 3}

) (

_{1 2 3}

)

1

F A 1 A 1 A 1 F F F

A

≤ → ≤

-> P1 kann abgearbeitet werden!

-> F '

=

F

+

B 1

-> F '

=

( F

₁+

B 1

₁

F

₂ +

B 1

₂

F

₃ +

B 1

₃

) (

=

F '

₁

F '

₂

F '

₃

) (

≥

A 2

₁

A 2

₂

A 2

₃

)

=

A 2 -> P2 kann abgearbeitet werden!

3. System NICHT sicher wenn:

(

_{1 2 3}

) (

_{1 2 3}

)

1 F A1 A1 A1 F F F

A ≥ → ≥

-> P1 kann NICHT abgearbeitet werden!

(

_{1 2 3}

) (

_{1 2 3}

)

2

F A 2 A 2 A 2 F F F

A

≥ → ≥

-> P2 kann NICHT abgearbeitet werden!

5.2 Theorie - Bandstationen:

*** genau so

Ein System verwaltet 8 Bandstationen, 3 Drucker und n Prozesse, wobei jeder Prozess maximal Für n = 5 Geräte.

Da: Typ: Betriebsmitteln r. Menge

1 2 3 4 5

Band: 2 2 2 1 1 8

Drucker: 0 0 1 1 1 3

Ein System verwaltet 9 Bandstationen und n Prozesse, wobei jeder Prozess maximal 3 Bandstationen zum Arbeiten benötigt. Für welchen maximalen Wert von n ist das System garantiert noch

verklemmungsfrei ? (Begründung)

Suche eine Konstellation bei der sich keine Verklemmung (auch nicht im nächsten Schritt)

Bei 5 Prozessen kann man mit der Konstellation “Prozesse belegen je 1BM + 2 Prozesse belegen je 2BM garantieren daß Prozess Nr 5 seine 3BM bekommt und es keine Verklemmung gibt auch nicht wenn nur noch 4 Prozesse nach der Abarbeitung übrig bleiben.

Suche die max. Anzahl Prozesse bei dennen es keine Konstellation gibt bei der eine Verklemmung auftritt!

Das kann man nur für max. 4 Prozesse garantieren weil sobald 4 Prozesse je 2BM belegen kann einer der 4 Prozesse auf jeden Fall noch das benötigte 3. BM erhalten

-> verklemmungsfrei

5.1 Theorie - Deadlocks:

Angenommen, ein Betriebssystem hätte einen Anruf

WarteAufMehrereBetriebsmittel(Liste der gewünschten Betriebsmittel).

Der Aufruf sollte erst dann zurückkehren, wenn alle Anforderungen erfüllt sind, ohne vorher auch nur eines der gewünschten Betriebsmittel zu belegen. Welche Vor- und Nachteile hätte so ein Aufruf?

N -> Gefahr von Deadlocks,

V -> Prozeß kommt eher zum Rechnen dran, ???? Oder: Anforderungen können leichter erfüllt werden???

Ein System mit n Prozessen befindet sich in einem Deadlock. Welche Probleme können auftreten, wenn der Deadlock dadurch beendet wird, dass die Prozesse der Reihe nach abgebrochen werden?

- Speicherverlust, - Evtl. Systemabsturz, - Instabilität,

- „Zombi-Zustand“,

- Abhängige Prozesse werden mit beendet, - Speicherdefragmentierung…

6. Binäres Buddy-System:

Ein System hat 1MB = 1024kB Freispeicher zur Verfügung. Speicher wird wie nachstehend beschrieben in Einheiten von 1kB angefordert und wieder freigegeben. Die in der

Ausgangslage belegten Blöcke sind markiert. Geben Sie für ein binäres Buddy-System an, wie sich der Speicher im Verlauf der Aufträge entwickelt. Falls Verschmelzungen oder

Aufteilungen stattfinden, so ist dies anzugeben. Freie Blöcke sind zu markieren. Falls eine Anforderung nicht erfüllt werden kann, so ist dies anzugeben. Wenn bei einer Anforderung Blöcke zur Auswahl stehen, dann ist mit der niedrigsten Adresse auszuwählen.

▪ 0 ▪ 128 ▪ 256 ▪ 384 ▪ 512 ▪ 640 ▪ 768 ▪ 896 ▪ 1024

a b c

e --- X --- X --- --- --- --- f --- --- --- X --- --- --- ---

g X g100 --- --- X --- --- --- ---

h X X h120 --- X --- --- --- ---

i X X X i90 X --- --- --- ---

j X X X X X j80 --- --- ---

k X X X --- X --- --- --- l X X --- --- X --- --- --- m X X --- --- --- --- --- --- n X --- --- --- --- --- --- ---

o X X o --- --- --- --- --- ---

p --- X --- --- --- --- --- --- ( X = Belegt, --- = frei) (512,256,128,64,32,16)

Aktionen:

e. Freigabe b f. Freigabe a g. Anfordern 100 h. Anfrodern 120 i. Anfordern 90 j. Anfordern 80 k. Freigabe c l. Freigabe i m. Freigabe j n. Freigabe h o. Anfordern 257 p. Freigabe g

7. FIFO(First In First Out) – LRU(Last Recently Used) – Optimale Ersetzung - Speicherverwaltung:

Gegeben ist ein System mit 4 Seitenrahmen (Nr. 0…Nr.3), welche am Anfang leer sind. Die nachfolgend angegebene Skizze enthält Platz für die Blöcke. Unten sind hier die Referenzen auf den Speicher angegeben. Dabei bezieht sich jede Nummer auf einen Block von der Größe eines

Seitenrahmens. Geben Sie für die Strategien „Optimale Ersetzung“ und „LRU“ den Zustand der Seitenrahmen nach jedem Zugriff an.

Die Bezeichnungen für die Seitenrahmen 0,1,2 & 3 müssen eingehalten werden!

0 0 0 0 0 0 0 0 0 3 3 3 3 3 3 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 1 - 1 1 1 1 1 1 1 1 1 1 1 1 1 1 - 3 3 3 3 0 0 0 0 5 5 5 5 1 1 2 - - 2 2 2 2 2 2 2 2 2 2 2 2 2 - - 1 1 1 1 1 1 1 1 1 3 3 3 3 3 - - - 3 4 4 4 4 4 4 6 6 6 6 6 - - - 4 4 4 4 4 4 4 4 4 4 4 4 0 1 2 3 4 0 1 2 3 4 6 1 3 2 0 2 3 1 4 2 0 1 4 2 5 2 3 4 1 0

Optimale Ersetzung – Strategie -> 4 FE LRU -> 5 Fehlentscheidungen

0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 2 2 2 2 2 2 2 2 2 2 2 1 1 1 1

1 - 3 3 3 3 0 0 0 0 5 5 5 5 1 1 - 1 1 1 1 4 4 4 4 4 4 4 4 4 4 2 - - 1 1 1 1 1 1 1 1 1 3 3 3 3 - - 0 0 0 0 1 1 1 1 5 5 5 5 5 3 - - - 4 4 4 4 4 4 4 4 4 4 4 4 - - - - 3 3 3 3 3 3 3 3 2 2 2

2 3 1 4 2 0 1 4 2 5 2 3 4 1 0 2 1 0 2 3 4 1 2 3 4 5 1 2 5 1

LRU -> 5 Fehlentscheidungen LRU

0 2 3 1 4 2 0 1 4 2 5 2 3 4 1 0 2 1 0 2 3 4 1 2 3 4 5 1 2 5 1 1 - 2 3 1 4 2 0 1 4 2 5 2 3 4 1 - 2 1 0 2 3 4 1 2 3 4 5 1 2 5 2 - - 2 3 1 4 2 0 1 4 4 5 2 3 4 - - 2 1 0 2 3 4 1 2 3 4 5 1 2 3 - - - 2 3 1 4 2 0 1 1 4 5 2 3 - - - - 1 0 2 3 4 1 2 3 4 4 4

Dazugehöriger Keller Dazugehöriger Keller

0 0 0 0 0 4 4 4 4 3 3 3 3 3 2 2 2 2 2 2 2 4 4 4 4 4 4 4 4 4 4 1 - 1 1 1 1 0 0 0 0 4 4 4 4 4 0 - 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 - - 2 2 2 2 1 1 1 1 6 6 6 6 6 - - 0 0 0 0 0 0 0 0 5 5 5 5 5 3 - - - 3 3 3 3 2 2 2 2 1 1 1 1 - - - - 3 3 3 3 3 3 3 1 1 1 1

0 1 2 3 4 0 1 2 3 4 6 1 3 2 0 2 1 0 2 3 4 1 2 3 4 5 1 2 5 1 FIFO FIFO 0 0 0 0 0 4 4 4 4 6 6 6 6 6 6 6 0 0 0 3 3 3 3 1 1 1 1 1 1 - 1 1 1 1 0 0 0 0 0 0 2 2 2 2 - 1 1 1 2 2 2 2 2 3 3 3 2 - - 2 2 2 2 1 1 1 1 1 1 3 3 3 - - 4 4 4 4 0 0 0 0 0 2

3 - - - 3 3 3 3 5 5 5 5 5 5 5 5

0 1 2 3 4 0 1 5 6 0 1 2 3 5 6 0 1 4 3 2 3 0 1 0 3 0 2 FIFO -> 7 Fehlentscheidungen FINUFO (First In Not Used First Out) 0 0 0 0 0 6 6 6 0 0 0 5 5 0 0 0 3 3 3 3 3 3 3 3 3 1 - 3 3 3 3 3 5 5 5 3 3 3 - 1 1 1 2 2 2 1 1 1 1 2 2 - - 4 4 4 2 2 2 2 2 2 4 - - 4 4 1 1 0 0 0 0 0 0

0 3 4 3 6 2 5 0 2 3 5 4 0 1 4 3 2 3 0 1 0 3 0 2

LRU -> 7 Fehlentscheidungen

***

^LRU

0 0 3 4 3 6 2 5 0 2 3 5 4 0 1 4 3 2 3 0 1 0 3 0 2 1 - 0 3 4 3 6 2 5 0 2 3 2 - 0 1 4 3 2 3 0 1 0 3 0 2 - - 0 0 4 3 6 2 5 0 2 3 - - 0 1 4 4 2 2 2 1 1 3

Dazugehöriger Keller Dazugehöriger Keller

*** LRU & optimal genau so

0 0 0 0 0 0 0 0 0 0 3 3 4 0 0 0 0 0 0 0 0 0 0 0 2 2 2

1 - 3 3 3 3 3 5 5 5 5 5 5 - 1 1 1 2 2 2 1 1 1 1 1 1 1

2 - - 4 4 6 2 2 2 2 2 2 2 - - 4 3 3 3 3 3 3 3 3 3 4 4

0 3 4 3 6 2 5 0 2 3 5 4 0 1 4 3 2 3 0 1 0 3 0 2 4 1 Optimale Ersetzung – Strategie -> 5 Fehlentscheidungen Optimale Ersetzung – Strategie -> 6 FE

Seitentauschen == Fehlentscheidungen

Def.: LRU: (last recently used) Zeitpunkt,

Das unterste Kellerelement wird ersetzt. Der Keller ist so tief wie es Kackeln gibt.

Falls vorhanden -> überschreiben & im Keller gelöscht und oben drauf!

RNU: (recently not used) Existenz,

OptiE.: Suche die jenige Seite, die am spätestens wieder benutzt wird.

Falls vorhanden -> überschreiben.

FIFO: Die am längsten sich im Speicher befindende Seite wird ausgelagert.

-> Neue Seite in lineare Liste vorne einketten und letzte Seite aushängen.

Betrachten Sie die folgende Sequenz von Speicherzugriffen eines 8KB großen Programmes:

(Alle Zahlen sind Hexadezimal)

3010, 1620, 2A04, 408, 1648, 1936, 2A20, 2030, 490, 1960, 2670 Geben Sie die Seitenreferenzfolge an, wenn die Seitengröße 2KB beträgt:

Lsg.:

2 KB

=

2048 Byte

_dezimal ⇒

2 KB

=

800

_hexadezimal

0

16

800

₁₆

2 x 800

₁₆ =

1000

₁₆

1800

₁₆

2000

₁₆

2800

₁₆

3000

₁₆

3800

₁₆

4000

₁₆

0

10

1

₁₀

2

₁₀

3

₁₀

4

₁₀

5

₁₀

6

₁₀

7

₁₀

8

₁₀

408,490 1620,1648 1936,1960 2030,2670 3010

Dem Programm stehen 3 Kacheln Hauptspeicher zur Verfügung. Wie oft werden bei der reinen LRU- Strategie Seiten getauscht? Wieviele Fehlentscheidungen werden im Vergleich zur optimalen Strategie getroffen?

0 6 6 6 0 0 0 0 0 0 0 0 6 6 6 0 0 0 5 5 5 3 3 1 - 2 2 2 2 3 3 3 3 3 3 - 2 2 2 2 2 2 4 4 4 4 2 - - 5 5 5 5 5 4 4 4 4 - - 5 5 5 3 3 3 0 0 0 6 2 5 0 2 3 5 4 0 3 4 6 2 5 0 2 3 5 4 0 3 4

Optimale Ersetzung – Strategie -> 3 FE LRU – FE -> 6 FE

6 2 5 0 2 3 5 4 0 3 4 - 6 2 5 0 2 3 5 4 0 3 - - 6 2 5 0 2 3 5 4 0

Dazugehöriger Keller

7.1 Speicherverwaltung – Adressierung – Theorie:

Gegeben ist eine CPU mit virtuellen Adressierung. Die CPU soll für Zeichenketten (=Strings) Spezialbefehle wie etwa: KopiereString, Quelladresse, Zieladresse, AnzahlBytes anbieten.

Welche Probleme kann es durch Seitenfehler geben? Wie könnte man hier abhelfen?

- WS erhöhen, um Trashing zu vermeiden,

- Besseres Lokalitätsverhalten (optimierter Specherzugriff), - Mehr Speicher.

Manche BS beschreiben den Speicher mit 0, bevor sie ihn einzelnen Prozessen zuteilen, manche nicht. Ist dies rein zufällig oder gibt es Gründe für das jeweilige Verhalten?

- Fehlervermeidung durch Speicherreininitialisierung, - Schutz vor Viren.

Bei einem Entwurf einer Speicherverwaltung soll die Seitengröße für virtuelle

Addressierungsform festgelegt werden. Es stehen die Größen 512 B und 4096 B zur Auswahl.

Nennen Sie je zwei Argumente für beide Größen.

512:

Vorteil:

- Weniger Speicherverschnitt weil kleinere Seitengrößen gewählt werden Nachteil:

- Die Seitentabelle wird sehr groß weil viele Einträge vorhanden sind - Das Suche innerhalb der Tabelle wird langsamer

4096:

Vorteil:

- Kleinere Seitentabelle

- Schnelleres Suchen innerhalb der Tabelle Nachteil:

- mehr Speicherverschnitt wegen größerer Seitengröße

7.2 Speicherverwaltung – Formeln:

Formeln – Speicherverwaltung:

0 1

0

p * s

Größe

=

γ

=

;

s s s s

Breite s ⁰

1 0

0

0 =

= +

=σ

ρ

chrate

=

Seitentaus für σ

σ ρ γ

σ

σ

1 *

0

0 0

0 ⇒ = −

≤

≤

für

( σ )

σ σ γ

σ γ σ

ρ γ σ

σ

−

−

= −

−

− −

−

= −

⇒

≤

≤ * 1

1

* 1 1 1 1

1 1

0 0 0

0 0

0 0

G = Gesamtdauer aller Prozesse (Gesamtbearbeitungsdauer) G

=

n * B * T * ρ für σ

<

σ

₀

, B = Dauer eines Prozesses,

n = Anzahl Prozesse im Speicher, M = Gesamt verfügbarer Speicher,

s = Anzahl Seiten pro Prozess (Programmgröße), m = Speicherangebot pro Prozess ->

n m

=

M ,

tT

= mittlere Seitenaustauschzeit - Transferzeit, (halbiert falls: 2xZugriffsgeschw.) t

s

= mittlere Seitenverweilzeit, (halbiert falls: 2xRechengeschw.)

'

n

= kritische Schranke – „Trashing“,

falls:

₀

1

₀

1

−

γ

> ⇒

σ

_T >

σ

T mit

s T

t T = t

dann 1 * '

0

2

n

s n

=

M

=

σ -> Ab n’ starker Leistungsabfall „Trashing“

falls:

₀

1

₀

1

−

γ

≤ ⇒

σ

_T ≤

σ

T mit

s T

t T = t

* '

* *

1 ₀

0

2 n

s M T

n T =

= −

σ

γ

7.3 Aufgaben – Größe – Breite – Seitentauschrate – krititsche Schranke:

*** genau so

Ein Programm P der Grösse s=40 Seiten besitze folgende Lokalität.

10 Seiten werden mit der Wahrscheinlichkeit p1=0,07,

30 Seiten werden mit der Wahrscheinlichkeit p2=0,01 referenziert.

Bestimmen Sie dir Größe & Breite der Vorzugsmenge des Programmes sowie die Seitentauschrate.

->

s

₀ =

10 ;

s₁ =30

Größe: γ

₀ =

p

₁

* s

₀ =

0 , 07 * 10

=

0 , 70

25 , 30 0 10

10

1 0

0

0 =

= +

= +

= s s

Breite

σ

s

ρ

=

chrate

Seitentaus für σ ρ * σ

25 , 0

70 , 1 0 25

, 0

0

≤ ≤ ⇒ = −

für 0,25≤σ ≤1⇒ρ =0,4−0,4*σ =0,4*

(

1−σ

)

Sei die mittlere Seitenverweilzeit ts=2ms und die mittlere Seitentransferzeit tT=20ms.

n Prozesse durchlaufen Programme mit gleicher Größe und gleichem Referenzverhalten wie P.

Bei welcher Anzahl n’ ist ein starker Leistungsabfall des Systems zu erwarten, wenn das gesamte Speicherangebot M=800 Seiten beträgt?

0 0

1 − γ > 1 ⇒ σ

_T

> σ

T

2 ¹⁰

20 =

=

= ms

ms t

T t

s T

10

0

, 0 30 , 1 0 70 , 0

1

− > ⇒ > ⇒

σ

_T >

σ T

-> 80 '

40

* 800 25 , 0

* 1 1

0

2

n

s

n

=

M

= = =

σ

Neue Systemplatten mit doppelter Zugriffsgeschwindigkeit werden angeschafft.

Welchen Einfluss hat dies auf die kritische Schranke n’ & Gesamtbearbeitungsdauer?

-> t_T wird halbiert -> 5 2

10 =

=

= ms

ms t

T t

s T

25

0

, 0 30 ,

0

> ⇒

σ

_T >

σ -> Hat hier keinen Einfluß!

Die Gesamtbearbeitungsdauer sinkt -> Prozesse werden schneller abgearbeitet.

Da

G

=

n * B * T * ρ für σ

<

σ

₀

Ein Programm P der Grösse s=200 Seiten besitze folgende Lokalität.

40 Seiten werden mit der Wahrscheinlichkeit p1=0,02000, 160 Seiten werden mit der Wahrscheinlichkeit p2=0,00125 referenziert.

Bestimmen Sie dir Größe & Breite der Vorzugsmenge des Programmes sowie die Seitentauschrate.

->

s

₀ =

40 ;

s₁ =160

Größe: γ

₀ =

p

₁

* s

₀ =

0 , 02 * 40

=

0 , 80

20 , 160 0 40

40

1 0

0

0 =

= +

= +

= s s

Breite σ s

ρ

=

chrate

Seitentaus für σ ρ * σ

20 , 0

80 , 1 0 20

, 0

0

≤ ≤ ⇒ = −

für 0,20≤

σ

≤1⇒

ρ

=0,25−0,25*

σ

=0,25*

(

1−

σ )

Sei die mittlere Seitenverweilzeit ts=2ms und die mittlere Seitentransferzeit tT=20ms.

n Prozesse durchlaufen Programme mit gleicher Größe und gleichem Referenzverhalten wie P.

Bei welcher Anzahl n’ ist ein starker Leistungsabfall des Systems zu erwarten, wenn das gesamte Speicherangebot M=2000 Seiten beträgt?

Achtung die Angabe kann auch folgendermaßen aussehen dann muß man erst paar Dinge berechnen.

ts : Seitengröße =512 Worte (~2KB)

Mittlere Befehlslänge 4B => 512 Befehle pro Seite Jeder Befehl wird im Mittel 2x ausgeführt

Anlagengeschwindigkeit : 1 MIPS (Million Instruktionen pro Sekunde)

ms t

_S

* 2 * 512 1

10 1

6 ≈

=

0 0

1 − γ > 1 ⇒ σ

_T

> σ

T

2 ¹⁰

20 =

=

= ms

ms t

T t

s T

10

0

, 0 20 , 1 0 80 , 0

1

− > ⇒ > ⇒

σ

_T >

σ T

-> 50 '

200

* 2000 20 , 0

* 1 1

0

2

n

s

n

=

M

= = =

σ

Neue Systemplatten mit doppelter Zugriffsgeschwindigkeit werden angeschafft.

Welchen Einfluss hat dies auf die kritische Schranke n’ & Gesamtbearbeitungsdauer?

-> t_T wird halbiert -> 5 2

10 =

=

= ms

ms t

T t

s T

₀

1

₀

1

−

γ

≤ ⇒

σ

_T ≤

σ

T ; 0 , 20 0 , 20 5

80 1 , 0

1

− ≤ ⇒ ≤

' 200 50

* 20 , 0

2000

* 80 ,

*0 1 5

5

*

* *

1 ₀

0

2 n

s M T

n T = =

= −

= −

σ

γ -> keine Änderung!

Die Gesamtbearbeitungsdauer sinkt -> Prozesse werden schneller abgearbeitet.

Da

G

=

n * B * T * ρ für σ

<

σ

₀

Ein neuer Prozessor mit doppelter Rechengeschwindigkeit wird angeschafft.

Welchen Einfluss hat dies auf die kritische Schrankte n’? (Begründung) ->

t

_s wird halbiert -> 20

1 20 =

=

= ms

ms t

T t

s

T

->

₀

1

₀

1 − γ > ⇒ σ

_T

> σ

T ^;

05 , 0 20 , 20 0 80 1 , 0

1− > ⇒ >

-> 50 '

200

* 2000 2 , 0

* 1 1

0

2

n

s

n

=

M

= = =

σ -> keine Änderung!

8. Semaphoren – Theorie – kritische Abschnitte:

Nennen Sie 2 Möglichkeiten zum Schutz von kritischen Abschnitten bei einem Einprozessorsystem:

Semaphoren , Mutex

der belegende Prozess darf von keinem Prozess verdrängt werden, der auch in den kritischen Abschnitt will.

Verhindern von Verdrängung

Was ist beim Schutz von langen kritischen Abschnitten bei Multiprozessorsystemen besonderst zu beachten? (Nenne 2 Punkte)

Aufpassen daß die kurzen kritischen Abschnitte anderer Prozesse nicht zu lange ausgegrenzt werden - Aktives Warten:

Voraussetzung 1. unteilbar (nur 1 Befehl ???TSL-Anweisung???)

2. Multiprozessorfest d.h. Prozessor sperrt B (Mutex) für einen Maschinenbefehl

- Verdrängungssperre nicht akzeptabel, da sonst für einen längeren Zeitraum keine anderen Prozesse auf diesem Prozessor laufen können.

- Aktives warten verbraucht zu viel Rechenzeit.

--> Semaphore mit Warteliste, geschützt durch Mutex (binäre Semaphore)

Tanenbaum formulierte in seinem Lehrbuch die nachfolgenden 4 Bedingungen für eine gute Lösung des Problemes der kritischen Abschnitte.

2 Prozesse dürfen sich nicht gleichzeitig in dem kritischen Abschnitten befinden.

- um sogenannte Race-Conditions zu vermeiden

- Lese+Schreib-Aktion ist nicht atomar, daher kann und wird es zu inkonsistenten Daten im kritischen Bereich führen.

Es dürfen keine Annahmen über die relativen Geschwindigkeiten der Prozesse oder Prozessoren gemacht werden.

Prozesse und Prozessoren müssen als zeitlich voneinander unabhängig betrachtet werden.

Die Entwicklung einer Strategie basierend auf Anzahl der microOPs und die Taktfrequenz zur Bestimmung der Eintrittszeitpunkts in den KA sind nicht akreptabel, zu Aufwendig, technisch nicht realiesiert.

Kein Prozess, der sich außerhalb seines kritischen Abschnittes befindet, darf andere Prozesse blockieren.

- Verklemmungsgefahr

Kein Prozess sollte beliebig lange auf seinen Eintritt in den kritischen Abschnitt warten müssen.

- Gefahr der Verhungerung (starvation)

9. UNIX Programme – Fragen zu C-Code:

Welche Werte druckt das folgende Programm? (Begründung)

#include <stdio.h>

main( ) { int i;

for (i = 0 ; i < 3 ; i++) {

fork( );

printf(“%d”, i );

} }

Bei Suse Linux erfolgte am Standard Out(über SSH) folgende Ausgabe:

012012012012012012012012

(genauer mit Promt: 012testlinux:~ # 012012012012012012012)

*** genau so

Lokalitätsverhalten - gegeben sind die nachfolgenden Programmvarianten PROG1 und PROG2 zum Löschen einer NxM Matrix

/* PROG 1 */

#define N 512

#define M 32 int main( void ) {

short int X[N][M]; /* short belegt 2 Bytes */

int i , j ;

for ( j = 0 ; j < M ; j++) for ( i = 0 ; i < N ; i++) X[ i ][ j ] = 0;

}

/* PROG 2 */

#define N 512

#define M 32 int main( void ) {

short int X[N][M]; /* short belegt 2 Bytes */

int i , j ;

for( i = 0 ; i < N ; i++) for( j = 0 ; j < M ; j++) X[ i ][ j ] = 0;

}

Nehmen Sie an , daß die Variablen i und j in Registern gehalten werden und die Matrix A im Adressraum ab Adresse 0 liegt. Der ausführbare Code liegt im Adressraum ab Adresse X'8000' und belegt 2KB. Die Seitengröße des virtuellen Speichers sei 4 KB für den Prozess stehen im

Hauptspeicher 5 Kacheln zur Verfügung.

Bei welcher Programmvariante werden weniger Seiten getauscht ? (Begründung)

Laut der Angabe über die Ablage von Feldern in C scheinen erst alle Zellen der jeweiligen Zeile nacheinander zu kommen dann die nächste Zeile ... Daraus schliesse ich daß Programm 2 die bessere Wahl ist mit weniger Seitenvertauschungen. Programm 2 wählt in der Äuseren Schleife erst die Zeile und itteriert dann innerhalb dieser Zeile die Zellen ab, di aber eben jeweils 2B belegen und

nacheinander kommen. D.h. Bei einer Seitengröße von 4 KB passen 2048 Zellen auf eine Seite die Matrix hat aber nur 32 pro Zeile -> 2048/32= 64 Zeilen Pro Seite.

=> 8 Seiten Daten (dann beginnt Code bei 0x8000)

Wenn man dagegen wie in Programm 1 erst über die Spalten iterriert muß man bei jeder 64. Zelle (weil 5 Zeile ) einen Seitenwechsel vornehmen. Das wäre aufwendiger.

Wie oft werden in PROG1 bei der optimalen Strategie Seiten getauscht ? 4 mal

Hinweis: Die Ablage von Feldern in C sei folgendermassen definiert.

A[0][0] ... A[0][M-1] ... A[N-1][M-1]

*** genau so

Zwei zyklische Prozessen (Bäckerrei)

Gegeben ist das nachfolgende Protokoll für den wechselseitigen Ausschluß zweier zyklischer Prozesse P1 und P2:

a) Globale Variablen (=Angabe-Teil1)

c1, c2: integer range 0...1, Initialisierung: c1 = 1; c2 = 1 b) Algorithmus für P1, P2

Ist dieser Algorithmus sicher? (Begründung bzw. Gegenbeispiel)

Verklemmung ist möglich , weil Addition und Zuweisung 2 Operationen sind und damit unterbrechbar sind.

10. UNIX Programme - Semaphoren:

Aufgabe:

Steuerung einer bidirektionalen Rolltreppe für maximal 10 Fahrgäste (=Prozesse, Threads);

0,1,2,...,9. Gleichzeitig können alle Fahrgäste in einer Richtung auf der Rolltreppe „fahren“.

Solange Fahrgäste aus der laufenden Richtung der Rolltreppe kommen, können diese die Rolltreppe ohne Wartezeit benutzen. Fahrgäste aus der anderen Richtung müssen solange warten, bis der Zustrom aus der Gegenrichtung abreißt und der letzte Fahrgast die Rolltreppe verlässt.

(Genau so, wie bei den bidirektionalen Rolltreppe bei U- bzw. S-Bahn. Nur nummerierte Fahrgäste 0,1,2,...,9 für eine leichtere Verwaltung).

Die Synchronisierung sowie das Vertagen und Aktivieren von Prozessen muss mit Semaphoren sichergestellt werden.

Tragen Sie die Lösung in das folgende Programmskelett ein.

class Semaphoren

{ // Nur zu Ihrer Information angegebene Daten public:

Semaphore(); // Einrichtung der Semaphore void P(); // Dijkstra´s P-Operation

void V(); // Dijkstra´s V-Operation void init (int count); // Anfangswert };

class Rolltreppe

{ // Datentypen

enum

{ MAXFAHRGAESTE = 10; };

// Eine Treppe hat einen Ruhezustand & 2 Laufrichtungen public:

enum Fahrrichtung

{ ruhend, aufwaerts, abwaerts };

private: // Attribute

Fahrrichtung Zustand; // Startzustand == ruhend

Semaphore mutex; // Wechselseitigen Ausschluss garantiert Semaphore WartePlatz[MAXFAHRGAESTE]; // Warteplätze bei Blockade

bool WartePlatzbelegt[MAXFAHRGAESTE]; // Hier warten die Fahrgäste

int FahrGaesteAufTreppe; // Anzahl der Fahrgäste auf der Treppe int WartendeFahrGaeste; // Die Wartenden (auf Gegenrichtung) ////////// Platz für Ihre Attribute, falls erforderlich! //////////

public:

Rolltreppe() {

Zustand = ruhend; // siehe oben

FahrGaesteAufTreppe = 0; // Niemand fährt am Anfang

WartendeFahrGaeste = 0; // Niemand warted

// Welchen Wert erhält mutex?

Mutex.init( 10 );

// Welchen Wert erhalten die Warteplätze?

for(int i = 0; i < MAXFAHRGAESTE; i++) {

WartePlatzbelegt[i] = true;

Warteplatz[i].init(MAXFAHRGAESTE-i);

}

// Initialisierung Ihrer Attibute, falls erforderlich }

Rolltreppe(); // Hier nicht erforderlich void IchWillFahren (Fahrrichtung RaufOderRunter, int FFahrgast)

{

// Falls sich die Treppe wie RaufOderRunter bewegt, Zugang gewähren.

// Falls sich die Treppe anders bewegt, Fahrgast blockieren.

// -> Aufwecken, wenn Zustrom aus alter RRichtung zuende.

// Falls Treppe ruhend: Zustand auf RaufOderRunter, Zugang gewähren Rolltreppe Roll;

Semaphoren Semph;

Switch(Rolltreppe.Zustand) {

case „RaufOderRunter“:

Roll.WartePlatzbelegt[FFahrgast]=true;

case „ruhend“:

Roll.Zustand = RaufOderRunter;

Semph.p();

default:

Roll.WartePlatzbelegt[FFahrgast]=false;

} }

void IchVerlasseDieTreppe (int Fahrgast) {

// Falls niemand mehr auf der Rolltreppe: Zustand = ruhend.

// Falls jemand auf Zugang wartet: Rolltreppe in gewünschten Zustand // d.h. die Rolltreppe ändert nun ihre Richtung

// Aktiviere alle wartenden Fahrgäste (=Prozesse) // (Diese warten alle auf Zugang in derselben Richtung!!!) Rolltreppe Roll;

If(Roll.WarteFahrGaeste == 0) Roll.Zustand {

Zustand = ruhend;

} else {

Roll.Zustand =

} };

Lösung:

Aufgabe:

Zur Prozesskommunikation mit einem Betriebssystem, welches Semaphoren mit P- und V- Operationen kennt, sollen Events realisiert werden. Die Routinen sollen zwei Zähler mit

Anfangswert Null verwalten: einen Ereigniszähler Event_E sowie einen Nummerzähler Event_N.

Das System soll für maximal 10 Prozesse ausgelegt sein. Im einzelnen sind die folgenden Routinen gesucht:

Int Event_Ticket (void);

// Dieser Aufruf liefert den Wert von Event_E und schaltet danach Event_E um eines weiter.

// Je zwei Aufrufer erhalten verschiedene Nummern.

void Event_Tick (void);

// Dieser Aufruf schaltet den Wert von Event_N weiter. Wenn Prozesse auf eine Wert // N <= Event_N werten, so sollen sie aktiviert werden.

void Event_Wait (int N);

// Dieser Aufruf vertagt den aufrufenden Prozess solange, bis Event_N >= N gilt.

Lösung:

11. UNIX Programme - Pipes:

Die Rechtecke Ci und Si sollen Prozesse darstellen, Ai bezeichnen unbenannte Pipes. Die Pfeilsymbole sollen Lese- bzw. Schreibvorgänge auf diese Pipes festlegen.

Diese Bezeichnungen müssen in der Lösung benutzt werden!

Die Clients Ci erteilen den Servern S1 und S2 in einer Schleife jeweils 1000 Aufträge. C1 erteilt Aufträge zur Berechnung von sin(x), C2 erteilt Aufträge zur Berechnung von cos(x).

Dabei wird x ab einem Wert von 0,0 in Schritten von 0,05 weitergeschaltet.

Die Server S1 und S2 sollen die Aufträge aus der Pipe A1 lesen, die Berechnung durchführen und das jeweilige Ergebnis nach A2 schreiben. Dabei soll angegeben werden, welcher Server die Berechnung durchgeführt hat.

Der Server S liest seine Aufträge aus der Pipe A2 und gibt die Ergebnisse nach stdout aus.

Die Server sollen jeweils einen Auftrag aus der jeweiligen Pipe lesen, bearbeiten und das Ergebnis in die angegebene Pipe schreiben (bzw. bei S: nach stdout ausgeben!).

Die Server beenden sich, wenn keine weiteren Aufträge folgen können.

// Format für die Pipes: identisch für ALLE SCHREIB- und LESEVORGÄNGE struct t_RESULTAT

{

double x; // Daten für Auftrag

int AuftragsCode; // 1 = berechne sin, 2 = berechne cos int code; // Nummer für Server: 1=S1 bzw. 2=S2 };

Aufgabe:

Geben Sie ein Programm an, das den Code für o.a. Prozesse sowie die Pipes enthält. Das Hauptprogramm soll die Pipes anlegen sowie alle Prozesse zum Ablauf bringen.

Geben Sie für jeden Prozess eine geeignete Routine C1, C2, S1, S2 bzw. S an.

Geben Sie den Programmcode für die o.a. Prozesse an. Die Lösung muss den Programmcode für das Einrichten der Pipes mit Schließen der nicht benötigten Lese- bzw. Schreibkennzahlen, die Erzeugung aller Prozesse sowie o.a. Vorgänge der Prozesskommunikation enthalten.

Zusatzfrage:

Besteht hier die Gefahr eines Deadlocks?

(Hinweis: Denken Sie an die vier Kriterien von Coffman)

C1

C2

S1

S2

S

A1 A2