View
3
Download
0
Category
Preview:
Citation preview
Grundlagen: Betriebssysteme undSystemsoftware (GBS)
Johann SchlichterInstitut für Informatik
TU München, Munich, Germany
September 2015Vorlesungsunterlagen
(Teacher Script1)
1Script generated by Targeteam. Not for Distribution
Inhaltsverzeichnis
1 Übersicht 21.1 Ziele der Vorlesung . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Anforderungen an Rechensysteme . . . . . . . . . . . . . 4
1.2.2 Struktur eines Rechensystems . . . . . . . . . . . . . . . 7
1.3 Themen der Vorlesung . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.1 Laufzeitmodell . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.2 Inhaltsübersicht . . . . . . . . . . . . . . . . . . . . . . . 10
1.4 Literaturübersicht . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.1 Begleitend zur Vorlesung . . . . . . . . . . . . . . . . . . 12
1.4.2 Weiterführende Literatur . . . . . . . . . . . . . . . . . . 12
2 Einführung 142.1 Betriebssystem - Überblick . . . . . . . . . . . . . . . . . . . . . 14
2.1.1 BS-Hauptaufgaben . . . . . . . . . . . . . . . . . . . . . 15
2.1.2 Systemprogrammierung . . . . . . . . . . . . . . . . . . 19
2.1.3 Hardwarekomponenten . . . . . . . . . . . . . . . . . . . 20
2.1.4 Betriebsarten . . . . . . . . . . . . . . . . . . . . . . . . 21
2.1.5 Historie . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2 Betriebssystem-Architektur . . . . . . . . . . . . . . . . . . . . . 23
2.2.1 Monolithischer Ansatz . . . . . . . . . . . . . . . . . . . 23
2.2.2 Mikrokern-Ansatz . . . . . . . . . . . . . . . . . . . . . 26
2.2.3 Beispiel: BS-Architekturen . . . . . . . . . . . . . . . . . 27
2.2.4 Systemaufrufe . . . . . . . . . . . . . . . . . . . . . . . 30
i
Schlichter, TU München INHALTSVERZEICHNIS
2.2.5 Virtuelle Maschine . . . . . . . . . . . . . . . . . . . . . 32
2.3 Hardwarenahe Programme . . . . . . . . . . . . . . . . . . . . . 33
2.3.1 Definitionen . . . . . . . . . . . . . . . . . . . . . . . . 33
2.3.2 Programmaufbereitung . . . . . . . . . . . . . . . . . . . 34
2.3.3 Binder und Lader . . . . . . . . . . . . . . . . . . . . . . 36
3 Parallele Systeme - Modellierung, Strukturen 423.1 Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.2 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.1 Begriffsdefinitionen . . . . . . . . . . . . . . . . . . . . 44
3.2.2 Beschreibungskonzepte . . . . . . . . . . . . . . . . . . . 46
3.3 Modellierung paralleler Systeme . . . . . . . . . . . . . . . . . . 47
3.3.1 Modellierungsziele . . . . . . . . . . . . . . . . . . . . . 47
3.3.2 Verhaltensbeschreibung . . . . . . . . . . . . . . . . . . 48
3.3.3 Ereignisse und Aktionsstrukturen . . . . . . . . . . . . . 50
3.3.4 Aktionen als Zustandsübergänge . . . . . . . . . . . . . . 56
3.3.5 Petri-Netze . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.4 Thread-Konzept . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.4.1 Charakterisierung von Threads . . . . . . . . . . . . . . . 75
3.4.2 Threads in Java . . . . . . . . . . . . . . . . . . . . . . . 78
3.5 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.5.1 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . 82
3.5.2 Definition: Wechselseitiger Ausschluss . . . . . . . . . . 84
3.5.3 Modellierung . . . . . . . . . . . . . . . . . . . . . . . . 85
3.5.4 Synchronisierungskonzepte . . . . . . . . . . . . . . . . 87
3.5.5 Semaphore . . . . . . . . . . . . . . . . . . . . . . . . . 92
3.5.6 Synchronisierung von Java Threads . . . . . . . . . . . . 98
3.6 Verklemmungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
3.6.1 Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . 100
3.6.2 Belegungs-Anforderungsgraph . . . . . . . . . . . . . . . 101
3.6.3 Verklemmungs-Ignorierung . . . . . . . . . . . . . . . . 101
3.6.4 Verklemmungs-Erkennung . . . . . . . . . . . . . . . . . 102
3.6.5 Verklemmungs-Verhinderung . . . . . . . . . . . . . . . 103
ii
Schlichter, TU München INHALTSVERZEICHNIS
3.6.6 Verklemmungs-Vermeidung . . . . . . . . . . . . . . . . 104
3.6.7 Vergleich der Ansätze . . . . . . . . . . . . . . . . . . . 106
4 Prozess- und Prozessorverwaltung 1074.1 Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.2 Prozessverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.2.1 Prozesskonzept . . . . . . . . . . . . . . . . . . . . . . . 108
4.2.2 Dispatcher . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.2.3 Arbeitsmodi . . . . . . . . . . . . . . . . . . . . . . . . 117
4.2.4 Systemaufrufe . . . . . . . . . . . . . . . . . . . . . . . 117
4.2.5 Realisierung von Threads . . . . . . . . . . . . . . . . . 118
4.3 Prozessorverwaltung . . . . . . . . . . . . . . . . . . . . . . . . 121
4.3.1 Kriterien . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.3.2 Scheduling-Strategien . . . . . . . . . . . . . . . . . . . 124
4.3.3 Beispiel Unix Scheduling . . . . . . . . . . . . . . . . . 129
4.3.4 Thread Scheduling . . . . . . . . . . . . . . . . . . . . . 130
4.3.5 Mehrschichtiges Scheduling . . . . . . . . . . . . . . . . 131
4.3.6 Echtzeit Scheduling . . . . . . . . . . . . . . . . . . . . 132
4.4 Unterbrechungskonzept . . . . . . . . . . . . . . . . . . . . . . . 134
4.4.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.4.2 Unterbrechungsarten . . . . . . . . . . . . . . . . . . . . 135
4.4.3 Behandlung externer Unterbrechungen . . . . . . . . . . 137
4.4.4 Konflikte . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5 Speicherverwaltung 1415.1 Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
5.2 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
5.2.1 Adressräume . . . . . . . . . . . . . . . . . . . . . . . . 142
5.2.2 Organisation von Adressräumen . . . . . . . . . . . . . . 143
5.2.3 Fragmentierung . . . . . . . . . . . . . . . . . . . . . . . 150
5.2.4 Forderungen an Adressraumrealisierung . . . . . . . . . . 151
5.3 Speicherabbildungen . . . . . . . . . . . . . . . . . . . . . . . . 152
5.3.1 Direkte Adressierung . . . . . . . . . . . . . . . . . . . . 152
iii
Schlichter, TU München INHALTSVERZEICHNIS
5.3.2 Basisadressierung . . . . . . . . . . . . . . . . . . . . . . 154
5.4 Seitenadressierung . . . . . . . . . . . . . . . . . . . . . . . . . 156
5.4.1 Ansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
5.4.2 Adressabbildung . . . . . . . . . . . . . . . . . . . . . . 159
5.4.3 Seiten-Kacheltabelle . . . . . . . . . . . . . . . . . . . . 163
5.4.4 Seitenfehlerbehandlung . . . . . . . . . . . . . . . . . . . 166
5.4.5 Seitenverwaltungsstrategien . . . . . . . . . . . . . . . . 167
5.4.6 Linux - Virtuelle Adressierung . . . . . . . . . . . . . . . 172
5.5 Segment-Seitenadressierung . . . . . . . . . . . . . . . . . . . . 174
5.6 Speicherhierarchie / Caches . . . . . . . . . . . . . . . . . . . . . 175
5.6.1 Speicherhierarchie - Beispiel . . . . . . . . . . . . . . . . 175
5.6.2 Cache Speicher . . . . . . . . . . . . . . . . . . . . . . . 176
5.6.3 Caching in der Speicherhierarchie . . . . . . . . . . . . . 176
5.6.4 Realisierung von Caches . . . . . . . . . . . . . . . . . . 178
5.6.5 Cache freundlicher Code . . . . . . . . . . . . . . . . . . 182
6 Prozesskommunikation 1846.1 Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
6.2 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
6.2.1 Kommunikationsarten . . . . . . . . . . . . . . . . . . . 185
6.2.2 Verteilte Systeme . . . . . . . . . . . . . . . . . . . . . . 189
6.3 Nachrichtenbasierte Kommunikation . . . . . . . . . . . . . . . . 190
6.3.1 Elementare Kommunikationsmodelle . . . . . . . . . . . 190
6.3.2 Erzeuger-Verbraucher Problem . . . . . . . . . . . . . . . 196
6.3.3 Modellierung durch ein Petrinetz . . . . . . . . . . . . . . 196
6.3.4 Ports . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
6.3.5 Kanäle . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
6.3.6 Ströme . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
6.3.7 Pipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
6.4 Client-Server-Modell . . . . . . . . . . . . . . . . . . . . . . . . 204
6.5 Netzwerkprogrammierung . . . . . . . . . . . . . . . . . . . . . 207
6.5.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . 207
6.5.2 Server Protokoll . . . . . . . . . . . . . . . . . . . . . . 208
iv
Schlichter, TU München INHALTSVERZEICHNIS
6.5.3 Client Protokoll . . . . . . . . . . . . . . . . . . . . . . . 210
6.5.4 Bidirektionale Stromverbindung . . . . . . . . . . . . . . 210
6.5.5 Java Socket Class . . . . . . . . . . . . . . . . . . . . . . 211
6.5.6 Beispiel - Generische Client/Server Klassen . . . . . . . . 213
7 Dateisysteme 2187.1 Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
7.2 Charakteristika von Dateisystemen . . . . . . . . . . . . . . . . . 219
7.3 Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
7.4 Memory-Mapped Dateien . . . . . . . . . . . . . . . . . . . . . . 223
7.5 Verzeichnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
7.6 Schichtenmodell . . . . . . . . . . . . . . . . . . . . . . . . . . 225
7.6.1 Datenträgerorganisation . . . . . . . . . . . . . . . . . . 225
7.6.2 Blockorientiertes Dateisystem . . . . . . . . . . . . . . . 226
7.6.3 Dateiverwaltung . . . . . . . . . . . . . . . . . . . . . . 227
7.6.4 Virtuelles Dateisystem . . . . . . . . . . . . . . . . . . . 228
8 Ein-/Ausgabe 2298.1 Klassifikation von E/A-Geräten . . . . . . . . . . . . . . . . . . . 229
8.2 Schichten eines E/A-Systems . . . . . . . . . . . . . . . . . . . . 230
8.3 Geräteverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . 232
8.3.1 Gerätetreiber . . . . . . . . . . . . . . . . . . . . . . . . 232
8.3.2 Geräteunabhängige E/A . . . . . . . . . . . . . . . . . . 234
8.4 RAID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
8.5 Disk Scheduling . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
8.6 Multimedia Systems . . . . . . . . . . . . . . . . . . . . . . . . 243
8.6.1 Zustellung von Mediendaten . . . . . . . . . . . . . . . . 243
8.6.2 Eigenschaften von Multimedia Systemen . . . . . . . . . 244
9 Sicherheit in Rechensystemen 2469.1 Fragestellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
9.2 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
9.3 Schutzmechanismen . . . . . . . . . . . . . . . . . . . . . . . . 252
v
Schlichter, TU München INHALTSVERZEICHNIS
9.3.1 Anforderungen . . . . . . . . . . . . . . . . . . . . . . . 253
9.3.2 Ebenen des Zugriffschutzes . . . . . . . . . . . . . . . . 253
9.3.3 Schutzmatrix . . . . . . . . . . . . . . . . . . . . . . . . 254
9.3.4 Authentifizierung . . . . . . . . . . . . . . . . . . . . . . 259
9.4 Mobiler Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
9.4.1 Sandboxing . . . . . . . . . . . . . . . . . . . . . . . . . 260
9.4.2 Interpretation . . . . . . . . . . . . . . . . . . . . . . . . 261
9.4.3 Signed Code . . . . . . . . . . . . . . . . . . . . . . . . 261
10 Entwurf von Betriebssystemen 26210.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
10.1.1 Hauptaspekte . . . . . . . . . . . . . . . . . . . . . . . . 262
10.1.2 Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . 263
10.2 Schnittstellenentwurf . . . . . . . . . . . . . . . . . . . . . . . . 264
10.2.1 Leitlinien für den Entwurf . . . . . . . . . . . . . . . . . 264
10.2.2 Paradigmen der Systemaufrufschnittstelle . . . . . . . . . 265
10.3 Weitere Implementierungsaspekte . . . . . . . . . . . . . . . . . 268
10.3.1 Architektur . . . . . . . . . . . . . . . . . . . . . . . . . 268
10.3.2 Mechanismen vs. Policies . . . . . . . . . . . . . . . . . 268
10.3.3 Namensräume . . . . . . . . . . . . . . . . . . . . . . . 269
10.3.4 Statische - Dynamische Datenstrukturen . . . . . . . . . . 270
10.3.5 Verbergen der Hardware . . . . . . . . . . . . . . . . . . 270
10.3.6 Speicherplatz vs. Laufzeit . . . . . . . . . . . . . . . . . 271
10.4 Trends beim Entwurf von Betriebssystemen . . . . . . . . . . . . 272
11 Zusammenfassung 276
vi
Schlichter, TU München INHALTSVERZEICHNIS
• Prof. J. Schlichter
– Lehrstuhl für Angewandte Informatik / Kooperative Systeme, Fakultät fürInformatik, TU München
– Boltzmannstr. 3, 85748 GarchingEmail: schlichter@in.tum.de (URL: mailto:schlichter@in.tum.de)Tel.: 089-289 18654URL: http://www11.informatik.tu-muenchen.de/
1
Kapitel 1
Übersicht
Grundlagen der
Programmierung
Technische Grundlagen der
Informatik
Systemnahe Programmierung;
Betriebsysteme, verteilte Systeme
1.1 Ziele der Vorlesung
Diese Vorlesung beschäftigt sich mit den technischen Aspekten von Rechensyste-men und der Informationsverarbeitung, nämlich der systemnahen Programmie-rung im Zusammenhang mit Betriebssystemen. Dabei werden vor allem nichtverteilte Systeme betrachtet. Aspekte verteilter Systeme und Rechnernetze wer-den im Grundstudium einführend in der Vorlesung: "Grundlagen: Rechnernetzeund verteilte Systeme" (GRV) behandelt.
• Zunächst werden informell die Aufgaben und Eigenschaften eines Betriebssy-stem dargestellt. Daraus lassen sich die für die Vorlesung relevanten Begriffeableiten. Weiterhin wird kurz auf Hardware-nahe Programme eingegangen.
2
Schlichter, TU München 1.2. MOTIVATION
• Im nächsten Teil der Vorlesung erfolgt der Übergang von sequentiellen zuparallelen Systemen. Zu den Themen, die behandelt hier werden, gehören dieGrundlagenprobleme paralleler Systeme und die Verfahren, mit denen diesegelöst werden können: Modellierung des Systemverhaltens, Synchronisation,Verklemmungen.
• Im Anschluss daran werden Konzepte und Verfahren von Betriebssystemen,die der wesentliche Teil der Konkretisierung paralleler Systeme sind, behandelt.Insbesondere geht es um die Arbeitsspeicherverwaltung (Hauptspeicherverwal-tung, "main memory management"), die Prozessverwaltung und die Prozessor-zuteilung sowie Mechanismen zur Kontrolle der Nebenläufigkeit. Beispiele fürletztere sind Threads und Semaphore.
• Prozesse existieren nicht in Isolation, sondern die Kommunikation zwischen denProzessen ist von zentraler Bedeutung für Lösung vieler Problemstellungen.Der Austausch von Information zwischen Prozessen kann entweder speicher-basiert oder über Nachrichten erfolgen. Die nachrichtenbasierte Prozesskom-munikation ist gerade für verteilte Rechensysteme, wo Prozesse über ein Rech-nernetz miteinander kommunizieren, von großer Bedeutung. Wichtige Aspektesind hierbei das Client-Server Modell und die Netzwerkprogrammierung.
• Im Abschnitt Ein-/Ausgabe wird die Anbindung von peripheren Geräten durchdas Betriebssystem behandelt.
• Mit der rasanten Verbreitung des Internet und dessen Nutzung für private undgeschäftliche Transaktionen (E-Commerce und E-Business) steigt der Bedarfan sicheren IT-Systemen. Der Abschnitt behandelt nach einigen verbreiteten Si-cherheitslücken verschiedene Schutzmechanismen, wie Schutzmatrizen, Kryp-tosysteme und Authentifizierungsmechanismen. Eine vertiefte Behandlung die-ser Thematik erfolgt in verschiedenen Spezialvorlesungen zur IT-Sicherheit.
1.2 Motivation
Aufgabe der Informatik ist es, Rechensysteme zu entwickeln und diese Anwen-dern als leistungsfähige Hilfsmittel für Lösungen ihrer Informationsverarbei-tungsprobleme zur Verfügung zu stellen. Diese Aufgabe ist vielgestaltig, weit-reichend, kompliziert und komplex; sie führt im Zuge der Weiterentwicklung vonRechensystemen und im Zuge der wachsenden Nachfrage der Gesellschaft nachInformation fortwährend auf neue Fragestellungen, für die nach Antworten ge-sucht werden muss. Sie hat zudem dazu geführt, dass sich große Bereiche derIndustrie und der Wirtschaft mit dieser Aufgabe befassen. Im folgenden werden
3
Schlichter, TU München 1.2. MOTIVATION
zunächst die wichtigsten Anforderungen, die mit der Entwicklung von Rechensy-stemen erfüllt werden sollen, in Kürze genauer erklärt.
1.2.1 Anforderungen an Rechensysteme
Rechensysteme sind
offene, dynamische, technische Systeme
mit Fähigkeiten zur Speicherung und zur
Verarbeitung von Information, die für Anwendungen und Anwender nutzbarzur Verfügung gestellt werden sollen.
Offenes System
Ein Rechensystem R ist ein offenes System sagt zweierlei aus:
• R ist als System eine durch Zusammenfassung gebildete, abgegrenzte Einheit,wo zwischen innen (R) und außen (U(R)) unterschieden wird. Innen ist das,was zu R gehört, und außen ist das, was nicht zu R und damit zur UmgebungU(R) gehört.
• R hat eine (offene) Schnittstelle, mit der Einwirkungen von U(R) auf R undEinwirkungen von R auf U(R) möglich sind.
• Schnittstelle eines Rechensystems
4
Schlichter, TU München 1.2. MOTIVATION
Umgebung
U(R)
Rechensystem R
Schnittstelle R - U(R)
Zur Schnittstelle R - U(R) gehören z.B. die Benutzerinteraktionsschnittstelle,die Netzschnittstelle, die Schnittstelle zu externen Geräten (Sensoren).
• Sichten eines RechensystemsEs existieren verschiedene Sichten auf das Rechensystems R
– Außensicht vs. Innensicht. Die Außensicht, die von außen die Eigenschaftender R-U(R) Schnittstelle zeigt, und die Innensicht, welche die innerenEigenschaften von R präsentiert.
– Black-box Sicht vs. White-box Sicht. 1
Das System ist ein schwarzer Kasten (black box): Das System wird alseinzelner Gegenstand aufgefasst. Das System ist ein weißer Kasten (whitebox oder auch glass box): Für das Verständnis des Systems ist dessenZusammensetzung aus Komponenten wichtig.
– Sichten sind methodische Hilfsmittel für Systemanalysen:
∗ Komponenten haben Eigenschaften, die denen von Systemen entsprechen.Dies bedeutet, Komponenten können für sich als Systeme betrachtetwerden.∗ Verbindungen zwischen Komponenten beschreiben Abhängigkeiten zwi-
schen Komponenten.∗ Rekursive Aufteilungen in Komponenten bzw. Sub-Komponenten liefern
verfeinerte White-box Sichten.1(siehe Informatik I, Brügge)
5
Schlichter, TU München 1.2. MOTIVATION
∗ Zusammenfassungen und Abgrenzungen liefern Einheiten, für die Black-box Sichten möglich sind.∗ ⇒ Rekursion bei der Entwicklung und Analyse von Rechensystemen.
Die umrissene Vorgehensweise unter Anwendung der erklärten Systembe-griffe ist für Analysen großer Systeme geeignet, wenn sie iterativ (rekursiv)angewandt wird; sie ist insbesondere dann geeignet, wenn sie induktiv ange-wandt werden kann. Die Möglichkeiten hierfür ergeben sich aus den Eigen-schaften, die ein gegebenes System hat. Für ein Rechensystem R wird überdiese Möglichkeiten bei der Entwicklung von R entschieden. Die Vorgehens-weise bei der Entwicklung von R und die Vorgehensweise bei Analysen vonR stehen also in engem Zusammenhang.
Dynamisches System
Eigenschaften des Rechensystems R ändern sich mit der Zeit
⇒ Beschreibung des Verhaltens von R.
In diesem Zusammenhang werden wir Beschreibungsmöglichkeiten kennenler-nen, insbesondere Petrinetze. Diese dienen dazu das Verhalten von Prozessenund deren Interaktion zu spezifizieren. Ein Rechensystem erhält seine Fähigkeitenzu selbsttätigen Veränderungen seiner Eigenschaften mit entsprechenden Kompo-nenten; demnach sind für R aktive und passive Komponenten zu unterscheiden:Mit seinen aktiven Komponenten (z.B. CPU) führt R Aktionen aus, die Verän-derungen der Eigenschaften von R bewirken; die passiven Komponenten (z.B.Arbeitsspeicher) sind Hilfsmittel für diese Aktionen.
Technisches System
Das Rechensystem ist mit hardware- und softwaretechnischen Mitteln realisiert.R ist entweder ein mit technischen Mitteln realisiertes, reales System oder einkünstliches, artifizielles System, das die Eigenschaften hat, die es mit seinerEntwicklung und mit seinen Weiterentwicklungen erhält.
Informationsspeicherung und -verarbeitung
6
Schlichter, TU München 1.2. MOTIVATION
Information
Daten
Information
Daten
Nachricht
Wissen
Repräsentation Interpretation
Daten sind elementare Fakten, Aussagen und Sachverhalte. Sie sind leichtzu strukturieren, leicht maschinell zu erfassen und leicht zu übertragen. ImZusammenhang mit der Übertragung spricht man auch gerne von Nachrichten.Information sind Daten mit einer Bedeutung und einem Zweck; sie erfordertAnalyse, Konsens bzgl. Semantik und Interpretation. Die Semantic Web(URL: http://www.w3.org/2001/sw/) Initiative versucht, die syntaktische Web-Information um semantische Information zu ergänzen. Wissen ist Informationin einem bestimmten, für den Menschen relevanten Kontext; es ist schwierig,Wissen zu strukturieren, schwierig maschinell zu erfassen und zu verarbeiten.Weiterhin ist es schwierig Wissen zu übertragen, da es oft nur implizit existiert(siehe auch das neue Forschungsgebiet Wissensmanagement bzw. "KnowledgeManagement").
2
1.2.2 Struktur eines Rechensystems
2Unterscheidung zwischen implizites und explizites Wissen.
7
Schlichter, TU München 1.2. MOTIVATION
Datenbank World Wide Web Email
Shell Übersetzer Dateisystem
Betriebssystem
Maschinensprache
Mikroprogramme / festverdrahtete Programme
physische Komponenten und Geräte
Hardware
Systemprogramme
Anwendungs-
programme
In dieser Vorlesung werden wir uns besonders mit Aspekten der technischenInformatik beschäftigen, und zwar mit den Systemprogrammen (Betriebssysteme,Assembler, Kommunikation in verteilten Systemen) sowie der Schnittstelle zuder darunter liegenden Hardware. Die Vorlesung ist als eine Einführung indiesen Bereich zu interpretieren; eine detailliertere Behandlung von Hardware,Systemprogramme und verteilte Systeme erfolgt in weiterführenden Vorlesungen.Mikroprogramme dienen zur Realisierung der Maschinensprache; bei RISC-Rechnern (z.B. Sun Workstation) sind die Mikroprogramme oft festverdrahtet.
• Darstellung von Programmen in maschinennaher Form für bestimmte Anwen-dungen auch heute noch unerläßlich, beispielsweise für den Übersetzerbau, ein-gebettete Systeme oder für systemnahe Programmierung in Teilen des Betriebs-systems. Beispiele dafür sind Echtzeitanwendungen, aber auch Teile des Be-triebssystems wie Nachrichtenaustausch, low-level Speicherverwaltung. Ein-gebettete Systeme sind in Autos oder Handies zu finden. Beispielsweise ist inmodernen Autos bereits eine zweistelligen Anzahl von Prozessoren zu finden,die über einen internen Bus miteinander verbunden sind.
• Thema der Vorlesung ist systemnahe Programmentwicklung; darunter maschi-nennahe Programmierung und nebenläufige ("concurrent") Ausführung vonmehreren Teilabläufen⇒ Nichtdeterminismus. Dabei ergibt sich von selbst ei-ne neue Qualität der Programmierung: Nebenläufigkeit, d.h. zwei oder mehrereTeilabläufe finden gleichzeitig statt, beispielsweise CPU und Drucker. Neue
8
Schlichter, TU München 1.3. THEMEN DER VORLESUNG
Qualität insofern, als Nebenläufigkeit auch Nichtdeterminismus enthält. UnterNichtdeterminismus verstehen wir das willkürliche Auftreten von Abläufen undEreignissen (bedingt durch Einflüsse wie Last, Interaktion mit Benutzer).
1.3 Themen der Vorlesung
Diese Vorlesung beschäftigt sich
mit den technischen Aspekten von Rechensystemen und der Informationsver-arbeitung, insbesondere der Systemsoftware.
Dabei werden vor allem Strukturen, Abläufe und Dienste von Betriebssyste-men betrachtet. Der Fokus liegt auf nicht verteilte Systeme. Im Zusammen-hang mit der Prozesskommunikation wird auch ein Ausblick auf verteilte Sy-steme gegeben. Dienste sind Softwareeinheiten, die bestimmte Funktionali-täten bereitstellen. Ablauf ist eine Abfolge von Aktivitäten/Operationen. AlsTeil eines Ablaufs können die Operationen eines Dienstes aufgerufen werden.Ablauf hat einen Zeitbezug.
1.3.1 Laufzeitmodell
Bereitstellung eines indirekten Zugangs zur Rechnerhardware über eine Dienst-schicht. 3 Ziel dieser Schicht ist die Realisierung einer virtuellen Maschine.Virtualisierung kann sowohl zur Fehlervermeidung als auch zur Reduktion derKomplexität eingesetzt werden.
• Die in den Diensten bereitgestellten Abstraktionen stellen einen Rahmen fürdie Organisation von Anwendungen zur Laufzeit dar, d.h. ein Laufzeitmodell.
• Dienste des Laufzeitmodells: Systembedienung, Prozessmanagement, Prozes-sinteraktion, Datenhaltung, Gerätemanagement. Wichtige Fragestellungen dersystemnahen Programmierung sind:
a) welche Dienste gehören zu einem Laufzeitmodell?b) gibt es einen inneren Zusammenhang unter den Diensten?c) welche Dienstmenge ist unverzichtbar?d) wo werden die Dienste realisiert?
Beispielsweise werden die Dienste im Betriebssystemkern oder als Systempro-zesse realisiert, die im Benutzermodus ("user mode") ablaufen.3[nehmer2001 S27]
9
Schlichter, TU München 1.3. THEMEN DER VORLESUNG
• elementare Abstraktionen eines Laufzeitmodells. Prozesse sind beispielsweisedynamische Objekte, die Aktivitäten in einem Rechensystem repräsentieren.
Jeder Prozess ist definiert durch einen Adressraum A, eine darin gespeicherteHandlungsvorschrift H in Form eines sequentiellen Programms und einenAktivitätsträger T, der mit der Handlungsvorschrift verknüpft ist und sieausführt. Der Aktivitätsträger T wird oft auch als "Thread" bezeichnet. DasTripel (A, H, T) repräsentiert einen sequentiellen Prozess.
Elemente des Laufzeitmodells
– Adressräume = Abstraktion eines physischen Speichers. Unter einemAdressraum versteht man einen von der Speichertechnologie und den be-schränkten Ausbaumöglichkeiten physischer Speicher unabhängigen virtuel-len Speicher. Adressräume verschiedener Prozesse sind gegeneinander ab-geschottet. Innerhalb eines Adressraums können ein oder mehrere Threadsablaufen.
– Threads = Abstraktion eines physischen Prozessors. Ein Thread ist der Trägereiner sequentiellen Aktivität, die durch die Ausführung eines dem Threadzugeordneten Programms (Handlungsvorschrift) bestimmt ist. Parallelitätwird durch die Ausführung mehrerer Threads erreicht.
– Prozessinteraktion. Prozessinteraktion kann entweder speicherbasiert, d.h. esgibt gemeinsame Speicherbereiche, auf die die Prozesse (Threads) zugreifen,oder nachrichtenbasiert ablaufen. Im ersten Fall sind Mechanismen zur Syn-chronisation der Zugriffe auf den gemeinsamen Speicherbereich notwendig,um Inkonsistenzen zu vermeiden. Im letzten Fall haben die Prozesse getrenn-te Adressräume. Sie tauschen Informationen über Nachrichten aus. DieserAnsatz wird vor allem in verteilten Rechensystemen verwendet, wo Prozesseüber ein Rechnernetz miteinander kommunizieren.
1.3.2 Inhaltsübersicht
Im einzelnen werden in der Vorlesung die folgenden Themen behandelt:
1. Übergang von sequentiellen Systemen zu parallelen Systemen: Verhaltensbe-schreibungen mit Hilfe von Spuren und Petrinetzen, Synchronisationskonzepte.Hier steht vor allem die Interaktion zwischen den Komponenten des Rechensy-stems im Vordergrund. Daneben wird auch die speicherbasierte Prozessinterak-tion behandelt, d.h. das gemeinsame Nutzen von Daten. Hier kommen Sema-phore und Monitore zum Einsatz. Ein wichtiger Aspekt ist die Behandlung vonVerklemmungen, d.h. Prozesse blockieren sich gegenseitig.
10
Schlichter, TU München 1.4. LITERATURÜBERSICHT
2. grundlegende Betriebssystemkonzepte: Prozessverwaltung, Prozessorzutei-lung, Arbeitsspeicherverwaltung, Dateisysteme. Bei der Arbeitsspeicherver-waltung steht vor allem der virtuelle Speicher in Form der Seitenadressierungim Vordergrund. Bei Dateisystemen wird neben allgemeinen Anforderungenauch ein Schichtenmodell kurz vorgestellt.
3. Prozesskommunikation - speicherbasiert und nachrichtenbasiert. Zunächstwerden die verschiedenen Kommunikationsarten vorgestellt, wobei wir uns vorallem auf die nachrichtenbasierte Kommunikation konzentrieren, z.B. Ports undSockets.
4. Sicherheit in Rechensystemen: Schutzmechanismen, Zugriffskontrolllisten,Capability-Listen, Kryptographie, Authentifizierung. In diesem Abschnitt stehtdie Sicherheit in Rechensystemen im Vordergrund, und zwar sowohl in lokalenals auch in verteilten Systemen.
Programmiersprachen
In der Vorlesung wird vor allem die Programmiersprache Java verwendet.Daneben, wenn notwendig, Verwendung von
• C Programmiersprache: zur Spezifikation von systemnahen Programmstücken.
– entwickelt zwischen 1969 und 1973 von Dennis Ritchie bei Bell Labs
– C und Unix sind eng miteinander verbunden
– C ist eine einfache, kleine Sprache
– C war und ist noch eine wichtige Sprache für systemnahe Programmierung
– C bedingt jedoch einige Fehleranfälligkeiten, z.B.dynamische Speicherbelegung und -freigabe. (malloc, free)Pointerarithmetik. (Addieren einer ganzen Zahl zu einem Pointer)
1.4 Literaturübersicht
Literatur, die als Basis für die Vorlesung verwendet wird.
11
Schlichter, TU München 1.4. LITERATURÜBERSICHT
1.4.1 Begleitend zur Vorlesung
• Andrew S. Tanenbaum, "Modern Operating Systems", Prentice Hall, 2014; esgibt eine ältere deutsche Übersetzung
Andrew S. Tanenbaum, "Moderne Betriebssysteme", Pearson Studium,2009
• Abraham Silberschatz, Peter Galvin, Greg Gagne, " Operating SystemConcepts. Operating System Concepts", Wiley & Sons, 2012 4
1.4.2 Weiterführende Literatur
• Albrecht Achilles, "Betriebssysteme - Eine kompakte Einführung mit Linux",Springer, 2006
• Uwe Baumgarten, Hans-Jürgen Siegert, "Betriebssysteme", Oldenbourg, 2006
• Rüdiger Brause, "Betriebssysteme - Grundlagen und Konzepte", Springer, 2013
• Eduard Glatz, "Betriebssysteme - Grundlagen, Konzepte, Systemprogrammie-rung", dpunkt.verlag, 2015
• Jürgen Nehmer, Peter Sturm, "Systemsoftware - Grundlagen modernerBetriebssysteme", dpunkt.verlag, 2001
• Randal E. Bryant, David R. O’Hallaron, "Computer Systems - A Programmer’sPerspective", Pearson Education, 2015 (detaillierte Diskussion von CacheSpeicher und deren Verwaltung)
• William Stallings, "Operating Systems - Internals and Design Principals",Pearson International Edition, 2011
• George Coulouris, Jean Dollimore, Tim Kindberg, "Distributed Systems -Concepts and Design", Addison-Wesley, 2012 (Neuausgabe 5. Edition)
• Andrew S. Tanenbaum, Marten van Steen, "Verteilte Systeme - Grundlagen undParadigmen", Pearson Studium, 2007 (2. Auflage)
• Elliote Rusty Harold, "Java Network Programming", O’Reilly, 2013 (seit 2009auch als eBook Kindle erhältlich)42010 ist eine Variante erschienen als " Operating System Concepts with Java Operating
System Concepts with Java" (8. Edition).
12
Schlichter, TU München 1.4. LITERATURÜBERSICHT
• Ralph Morelli, Ralph Walde, "Java, Java, Java - Object-Oriented ProblemSolving", Prentice Hall, 2005 (Aspekte von Java Netzwerkprogrammierung)
• Claudia Eckert, "IT-Sicherheit: Konzepte - Verfahren - Protokolle", OldenbourgVerlag, 2014
13
Kapitel 2
Einführung
Definition eines Betriebssystems nach DIN 44300:
Das Betriebssystem wird gebildet durch die Programme eines digitalenRechensystems, die zusammen mit den Eigenschaften der Rechenanlage dieGrundlage der möglichen Betriebsarten des digitalen Rechensystems bildenund insbesondere die Ausführung von Programmen steuern und überwachen.
Diese Definition geht also von der Beschreibung seiner Aufgabe und seinerStellung in einer Programmhierarchie aus.
2.1 Betriebssystem - Überblick
Ein Betriebssystem realisiert die Schnittstelle zwischen dem Benutzer und derphysischen Rechenanlage. Aus der Sicht des Benutzers entsteht durch ein Be-triebssystem eine virtuelle Maschine. Für einen Benutzer ist es nicht wichtig, ob ineinem Rechensystem Systemfunktionen durch Hardware oder Software realisiertsind. Ein Betriebssystem realisiert insbesondere eine Benutzerschnittstelle. DerEntwurf und die Implementierung von Betriebssystemen gehören zu den klassi-schen Aufgabenstellungen der Systemprogrammierung. Je nach Art der Hardwaregibt es sehr unterschiedliche Typen von Betriebssystemen. Sie reichen von Be-triebssystemen für Großrechner, über Server-BS bis hin zu PC-Betriebsystemenund eingebetteten Betriebssystemen (z.B. in einem Android Smartphone). Andro-id ist fuer den Nutzer weitgehend unsichtbar. Im Vordergrund steehn die Apps,mit denen er interagiert.
14
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
2.1.1 BS-Hauptaufgaben
Ein Betriebssystem (engl. operating system) erfüllt folgende Hauptaufgaben:
• Veredeln der Hardware (Virtualisierung).
• Steuerung und Kontrolle der Programmausführung. Dazu werden die beidenBetriebsmittel CPU und Arbeitsspeicher geeignet den Programmen zugeteilt.Zur Durchführung dieser Aufgabe ist eine Prozessverwaltung (die imSystem momentan auszuführenden Programme) und eine Benutzerverwaltungnotwendig.
• Interprozesskommunikation. Prozesse können mit anderen Prozessen Informa-tionen austauschen. Die Prozesse können entweder auf dem gleichen Rechner(lokal) oder auf anderen Rechner im Rechnernetz (verteilt) ausgeführt werden.
• Verwaltung der Ressourcen (Speicher, CPU, Platten, Netz etc.)⇒ Betriebssy-stem kann als Ressourcenverwalter gesehen werden. 1
Damit stellt sich die Frage: Sind Ressourcen überhaupt knapp, oder können aus-reichend viele bereitgestellt werden? Phasen der Ressourcenverwaltung: Anfor-derung, Zuteilung, Nutzung, Freigabe/Entzug/Aufräumen. Die Benutzung derEin-/ Ausgabegeräte sowie des Netzanschlusses erfolgt stets über das Betriebs-system.
– RessourcenklassenEin Rechensystem kann als strukturierte Sammlung von Ressourcenklassenbetrachtet werden, wobei jede Klasse durch Dienste des Betriebsystemskontrolliert wird. 2
Zentral Ressourcen Periphere Ressour-cen
Aktive Ressourcen Prozessoren (CPUs) Kommunikationseinheitenwie Endgeräte ( Tasta-tur, Drucker, Monitor,Maus) und Netzwerk(lokal, entfernt)
Passive Ressourcen Arbeitsspeicher Speichereinheiten wieFestplatten, CD, DVD
1Man spricht oft auch von Betriebsmittelverwalter.2Glatz S3
15
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
• Anbieten von Diensten in Form von Schnittstellen, so dass die Ressourcengenutzt werden können ⇒ Hardwareunabhängige Programmierschnittstelle,z.B. geräteunabhängige Ein-/Ausgabefunktionen. Programme können aufdiese Weise unverändert auf verschiedenen Rechensystemen mit Gerätenunterschiedlicher Hersteller ablaufen.
• Sicherheitsmechanismen. Darunter fallen Funktionen wie fehlerfreie Datenver-arbeitung und Datenschutzkonzepte, z.B. Zugangskontrolle zum Rechner oderZugriffskontrolle auf Dienste oder Dateien. Unterscheidung zwischen
Authentifizierung: wer ist er?
Autorisierung: was darf er?
• Arbeitsmodi des BetriebssystemsOperationen des Betriebssystems und der Hardware müssen vor Programmier-fehlern in Anwendungsprogrammen geschützt werden⇒ Einführung eines Pri-vilegiensystems.
Benutzermodus (user mode): Ausführung von Benutzerprogrammen,kein direkter Hardware-Zugriff, keine privilegierten Befehl, nur virtuelleAdressen.
Systemmodus (kernel mode): Ausführungsmodus der Dienste des BS-Kerns, privilegierte Befehle erlaubt. Beispiele von privilegierten Befehlensind das Anhalten des Rechners, Zugriff auf Prozesskontrollblock (Pro-zessbeschreibung), direkter Zugriff auf Hardware, insbesondere Geräte.
Benutzermodus Systemmodusbegrenzte Auswahl von Maschinen-befehlen
alle ausführbaren Maschinenbefehle
Hardwarezugriff nur über BS Vollzugriff auf Hardwarekein bzw. nur lesender Zugriff aufSystemcode oder Daten
exklusiver Zugriff auf Systemcodeund Daten
Schreibzugriffe auf Systemcode sind nur im Systemmodus möglich. Wennim Systemmodus auf Systemcode/Systemdaten zugegriffen wird, kann parallelkein anderer Zugriff darauf (auch kein lesender) erfolgen.
16
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
Benutzerprozess
Betriebssystemkern
Ausführung
Benutzerprozess
System
Aufruf
Ausführung
Systemdienst
Rückkehr von
System AufrufBenutzermodus
Systemmodus
Bei Ausführung des Benutzerprozesses befindet sich das System im Benutzer-modus. Falls ein Dienst des Betriebssystemkerns notwendig ist, z.B. Zugriff aufein Gerät, muss vorher in den Systemmodus gewechselt werden. Beim Rech-nerboot wird zunächst im Systemmodus gestartet. Das Betriebssystem wird ge-laden; anschliessend werden die Benutzerprogramme im Benutzermodus gest-artet.
• Struktureller Aufbau
17
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
Speicher
verwaltung
Prozess
verwaltung
Datei
system
Scheduler &
Dispatcher
EA-
System
Unterbrechungs-
System
Hardware
Konfiguration
Betriebssystem-Schnittstelle
Z
u
g
a
n
g
s
k
o
n
t
r
o
l
l
e
Benutzer-
Prozesse
System-
Prozesse
Schnittstelle zur Systemumgebung
berechtigte
Benutzer
berechtigte
Benutzer
login
zu überprüf.
Benutzer
Aus dem strukturellen Aufbau sind auch die wichtigsten Aufgaben und Funk-tionen eines Betriebssystems ersichtlich. Dabei ist auch festzulegen, welcheDienste im Betriebssystemkern und welche Dienste über Systemprozesse reali-siert werden.
• Ein anderer BlickwinkelNY Times, Sept, 3, 1997: A decade ago, an "operating system" was just thebasic piece of software that ruled the machine and allowed it to manipulatefiles, converse with any peripherals, and start up programs. That was when acomputer was just a nerd toy, not the foundation for the most vital part of ofour economy. But today, an "operating system" is much more a vote over whogets to be the richest men in the world. Windows means Microsoft, Java meansSun, while MacOs means That Steve Jobs won’t go broke saving Apple. Linuxmeans no one gets rich because the OS is free, thanks to the help of many
18
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
volunteers. 3
2.1.2 Systemprogrammierung
Die Programmierung eines Betriebssystems gehört zu dem Bereich der System-programmierung.
• DefinitionDie Systemprogrammierung befasst sich mit der Darstellung, der Realisierung,den Eigenschaften und der Konstruktion derjenigen Algorithmen für einRechensystem, die die Bearbeitung und Ausführung von Benutzerprogrammenunter vorgegebenen Qualitätsgesichtspunkten organisieren, d.h. steuern undkontrollieren, und zum Teil selbst durchführen.
direkte Nutzung der generischen Systemprogrammierschnittstelle des BS.
meist in Programmiersprache C.
generischen Systemprogrammierschnittstelle bedeutet eine allgemeine Schnitt-stelle, d.h. alle Applikationen haben die gleiche Schnittstelle; im Gegensatz zuanwendungsspezifischen Schnittstellen.
• Qualitätskriterien können z.B. sein:
– Zuverlässigkeit der durchgeführten Berechnung (Behandlung von System-crashs, Netzausfällen, fehlerhafter Nachrichtenübermittlung etc.).
– Effizienz und Performanz einerseits systemglobal, d.h. es wird versucht,das System optimal auszulasten, andererseits Auftrags-lokal, z.B. es wirdversucht, zu garantieren, dass eine Auftragsbearbeitung nicht übergebührlichlange verzögert wird. Dabei soll auch die unfaire Behandlung von Prozessenvermieden werden, d.h. jeder Prozess soll nach einer gewissen Wartezeitrechnen können.
– Einhaltung von Realzeitanforderungen: zeitkritische Aufträge besitzen z.B.eine Deadline bis zu der sie ausgeführt sein müssen. Ein Beispiel sindVideoströme, die die Frameraten für die Anzeige von Bildern einhaltenmüssen.
– Durchsetzung von Sicherheitsanforderungen: Schutz der Daten und Informa-tionen vor unberechtigten Zugriffen und Einsichtnahme.
3Welche Perspektive ist zukünftig relevant? Am mächtigsten ist derjenige, der dieInformationen verwaltet - Google? Oder am mächtigsten ist derjenige, der die sozialenBeziehungen verwaltet - Facebook?
19
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
– Benutzerfreundlichkeit: bequeme Formulierungsmöglichkeit von Benutzer-aufträgen.
2.1.3 Hardwarekomponenten
Das Betriebssystem ist sehr eng mit der Hardware des Rechensystems verknüpft,auf dem es ausgeführt wird. Es erweitert den Befehlssatz des Rechners undverwaltet seine Ressourcen.
Deshalb an dieser Stelle einen kurzen Überblick über den Aufbau einesRechensystems. (Detaillierte Erklärungen zum Aufbau von Rechensystemenwurden in der Vorlesung Einführung in die Technischen Grundlagen behandelt.)Als Beispiel wird hier kurz der Aufbau eines Intel PC’s präsentiert. Daraus erkenntman, dass ein Rechner unterschiedlicher Bussysteme mit unterschiedlichenGeschwindigkeiten integriert. Daneben gibt es noch weitere Busse wie SCSI fürden Anschluss Festplatten und anderen Geräten, sowie IEEE 1394 - Firewire fürden Anschluss von Multimedia Geräten z.B. digitale Kamera.
CPU
Drucker
Northbridge Arbeitsspeicher
Systembus Speicherbus
USB
AGP
PCI Bus
EA-Karte
Grafik
EA-Karte
Sound
Southbridge
IDE
Festplatte
ISA Bus
(Maus,
Tastatur)
EA-Karte
LAN
20
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
PCI = Peripheral Component InterconnectISA = Industry Standard ArchitectureUSB = Universal Serial BusAGP = Accelerated Graphics Port (Anschluss von schnellen Grafikkarten).Der AGP Bus soll den Zugriff schneller Grafikkarten auf den Arbeitsspeicherbeschleunigen. Alternativ existiert PCI-Express.
Der Systembus unterteilt sich weiterhin in den Adressbus, Datenbus undSteuerbus. Die Anzahl der parallelen Leitungen des Adressbusses (32bit oder64bit) bestimmen auch die maximale Größe des Programmadressraums. Intelbezeichnet die Southbridge auch als I/O Controller Hub, die Northbridge alsMemory Controller Hub.
2.1.4 Betriebsarten
Beim Betrieb von Rechenanlagen können bzgl. des Zusammenwirkens von Be-nutzer und Rechensystem die Betriebsweisen Stapelverarbeitung, Dialogbetrieb,Transaktionsbetrieb und Echtzeitbetrieb unterschieden werden.
• StapelbetriebDas Rechensystem verarbeitet Ströme von Auftragspaketen (engl. batch pro-cessing). Ein Benutzer deklariert vollständig alle Teile eines Auftragspaketes,bevor es in das System eingegeben wird. Anschließend wird das Auftragspa-ket durch das Rechensystem abgearbeitet, ohne dass der Benutzer noch Ein-flussmöglichkeiten hat. Bei Auftreten eines Fehlers muss i.a. nach der Korrekturdas gesamte Auftragspaket nochmals gestartet werden. Auftragspakete könnenin Unterabschnitte zerfallen, z.B. Teilprogrammabläufe. Diese Betriebsart warin den Anfängen von Rechenanlage sehr verbreitet (Nutzung von Lochkartenund Lochstreifen).
• DialogbetriebIm Dialogbetrieb (engl. Timesharing) erteilt der Benutzer dem Betriebssystemeinen Auftrag nach dem anderen im Dialog. Innerhalb eines Benutzerauftragsfindet eine Interaktion zwischen dem Benutzer und der Systemumgebungstatt (z.B. Eingabe weiterer Daten, Ausgabe von Zwischenergebnissen). DerDialogbetrieb erfordert eine besondere Gestaltung der Benutzerschnittstelle.Oft wird Betriebssystem und Benutzerschnittstelle (engl. user interface) ineinem Atemzug genannt und auch oft gleichgesetzt. Beide sind jedoch getrenntvoneinander zusehen. Beispielsweise existierten mit dem X11-Windowsystemund Sun Windowsystem (auf der Basis von Postscript) zwei unterschiedlicheBenutzerschnittstellen auf demselben Betriebssystem.
21
Schlichter, TU München 2.1. BETRIEBSSYSTEM - ÜBERBLICK
• TransaktionsbetriebBewältigung einer Vielzahl von kleinen Aufgaben in kürzester Zeit, z.B.Banküberweisungen oder Buchungen. Dabei muss die Bearbeitung folgendeKriterien, wie sie auch von Datenbanken bekannt sind, erfüllen: Atomarität,Konsistenz, Isolation, Dauerhaftigkeit (engl. ACID), d.h. die Bearbeitung mussentweder vollständig ablaufen oder keinerlei Änderung verursachen (Alles-oder-nichts Prinzip).
• EchtzeitbetriebIn der Prozesssteuerung (automatische Fertigungssysteme, Roboter) und imMultimediabereich sind die Reaktionszeiten des Betriebssystems von großerBedeutung. Dies erfordert spezielle Mechanismen bei der Behandlung vonEreignissen und Unterbrechungen sowie der CPU-Zuteilung an rechenbereiteProzesse / Threads. Beispielsweise ein Videoserver (bei Nutzung des StreamingAnsatzes) benötigt ein Betriebssystem, das gewisse Echtzeitfähigkeiten hat.Videos müssen mit einer bestimmten Geschwindigkeit abgespielt werden. DieBilder dürfen an das Abspielprogramm nicht zu langsam (ansonsten ruckeltdas Videobild) und nicht zu schnell ausgeliefert werden (sonst gehen beiPufferüberlauf Videobilder verloren). Unterscheidung zwischen
harte Echtzeitsysteme: Reaktionszeit darf nicht überschritten werden. Einezu späte Reaktion kann zu ernsthaften Problemen führen, z.B. bei derSteuerung eines Atomreaktors.
weiche Echtzeitsysteme: gewisse Toleranzen bzgl. der Abweichungsind erlaubt. Bei Audio und Multimedia-Systemen werden gewisseAbweichungen von der Reaktionszeit toleriert.
2.1.5 Historie
Betriebssysteme haben sich über die Jahre hinweg ständig weiterentwickelt.Faktoren für die Entwicklung von Betriebssystemen:
Fortschritte der Hardwaretechnologie.Preis - Leistungs - Verhältnis.Übergang von numerischer Berechnung zur allgemeinenInformationsverarbeitung.neue Anwendungsbereiche und Öffnung für Nichspezialisten. Ein Beispielist die Nutzung von Rechnern als eingebettete Systeme im Auto sowie ihreNutzung in Mobiltelefonen oder Smartphones.
• 1. Generation 1945 - 55: Arbeiten an leerer Rechenanlage. Es war praktischkein Betriebssystem vorhanden. Es gab ein sehr rudimentäres Betriebssystem
22
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
(nur Steuerung der Ein-/Ausgabe, es wird deshalb auch nicht als Betriebssystembezeichnet). Ein Benutzer hatte den Rechner für sich. Die Programmierungerfolgte in Maschinensprache. Lochkarten und Lochstreifen brachten einegewisse Verbesserung. Beispielrechner sind die Zuse Z3, ENIAC, oder diePERM an der TUM.
• 2. Generation 1955 - 65: Stapelbetrieb ohne parallele Verarbeitung vonProgrammen. Programme wurden als Lochkartenstapel eingelesen; auf dieseWeise wurden Jobs sequentiell abgearbeitet. Damals gab es auch noch denBeruf des Operateurs. Beispiel: Betriebssystem der Telefunken TR4.
• 3. Generation 1965 - 80: Mehrprogrammbetrieb, Spooling auf Platten, Nutzungvon Dateisystemen, Dialogbetrieb. Unterstützung von Unterbrechungen undASP-Organisation für Mehrprogrammbetrieb. Beispiele: Multics (Vorläufervon Unix), Unix V6, DEC VMS.
• 4. Generation ab 1980: Integration des Personal Computing, graphische Be-nutzeroberflächen, Netzwerkunterstützung, Multimedia. Beispiele: Windows,MacOS, Linux.
• 5. Generation ab 2000: eingebettete Systeme und Chipkarten, Unterstützungmobiler Plattformen für ubiquitäre Nutzung, BS-Unterstützung gemäß demSchlagwort: Das Netz ist der Computer. Beispiele: ChromeOS, Android, iOS.
Neben den Betriebssystemen für Großrechner, Server und Arbeitsplatzrechnerhaben sich auch Betriebsysteme für eingebettete Systeme und Chipkarten ent-wickelt. Diese Systeme besitzen meist die Eigenschaften von Echtzeitbetriebssy-stemen, sind aber zusätzlich noch auf geringe Größe, einen kleinen Arbeitspeicherund geringen Stromverbrauch ausgelegt.
2.2 Betriebssystem-Architektur
In der Praxis findet man einige verschiedene BS-Architekturkonzepte, wobei dermonolithische Ansatz und zunehmend auch der Mikrokern-Ansatz am weitestenverbreitet sind.
2.2.1 Monolithischer Ansatz
Das Betriebssystem besteht aus einer umfangreichen Menge an Funktionen,die sich bei Bedarf gegenseitig aufrufen können. Die Funktionen werden in
23
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
einem großen BS-Kern zusammengefasst. Der BS-Kern wird durch Aufrufvon Systemdiensten betreten. Der BS-Kern hat i.a. nur wenig Struktur. AlsGrundstruktur kann man von 3 Schichten ausgehen: a) die Hauptprozedur, b)den Systemfunktionen, die von der Hauptprozedur aufgerufen werden, sowie c)den Hilfsfunktionen. Unix kann als BS mit einer monolithischen Architekturbetrachtet werden.
BS-Kern arbeitet im Systemmodus.
Er hat hohe Ablaufpriorität. Oft läuft er unter kompletter Unterbrechungssper-re.
Er ist permanent im Arbeitsspeicher.
Anwendung
Benutzerprozess
Anwendung
Benutzerprozess
Benutzer-Modus
(User Mode)
System-Modus
(Kernel Mode)Systemdienste
(Hauptprozedur)
Hardware
Hilfs
funktionen
• komplexe, monolithische Betriebssystem sind sehr schwierig zu warten undzu erweitern. Es ist oft schwierig nachzuvollziehen, welche KonsequenzenÄnderungen von Systemdiensten bzw. Hilfsfunktionen im Betriebssystemnach sich ziehen. Dies bezieht sich vor allem auf die Synchronisation vonnebenläufigen Zugriffen und die Nutzung von Ressourcen. Es sind oft vieleDetailkenntnisse des gesamten Betriebssystems notwendig.
• Geschichtete Systeme
24
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
Einen Ausweg aus der Problematik monolithischer Systeme bieten geschichteteSysteme;
das Betriebssystem besteht aus einer Hierarchie abstrakter Maschinen.
Jede Schicht hat wohldefinierte Schnittstellen und eine wohldefinierteAufgabe
⇒ Reduktion der Systemkomplexität.
Geschichtete Systeme ermöglichen die Realisierung von Systemfamilien, d.h.ein neues Familienmitglied (und damit eine neue Plattform für Anwendungen)kann mit vergleichsweise geringem Aufwand auf irgendeiner abstraktenMaschine aufgesetzt werden. Unter der Voraussetzung, dass die Schnittstellenpräzis und in sich konsistent festgelegt wurden, kann jede abstrakte Maschineunabhängig von anderen erstellt werden. Dies bietet auch die Möglichkeit,einzelne Schichten durch neue Implementierungen zu ersetzen, solangeSchnittstelle und Aufgabe eingehalten werden. Gerade im Bereich derRechnernetze spielt das Schichtenkonzept eine sehr wichtige Rolle (sieheISO/OSI Referenzmodell oder TCP/IP Referenzmodell).
Anwendungen
abstrakte Maschine N
Funktionsschnittstelle
abstrakte Maschine N - 1
Funktionsschnittstelle
abstrakte Maschine 0
Funktionsschnittstelle
Rechnerhardware
Schicht N
Schicht N-1
Schicht 0
25
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
2.2.2 Mikrokern-Ansatz
Der Trend moderner Betriebssystem geht hin zu einem Mikrokern-Ansatz.Im Mikrokern sind nur mehr Basismechanismen, z.B. Prozesskommunikation(Austausch von Nachrichten), CPU-Zuteilung. Möglichst viele Subsystemesind als Systemprozesse außerhalb des Mikrokerns realisiert. Sie laufen imBenutzermodus ab, z.B. Dateisystem, Speicherverwaltung. Verwaltungsdienste,z.B. Strategien zur Speicherverwaltung oder Prozessverwaltung (z.B. Zuteilungvon Prioritäten) laufen im Benutzermodus. Man spricht im Zusammenhangmit diesem Ansatz auch von einer Client/Server-Struktur. Systemfunktionenwerden als Serverprozesse im Benutzermodus ausgeführt. Benötigt ein Prozess(Client) eine Dienstleistung schickt er eine Anforderung an einen anderenProzess (Server), der die Dienstleistung erfüllt und die Antwort an den Clientzurückgibt. Die Kommunikation zwischen den beteiligten Prozessen erfolgt überden Mikrokern. Durch die Ausgliederung in Serverprozesse ist eine Trennung vonMechanismus und Strategie möglich. Die Strategien werden in Serverprozessenim Benutzermodus realisiert, während der Mikrokern wenige Basismechanismenumfasst. Ziel ist, das der BS-Kern nur für kurze Zeit blockiert sein soll.
Einfaches Austauschen von Subsysteme ⇒ ermöglicht die einfache Anpas-sung von Systemanforderungen.
Benutzer-Modus
(User Mode)
System-Modus
(Kernel Mode)
Mikrokern
Hardware
Benutzer
Programm
Prozess
Server
Memory
Server
File
Server
Netzwerk
Server
Display
Server
Anforderung
Antwort
Vorteile des Mikrokernansatzes sind
Bereitstellung einer einheitlichen Schnittstelle für alle Requests,
Flexibilität, Erweiterbarkeit, Portabilität (Prozessor-spezifischen Codeanteilesind im Mikrokern),
leichte Unterstützung verteilter Systeme.
26
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
Nachteil ist der zusätzliche Zeitaufwand, da die Systemkomponenten überNachrichten miteinander kommunizieren, die über den Mikrokern propagiertwerden.
2.2.3 Beispiel: BS-Architekturen
Unix Betriebssystem
Die nachfolgende Abbildung skizziert die wesentlichen Komponenten desUnix Betriebssystems. Der Unix-BS-Kern enthält die Datei-, Prozess- undProzessorverwaltung, die Speicherverwaltung und die Geräte-Treiber. ZurNutzung beispielsweise der Systemdienste des Dateisystems bietet das BS u.a.die Dienste open, read, write, close an. Bibliotheken enthalten u.a. dieRoutinen für Standard-Ein/Ausgabe sowie malloc-Funktion zur dynamischenSpeicherverwaltung.
Hardware
Geräte Treiber
Datei
System
Unterbrechungs
behandlung
Prozess
verwaltung
Prozessor
verwaltung
Arbeitsspeicher
verwaltung
Systemschnittstelle
u.a. open,close, read, write; fork, exec, kill, ...
Programme ShellsBibliotheken
(z.B. lib.a)
Betriebs-
systemkern
Programmier-
schnittstelle
Benutzungs-
schnittstelle
Windows NT Betriebssystem
Mit Hilfe von HAL wird versucht, die meisten Maschinenabhängigkeiten zuverbergen. HAL präsentiert dem restlichen BS abstrakte Hardwaregeräte (z.B.Systembus, Arbeitsspeicher etc). Der Kernel ist kein Mikrokern. Zielsetzung desKernels ist die vollständige Hardware-Unabhängigkeit, und damit sehr portable
27
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
BS-Komponenten höherer Ebene. Der Kernel besteht aus Control-Objects (z.B.primitive Prozessobjekte, Unterbrechungsobjekte) und Dispatcher-Objects (z.B.Semaphore, Ereignisse, Timer). Der Kernel ist auch zuständig für das Schedulingvon Threads. Der Objektmanager verwaltet alle Systemobjekte (z.B. Prozesse,Threads, Dateien, Semaphore). Der Prozessmanager ist für die Erzeugung,Verwaltung und Löschung von Prozessen und Threads verantwortlich. Die LocalProcedure Call Facility realisiert eine effiziente Interprozess-Kommunikationzwischen den Subsystemen. Die System Services stellt die Schnittstelle zumExecutive bereit. Daneben gibt es noch einige weitere Manager wie PowerManager, Cache Manager und Plug-and-play Manager. 4
Hardware
Hardware Abstraction Layer (HAL)
Kernel
Object
Manager
Security
Manager
Process
Manager
Local
Procedure
Call Facility
Virtual
Memory
Manager
System Services
I/O Manager
File
SystemsCache Mgr
Device
DriversNetwork
Drivers
Hardware Manipulation
User Mode
Kernel Mode
Win32
Subsystem
Security
Subsystem
OS/2
Subsystem
Posix
Subsystem
Logon
ProcessOS/2 Client Win32 Client Posix Client
Systemaufrufe
NT Executive
Protected
Subsysteme
(Servers)
Applications
System Interface (DLL)
Nachfolgende Betriebssystem Versionen wie Windows XP, Windows Vista, Win-dows 7 und Windows 8 haben auf dieser Abstraktionsebene eine ähnliche Struk-tur. Windows 10 besitzt eine Architekturmischform: Elemente der Mikrokernideeals auch der geschichteten Strukturierung. Windows 10 ist in C und z.T in C++programmiert.
4Eine ausführliche Behandlung von Windows 2000 ist in [Tanenbaum2001, S763] zu finden.
28
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
Linux Betriebssystem
Linux begann Anfang der 1990er Jahre als eine Unix Variante für den IBM PC;
erste Version durch Linus Torvalds (1991).
Linux ist frei und Quellcode ist verfügbar.
kollaborative Weiterentwicklung durch Open Source Community.
• kein Mikrokern-Ansatz, jedoch modulare Struktur.
dynamic linking. Linux besteht aus einer Sammlung von Moduln, diedynamisch geladen und ausgeladen werden können (je nach Bedarf). EinModul des BS-Kerns kann bei Bedarf in den Kern geladen und verlinktwerden. Auf diese Weise bleiben die Vorteile des Mikrokern-Ansatzeserhalten. Jederzeit kann ein Modul wieder ausgeladen, und damit vomaktuellen BS-Kern entfernt werden.
Module sind hierarchisch organisiert. Zwischen Moduln auf unterschiedli-chen Schichten bestehen Dienstaufrufbeziehungen, d.h. ein Client Modulreferenziert eine Bibliothek der unteren Schicht.
• jeder Modul ist durch 2 Datenstrukturen beschrieben.
Modulbeschreibung, u.a Modulname, Größe, Zahl der exportierten Symbo-le und referenzierte Module. Die Modulbeschreibungen sind untereinanderzu einer Liste verbunden.
Symbol-Tabelle. Liste der Symbole, die im Modul definiert sind und durchandere Komponenten verwendet werden.
29
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
Prozesse
Processes &
scheduler
System
callsSignals
Virtual
memory
Traps
faults
Physical
memory
device driver
(Char)
Interrupt
Device driver
(Block)
File systemNetwork
protocols
Network
driver
user mode
kernel mode
CPU Main memory terminal diskNetwork interface
controller
Jeder Prozess kann aus ein oder mehreren Threads (Aktivitätssequenzen)bestehen. Der Kernel besteht aus einer Sammlung von Komponenten, wobeidie Pfeile die Hauptinteraktionen zwischen den Komponenten darstellen. JedeKomponente wird natürlich auf der CPU ausgeführt.
Signals: Aufruf eines Prozesses durch den Kernel (z.B. um Prozess von einemFehler zu unterrichten (Division durch 0).
Traps: Unterbrechungen und Fehler, die durch CPU erzeugt werden.
2.2.4 Systemaufrufe
Die Schnittstelle zwischen dem Betriebssystem und den Benutzerprogrammenwird durch eine Menge von Systemaufrufen (engl. system calls) gebildet. Siestellen für Benutzerprogramme die einzige Schicht zum Zugriff auf Dienste desBetriebssystems and damit zur Nutzung der Hardware dar.
• in Benutzerprogrammen werden Systemaufrufe nicht direkt verwendet, sonderndies erfolgt über die Einbindung von Systembibliotheken, z.B. C-Library. Nachdem Übersetzen des Benutzerprogramms wird dieses i.a. mit einer C-Library
30
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
(z.B. glibc bei Linux) gelinkt, bevor es ausgeführt wird. Die Aufgabe dieserBibliothek ist es, Standard-C-Aufrufe in Systemaufrufe umzusetzen.
main ( ) {
--------------
printf ("hello“);
--------------
}
-------------
printf erledigt Formatierung
--------------
Systemaufruf
Anwendung
Bibliotheksfunktion
-------------
write (1, "hello“, 5);
--------------
Betriebssystemkern
Z.B. Zugriff auf FestplatteHardware
Benutzermodus
Systemmodus
Im write-Befehl wird als 1. Parameter das Standard-Ausgabemedium und als3. Parameter die Stringlänge angegeben.
• Systemaufruf führt zum Übergang vom Benutzermodus in den Systemmodus.
• Beispiele von Systemaufrufen
Prozessmanagement: fork, waitpid, exit. fork (Erzeugen eines neuenKindprozesses), waitpid (Warten auf Beendigung des Kindes), exit (Prozessbeenden).
Dateimanagement: open, close, read, write.
Verzeichnismanagement: mkdir, rmdir, link, mount.
Gerätemanagement: request/release device, get/set device attributes.
Kommunikationsmanagement: send/receive messages, create/deleteconnection.
Ein Systemaufruf wird realisiert mittels eines TRAP-Befehls (SysCall), derals Parameter die gewünschte Systemfunktion hat. Der TRAP-Befehl führtzu einer Unterbrechung des aktuellen Ablaufes und zu einem Sprung in denBS-Kern, wo die Unterbrechungsbehandlung nach dem Retten des aktuellenAusführungskontexts zum gewünschten Dienst springt.
31
Schlichter, TU München 2.2. BETRIEBSSYSTEM-ARCHITEKTUR
2.2.5 Virtuelle Maschine
Das Konzept der Virtualisierung erlaubt die Abstraktion der Hardware eineseinzelnen Rechners (CPU, Festplatte, Netzschnittstelle) auf unterschiedlicheAusführungsumgebungen. Eine wichtige Anwendung dieses Konzepts ist diegleichzeitige Bereitstellung mehrerer Betriebssysteme auf einem Rechner.
Isolierung der virtuellen Maschinen. Es gibt keine direkte gemeinsame Nut-zung von Ressourcen; deshalb gibt es keine Probleme bzgl. konkurrierenderZugriffe verschiedener virtueller Maschinen.
gemeinsame Nutzung von Dateien möglich. Teile einer Festplatte können fürdie gemeinsame Nutzung eingerichtet werden.
Beispiel VMware (URL: http://www.vmware.com/).
Hardware
CPU Arbeitsspeicher E/A-Geräte
Host Betriebssystem
(Linux)
Applikation Applikation Applikation
Virtualisierungsschicht
Gast-Betriebssystem
(free BSD)
virtuelle CPU
virtueller Speicher
virtuelle Geräte
Gast-Betriebssystem
(Windows XP)
virtuelle CPU
virtueller Speicher
virtuelle Geräte
In diesem Fall ist Linux ist das native Host-Betriebssystem. Die Virtualisierungs-schicht abstrahiert die physikalische Hardware zu isolierten virtuellen Maschinen,auf denen jeweils Gast-Betriebssysteme laufen.
Die Java Virtual Machine (JVM) spezifiziert einen abstrakten Computer, auf demJava Programme ausgeführt werden. JVM ist ein Softwaresystem, das auf demHost-Betriebssystem ausgeführt wird.
32
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
2.3 Hardwarenahe Programme
Zur Erleichterung werden hardwarenahe Programme für ein Rechensystem nichtals ausführbare Maschinenprogramme (Folge von Befehlswörtern) realisiert,sondern mit Hilfe von Assemblerprogrammen.
2.3.1 Definitionen
Maschinenschnittstelle
Als Maschinenschnittstelle 5 bezeichnet man die Gesamtheit aller Datenobjekteund Operationen der reinen Hardwarearchitektur (auch Programmierschnittstellender Maschine).
• Folge von Maschinenbefehlen ist auf dieser Ebene eine Folge von Binärzeichen.Auf dieser Ebene müsste man insbesondere die Befehle der Maschine als reineFolge von Binärzeichen (Befehlswörter) schreiben; diese Schnittstelle ist sehrprogrammier-unfreundlich.
Assemblerschnittstelle
Die Assemblerschnittstelle ist die eigentliche maschinennahe (konkrete) Program-mierschnittstelle. Sie erlaubt, alle Befehle, Adressen und Datenobjekte der reinenHardware darzustellen.
• Verwendung von Namen für Adressen und Operationen. Assemblersprachensind eine geringfügige Erweiterung von reinen Maschinensprachen. Zurbequemeren Nutzung werden u.a. symbolische Adressen (z.B. Identifikatoren)und symbolische Namen für Operationen (z.B. ADD für Addition) verwendet.
Assembler
Ein Assembler ist ein Programm, das die Aufgabe hat,
1. Assemblerbefehle in Maschinencode zu transformieren,
2. symbolischen Namen Maschinenadressen zu zuweisen, sowie
3. ein Objektprogramm zu erzeugen.5siehe die Vorlesung "Einführung Technische Grundlagen"
33
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
2.3.2 Programmaufbereitung
Wir wollen eine grobe Vorstellung der Funktion eines Assemblers, Binders undLaders vermitteln. Binder/Lader sind i.d.R. Bestandteil des Betriebssystems. Hiersteht nicht die Konstruktion solcher Komponenten (Systemprogrammierung),sondern deren Aufgaben und Funktionen im Vordergrund.
Programm
z.B. Java Programm
Compiler
Assembler
Programm
Assembler
Bindemodul Bindemodul
Binder
Lademodul
Lader
Maschinenprogramm im
Arbeitsspeicher
Maschinenbefehle mit
relativen Adressen
symbolische Bezüge
nach außen
offene Referenzen
Beispiel Unix Compilersystem
Aufruf:
unix> gcc -o hello hello.c
34
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
preprocessor
(cpp)
hello.c
Source
Program
(Text)
compiler
(ccl)
hello.i
Modified Source
Program
(Text)
assembler
(as)
hello.s
Assembly
Program
(Text)
linker
(ld)
hello.o
printf.o
relocatable object
program (Binary)
hello
executable
object program
(Binary)
Transformation in 4 Phasen
• Preprocessor: Aufbereitung. Der Preprocessor (cpp) modifiziert das ursprüngli-che C Programm gemäß den Anweisungen, die mit einem # Zeichen beginnen,z.B. die Anweisung #include <studio.h> führt zur Einfügung der header Dateistudio.h. In C können sie am Anfang mittels "#def" Makros definieren, z.B. an-stelle eines Zahlenwerts definieren sie einen Namen, der überall im Programmdann verwendet wird. Möchten sie dann den Zahlenwert ändern, muss dies nuran einer Stelle erfolgen. Der Preprocessor ersetzt vor dem Übersetzen dann dendefinierten Name durch den zugeordneten Zahlenwert.
• Compiler: Übersetzer von C nach Assembler. Der Compiler (ccl) übersetzthello.i in die Text Datei hello.s. Jede Anweisung in Assembler beschreibteine maschinen-sprachliche Instruktion im Textformat. Die Assemblerspracheist gemeinsam für die verschiedenen Compiler unterschiedlicher höhererProgrammiersprachen.
• Assembler: Übersetzer von Assembler nach Maschinensprache; Generierungdes Objektprogramms. 6
Der Assembler (as) übersetzt hello.s in Maschineninstruktionen und paketiertsie in verschiebbare Objektprogramme.
• Linker (Binder): Nachbearbeitung und Kombinationen verschiedener Module.In der Linker Phase werden notwendige Standardfunktionen wie printfintegriert. Der Linker ld führt die Kombination der einzelnen Module durch.Ergebnis ist die ausführbare Datei hello, die nun in den Arbeitsspeicher geladenund ausgeführt werden kann.6Dieser Teil und der Aufbau von Objektprogramms ist Teil der Vorlesung "Einführung in die
Technische Informatik".
35
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
2.3.3 Binder und Lader
Ein Assembler-Programm kann aus mehreren logischen Einheiten bestehen, dievom Assembler als einzelne, unabhängige Einheiten (Bindemoduln) transformiertwerden. In Informatik I wurde bereits Modularisierung als wichtiges Konstrukti-onsprinzip behandelt. Aspekte sind: Problem wird in Teilprobleme zerlegt, Bau-steine als Lösung von Teilproblemen, Wiederverwendung von Bausteinen, Biblio-theken (engl. library). Modularisierung ist besonders bei der Entwicklung großerProgramme sehr wichtig.
Binder
Der Binder (engl. linker) hat die Aufgabe, aus einer Menge von einzelnenBindemoduln ein ausführfähiges Ladeprogramm zu erzeugen, indem die nochoffenen externen Referenzen aufgelöst werden.
• Binde-ModuleDer Assembler erzeugt Code, der jeweils relativ zum Modul-Anfang adressiert.
Segment 1
JUMP start
Segment 2 Segment n
start:
Lade
objekt 1
Lade
objekt 2
Lade
objekt n
Assemblermodule
Bindemodule
assemblieren
Das Zusammenfügen der einzelnen Ladeobjekte zu einem ausführfähigenProgramm ist die Aufgabe des Binders (Linker).
– Externe ReferenzenIn einem Modul Mi können Referenzen auf Daten/Symbole auftreten, wobeidie Daten/Symbole in einem anderen Modul Mj definiert werden. Beispiel:Symbol start wird in Segment 1 verwendet, und erst in Segment n definiert.
36
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
Solche Referenzen heißen externe Referenzen. Assembler kann Referenzennicht auflösen, Assembler besitzt keine Informationen darüber, wo sich dieeinzelnen Segmente zur Ausführungszeit im Arbeitsspeicher befinden.
– Behandlung externer ReferenzenFür jede externe Referenz erzeugt der Assembler Informationen, diees dem Binder ermöglicht, aus den Einzelmoduln ein ausführfähigesGesamtprogramm zu erzeugen, d.h. die → Referenzen (siehe Seite 39)aufzulösen. Module können unabhängig assembliert werden: keine Vorgabeüber zeitliche Reihenfolge.
∗ Der Programmierer gibt durch spezielle Assembler-Direktiven für jedenModul an, welche Symbole und Namen des Moduls von außen verwendetwerden können, d.h. exportiert werden.∗ Extern referenzierte Symbole in einem Modul, sogenannte importierte
Symbole, müssen durch Assembler-Steuerungsanweisungen im Modulmarkiert werden.∗ Assembler erzeugt ausgehend von diesen Steuerinformationen spezielle
Einträge im Objekt-Programm.◦ Für exportierte Symbole: ein Eintrag (gekennzeichnet z.B. durch ein
D (=define)), der den Namen und die relative Adresse des Symbolsumfasst. Aufbau des Define-Eintrag:
"Kennung D, Name des exportierten Symbols, relative Adresse desSymbols im definierenden Segment".
◦ Für importierte Symbole: ein Eintrag (gekennzeichnet z.B. durch ein R(=refer)), der den Namen des importierten Symbols umfasst. Adressenkönnen hierfür noch nicht eingetragen werden. Aufbau des Refer-Eintrag:
"Kennung R, Name des importierten Symbols".∗ Findet der Assembler eine externe Referenz, so trägt er in dem
erzeugten Code die Adresse 0 ein. Gleichzeitig erzeugt er einenModifikations-Eintrag (gekennzeichnet z.B. durch ein M (=modify)) imObjektprogramm, der für den Binder die benötigte Information enthält:
Angabe, welches Auftreten der Referenz zu modifizieren ist undName des externen Symbols.
Auftreten bezieht sich hier auf die Angabe, wo im Maschinenbefehl dieexterne Referenz als Operand auftritt. Aufbau Modifikations-Eintrag:"Kennung M, Startadresse des zu modif. Adressfeldes, importiertesSymbol".
37
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
Lader
Ein Lader (engl. loader) ist ein Systemprogramm, das die Aufgabe hat,Objektprogramme in den Speicher zu laden und deren Ausführung anzustoßen.
• EigenschaftenIn einem System ist i.d.R. nur ein Lader vorhanden, so dass Programmeunterschiedlicher Quellsprachen in ein einheitliches Objektprogramm-Formattransformiert werden müssen.
– Viele Lader beinhalten gleichzeitig Binde-Funktion. Binde/Lader sindheutzutage typische Komponenten in Rechensystemen. Binde/Lader sindBestandteil der Dienste, die ein Betriebssystem anbietet.
∗ Binde/Lader: Programmmodule werden zur Ladezeit gebunden.∗ Lauf 1: Zuweisung von Adressen zu externen Referenzen (Auflösen von
Referenzen).∗ Lauf 2: Binden, Verschieben, Laden. Hierbei werden die Modify-Einträge
aufgelöst, d.h. die Adressen der extern referenzierten Symbole werdeneingetragen.
– Absoluter LaderAufgaben eines absoluten Laders; ein Lauf genügt.
∗ Prüfe, ob der für das Programm vorgesehene Speicher groß genugist. Jedes Objektprogramm hat einen Header, in dem u.a. auch dieProgrammgröße verzeichnet ist.∗ Die Text-Einträge im Objekt-Programm werden gelesen und der Code
wird an die dort angegebenen, absoluten Adressen des Speichers geladen.∗ Beim Lesen des END-Eintrags springt der Lader zur angegebenen Start-
Adresse des Programms, um die Programmausführung zu starten. Ein ab-soluter Lader hat jedoch eine Reihe von Problemen: a) Programmierermuss Lade-Adressen explizit angeben, b) Probleme bei Multiprogram-ming: Ladeadresse nicht vorab bekannt, c) Verschiebbarkeitsforderungenkönnen nicht erfüllt werden, und d) Probleme bei Wiederverwendbar-keit von z.B. Bibliotheksfunktionen, wenn diese vorab vergebene absoluteAdressen besitzen.
– Relativer LaderLaden verschiebbarer Objekt-Programme, wobei die Information, welcheAdressen neu zu berechnen sind, vom Assembler zur Verfügung ge-stellt werden, z.B. durch Modifikations-Einträge im Objekt-Programm.
38
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
Modifikations-Einträge sind jedoch nicht für jede Maschinen-Architektur ge-eignet. Maschinen, die z.B. keine relative Adressierung kennen, erfordern,dass u.U. fast alle Adressen neu berechnet werden müssen durch den Lader.Entsprechend umfangreich sind dann die benötigten Modifikations-Einträgeund entsprechend groß wird dann das Objekt-Programm. Die Verschiebbar-keit wird in Zusammenhang mit der Seitenadressierung detaillierter behan-delt.
Datenstrukturen eines Binde/Laders
Der Binder benötigt eine Tabelle ESTAB ("external symbol table") für dieaufzulösenden externen Referenzen, wenn im Programm externe Referenzenauftreten. Der Tabelleneintrag besteht aus [Symbol, Adresse]. ESTAB hat analogeAufgaben wie die Symboltabelle des Assemblers. Der Tabelleneintrag beinhaltetu.U. auch den Modul, in dem das Symbol definiert ist.
• Hilfsvariable
– PADR: Startadresse im Speicher, wohin das gebundene Programm geladenwerden soll. Der Wert wird i.d.R. durch das Betriebssystem ermittelt unddem Lader mitgeteilt.
– CSADR: Startadresse des jeweils bearbeiteten Moduls; dieser Wert wird zuden Relativ-Adressen des jeweiligen Moduls hinzu addiert. CSADR steht fürcontrol section adr.
• Algorithmus zum Lauf 1Festlegen der Startadresse PADR des zu ladenden Programms (also wohin es inden Speicher geladen werden soll). Jedes Modul wie folgt bearbeiten:
– Header-Eintrag lesen und Eintrag in Symboltabelle ESTAB:[Name des Moduls, Startadr. (=CSADR) des Moduls].
Beim ersten Modul gilt: CSADR=PADR.
– Lesen von Export-Einträgen (Symbol-Definitionen) im Objekt-Programm;alle auftretenden Symbole in ESTAB eintragen, wobei gilt:
[symbolischer-Name, Adresse = Relativadr + CSADR].Lesen der Assemblerbefehle; bei externen Referenzen werden jeweilsModifikationseinträge hinzugefügt.
– Lesen des END-Eintrags: CSADR = CSADR_alt + Länge des Segments(steht als Info im Header); Bearbeiten des nächsten Moduls mit der neuenAnfangsadresse CSADR.
39
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
• Algorithmus zum Lauf 2Nach Lauf 1 enthält ESTAB alle externen Symbole, die in Modulen definiertwurden zusammen mit deren Adresse. Der 2. Lauf erledigt die FunktionenLaden, Verschieben, Binden.
– Sukzessives Lesen der Text-Einträge aus Objektprogramm; Abspeichern desCodes an "Startadresse des Segments + Relativadresse" im Eintrag. DieStartadresse des Segments ist CSADR und ist jeweils im Eintrag zum Modulin ESTAB enthalten. Die Adressen im Maschinenbefehl werden angepasst.
– Wird ein Modifikations-Eintrag gelesen, so wird das extern referenzierteSymbol bzw. dessen Adresse, in ESTAB nachgeschlagen.
– Ist das letzte Modul bearbeitet und dessen END-Eintrag gelesen, so wirdzum dort angegebenen Beginn des Programms gesprungen und die Kontrollezur Ausführung des Programms wird an das Programm abgegeben. Beimehreren Objektprogrammmodulen enthält meist nur das Hauptprogrammeine Angabe einer Startadresse. Falls kein Modul eine Startadresse definiert,wird vom Lader per default die Anfangsadresse PADR genommen. Damitgilt folgendes: Reihenfolge, in der Module geladen werden spielt keineRolle. Andere Möglichkeit: Startadresse des geladenen Programms wird andas Betriebssystem zurückgeliefert und Benutzer muss mit einem Execute-Befehle (exec) explizit die Ausführung starten.
Dynamisches Binden
Binden von Unterprogrammen erst zur Laufzeit, d.h. erst wenn sie das erste Malaufgerufen werden. Als Vorteile ergeben sich folgende:
• Nach Bedarf ladenUnterprogramme werden also nur dann, wenn sie tatsächlich gebraucht werden,zum in Ausführung befindlichen Programm hinzu gebunden. Bei großenUnterprogrammen oder bei Unterprogrammen mit vielen externen Referenzenkann man mit dynamischen Binden viel Speicherplatz und Zeit einsparen.Z.B. Nutzung einer großen Statistik-Bibliothek abhängig von Eingabewerten,die erst zur Laufzeit bekannt sind: kein Binden einer vollständigen Kopie derBibliothek nötig.
Beispiel Windows: Routinen in Dynamic Link Libraries (DLL) zusammen-gefasst; erst wenn sie benötigt wird, Laden der gesamten DLL.
• Code-Sharing
40
Schlichter, TU München 2.3. HARDWARENAHE PROGRAMME
Dynamisches Binden wird oft verwendet, wenn mehrere ausführfähigeProgramme eine einzige Kopie eines Unterprogramms oder einer Bibliothekgemeinsam nutzen sollen. Z.B. werden für die Programmiersprache Cdie Routinen für die Laufzeit-Unterstützung in der dynamic link libraryzusammengefasst. Es wird dann nur eine Kopie der Routinen der Bibliothekin den Arbeitsspeicher geladen und alle ausführenden Programme könnendann dynamisch diese Kopie zu ihrem Programm hinzu binden, anstatt jeweilseine eigene Kopie in ihr Objektprogramm zu binden. Dabei ist es notwendigzwischen dem statischen Teil (gleich für alle) und dem dynamischen Teil(spezifisch für jedes aufrufende Programm) zu unterscheiden. Bibliothek isteine Sammlung von Funktionalitäten, die in ein Programm eingebunden werdenkönnen. Die dort verfügbaren Funktionen werden dann als Unterprogramm imeigenen Programm aufgerufen. Bibliotheken werden typischerweise von vielenAnwendungsprogrammen verwendet.
41
Kapitel 3
Parallele Systeme - Modellierung,Strukturen
Historisch gesehen war der Ausgangspunkt eine Ein-Benutzer, Ein-ProgrammRechenanlage und zwar ohne ein Betriebssystem, das die Ausführung vonProgrammen koordiniert. Für die Ausführung von mehreren Programmen,insbesondere wenn sie parallel ausgeführt werden sollen, sind eine Reihe vonorganisatorischen Maßnahmen notwendig. Die angesprochenen organisatorischenAufgaben sind wesentlicher Bestandteil der Aufgaben eines Betriebssystemsund die Programmierung eines Betriebssystems gehört zu dem Bereich dersystemnahen Programmierung. Typischerweise finden in einem allgemeinenRechensystem eine Vielzahl paralleler Abläufe statt, die miteinander koordiniertwerden müssen.
Bevor wir auf die Aufgaben eines Betriebssystems und insbesondere aufdie Bereiche Prozess- und Prozessorverwaltung, Speicherverwaltung sowieEin/Ausgabe eingehen, werden wir uns zunächst mit den Problemen beschäftigen,die sich daraus ergeben, dass in einem Rechensystem eine Vielzahl von parallelenAbläufen/Prozessen, existieren kann, die sich beeinflussen können, miteinanderkommunizieren oder auch in Konkurrenz zueinander stehen können.
3.1 Fragestellungen
• Sequentielle Aspekte von systemnaher Programmierung:
– Programm als Repräsentation eines Algorithmus; ein Algorithmus ist einschrittweise effektiv durchführbares Verfahren, in endlichen Schritten; er hateine endliche eindeutige Beschreibung.
42
Schlichter, TU München 3.1. FRAGESTELLUNGEN
– Programm als sequentielle Folge von Aktionen/Anweisungen (alle Schrittenacheinander);
– determinierte Programme: unter gleichen Bedingungen und Eingabenproduziert das Programm stets das gleiche Ergebnis; dies erlaubt eineeinfaches Testen bzw. Debuggen der Programme und der Prozessabläufe.
– deterministische Abläufe: eindeutig vorbestimmter Ablauf, keine willkürli-che Auswahl von alternativen Schritten.
• Übergang von sequen-tiellen Systemen hin zu parallelen Systemen/Programmen. Dabei werden diefolgenden Aspekte näher betrachtet.
– gleichzeitige Aktivität von Komponenten, die möglicherweise miteinanderkommunizieren oder aufeinander einwirken.
– Beispiele für Parallelität
∗ HW-Komponenten eines Rechensystems, z.B. Prozessor und E/A-Controller.∗ SW-Komponenten eines Rechensystems, z.B. parallel ablaufende Pro-
gramme; u.U. Zugriff auf gemeinsame Ressourcen, z.B. Daten im Arbeits-speicher. In einem Multiprozessorsystem können Programme echt gleich-zeitig ausgeführt werden.∗ SW-Komponenten in einem verteilten System, d.h. Rechensysteme, die
über ein Rechnernetz miteinander verbunden sind.
– Aspekte des Abschnitts
∗ Modellierungstechniken zur Analyse und Beschreibung der Eigenschaftenparalleler Systeme (Spuren, Petrinetze).∗ Threads als Mittel zur Realisierung von Parallelität innerhalb eines
Prozesses.∗ Synchronisation in parallelen Systemen. Hier geht es darum, dass
Konkurrenz in parallelen Systemen koordiniert werden muss, umInkonsistenzen in Rechensystemen zu vermeiden. Erhaltung der kausalenBeziehungen zwischen Aktionen; Synchronisation des Zugriffs aufgemeinsame Ressourcen.∗ Mechanismen zur Behandlung von Verklemmungen. Im Rechensystem
gibt es keinen Fortschritt, da sich die einzelnen Prozesse gegenseitigblockieren. Prozesse warten gegenseitig auf frei-werdende Ressourcen.Im Gegensatz zum vorhergehenden Aspekt ist bereits eine Blockierungeingetreten, die nun aufgelöst werden muss.
43
Schlichter, TU München 3.2. GRUNDLAGEN
3.2 Grundlagen
In diesem Teilabschnitt werden kurz die wichtigsten Begriffe definiert sowieKonzepte zur Formulierung paralleler Aktivitäten aufgelistet. Einige dieserKonzepte werden in nachfolgenden Teilabschnitten ausführlicher diskutiert.
3.2.1 Begriffsdefinitionen
Nebenläufigkeit
Nebenläufigkeit (engl. concurrency) bezieht sich auf die zeitliche Beziehungzwischen den Aktivitäten von Komponenten, die gleichzeitig oder zeitlichverzahnt (engl. interleaving) ablaufen können.
• z.B. gleichzeitig: Drucken eines Dokuments und Berechnen einer Formel ineiner Tabellenkalkulation (CPU-Nutzung).
• z.B. zeitlich verzahnt: Benutzerauftrag muss CPU abgeben und wartet; einanderer Auftrag wird (teilweise) ausgeführt und gibt CPU wieder zurück, bevordas Ende erreicht ist. Hier spricht man auch von Pseudoparallalität. Für einenBenutzer sieht es so aus, als ob Dinge gleichzeitig passieren.
Parallelität
Parallelität wird häufig synonym zu Nebenläufigkeit verwendet;
• spezielle Form der Nebenläufigkeit: mehrere Prozessoren stehen zur Ausfüh-rung zur Verfügung. Ein Beispiel dafür sind Multiprozessoren mit mehrerenProzessoren. Auch bei einem Ein-Prozessor gibt es echte Parallelität zwischenE/A-Controller (z.B. mit angeschlossenem Drucker) und CPU.
Verteiltheit
Verteilheit (engl. distribution) ist die räumliche oder auch nur konzeptionelleAufteilung der Komponenten eines Systems, z.B. vernetzte PCs. Die Verteilungkann sich sowohl auf der Ebene der HW-Komponenten als auch auf der Daten-und Anwendungsebene abspielen.
44
Schlichter, TU München 3.2. GRUNDLAGEN
Interaktion
Kommunikation, Synchronisation, Konkurrenz betrifft die kausalen Beziehungenzwischen räumlich verteilten und nebenläufig ausgeführten Aktivitäten.
• kausale Abhängigkeit zwischen Ampel und Fußgänger:
Ereignis von Fußgänger:er drückt KnopfEreignis beeinflusst Ampel: sie schaltet auf Rot für Auto
• Kommunikation: Prozesse auf dem gleichen oder unterschiedlichen Rechensy-stemen tauschen Nachrichten untereinander aus.
• Koordinierung: Beziehung zwischen Auftraggeber und Auftragnehmer ⇒Erstellen eines Auftrages durch Client und anschließendes Bearbeiten desAuftrags durch Server. Ein Beispiel ist auch der koordinierte Zugriff aufgemeinsame Daten (Erzeuger - Verbraucher Problematik).
• Konkurrenz: Aktivitäten eines Prozesses behindern die eines anderen Prozessesz.B. Warten, wenn CPU von anderem Prozess belegt.
Nichtdeterminismus
System zeigt bei gleichen Ausgangsbedingungen und gleichen Eingaben unter-schiedliches Verhalten (Reihenfolge der Prozesse spielt eine Rolle!). Problem:Nichtreproduzierbarkeit von Ergebnissen, Testen von parallelen Programmen beiNichtdeterminismus ist schwierig. Beispiel:
x = 2 Prozess 1: x = x+5 Prozess 2: x = x*2
Ausführungsreihenfolge
P1 vor P2: x == 14P2 vor P1: x == 9Andere Ursachen für Nichtdeterminismus sind unterschiedliche Last bzglRechner, Netz. Es geht nur um die Ausgangsbedingungen, die für die Ausführungim Rechner relevant sind, und nicht darum, ob in New York gerade ein Taxi die 5thAv. herunterfährt. Zu Ausgangsbedingungen zählen u.a., welche anderen Prozesselaufen im Rechner gerade, wie ist der Speicher belegt, findet ein Netzwerk-kommunikation statt, etc.
45
Schlichter, TU München 3.2. GRUNDLAGEN
3.2.2 Beschreibungskonzepte
Es gibt eine Vielzahl von Konzepten zur Formulierung paralleler Aktivitäten.In der Vorlesung werden wir uns vor allem mit den beiden modell-basiertenAnsätzen, Ereignisse und Petrinetze befassen. Es gibt auch noch andereModellansätze (z.B. bei Rechnernetzen), z.B. formale Beschreibungssprachen(Estelle, LOTOS), die z.T. auf Prozessalgebren basieren. Eine andere Möglichkeitsind parallele Programmiersprachen.
modell-basierte Konzepte
• ereignis-orientiert: es wird der Ablauf von Prozessen betrachtet; jeder Ablaufwird durch eine Menge von Ereignissen charakterisiert. Jeder Ablauf repräsen-tiert eine Ereignisspur. Einzelne Ereignisse können in kausalem Zusammen-hang stehen. Es werden nun eine Menge von Prozessen und deren Zusammen-wirken betrachtet, insbesondere auch wie deren Ereignismengen im Zusam-menhang zueinanderstehen. Ein Prozess wird anhand von Ereignismengen cha-rakterisiert.
• graphisch-orientiert: der Prozessablauf wird graphisch dargestellt. Petrinetzesind ein Beispiel dafür. Petrinetze sind Graphen mit 2 Arten von Knoten,den Stellen und Transitionen. Abläufe werden durch das Schalten vonTransitionen und der Propagierung von Marken charakterisiert. Dabei könnenAussagen bzgl. der kausalen Abhängigkeit, aber auch der Unabhängigkeit vonTeilabläufen getroffen werden.
Sprachkonstrukte in Programmiersprachen
• parallele Komposition von Teilabläufen innerhalb eines Prozesses, z.B. JavaThreads. Andere Beispiele sind Tasks in Ada, oder auch parbegin, parend.
• Prozesshierarchien in Betriebssystemen: u.a. fork, join
• Kommunikationskonzepte: u.a. send, receive
• Synchronisationskonzepte: u.a. lock, unlock
Konzepte in Betriebssystemen
• Prozesskonzept = Programm in Ausführung; Prozesse haben einen eigenenAdressraum während Threads eines Prozesses den Adressraum des Prozessesgemeinsam nutzen.
46
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
• Threadkonzept = leichtgewichtiger Prozess;
• Kommunikation: Shared memory, Dateien, Nachrichten etc.
• Synchronisation: Unterbrechungen (Interrupts), Sperren etc. Das Auftreten vonUnterbrechungen sowie deren Behandlung wird im Verlaufe der Vorlesungnoch näher behandelt.
3.3 Modellierung paralleler Systeme
In diesem Abschnitt behandeln wir grundlegende Mechanismen zur Modellierungund Beschreibung parallel ablaufender Systeme. Siehe auch das Buch M. Broy"Informatik", Springer-Verlag. Insbesondere geht es in diesem Abschnitt umfolgendes:
das Verhalten von parallelen Systemen klären,
sich auf wesentliche Aktionen, Ereignisse konzentrieren (Abstraktion),
die Abhängigkeiten zwischen Aktionen ermitteln/klären,
Fehler oder Konflikte aufgrund paralleler Tätigkeiten vermeiden und
maximale Parallelität erzielen.
3.3.1 Modellierungsziele
Ziel ist die einfache Analyse und Beschreibung von parallelen Systemen.
• Spezifikation eines Modells im Sinne von Abstraktion: Vereinfachung,Weglassen von Details, Beschränken auf interessierende Eigenschaften.
• Beispiele interessanter Eigenschaften sind:
– Determiniertheit. Unter gleichen Bedingungen entstehen die gleichenErgebnisse.
– Störungsfreiheit. Für störungsfreie Systeme gilt, dass unter Einhaltung derdurch eine Ordnung (später wird hierzu die Kausalitätsordnung zwischen Er-eignissen verwendet) festgelegten Reihenfolge, die Ausführungsreihenfolgeder parallelen Ereignisse und deren Aktionen keinen Einfluss auf die berech-neten Ergebnisse hat.
47
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
– wechselseitiger Ausschluss. Hier geht es darum, dass bei konkurrierendenZugriffen auf gemeinsame Ressourcen, die exklusiv benutzt werden, immernur ein Prozess zu einem Zeitpunkt darauf zugreift. Damit soll die Konsistenzsichergestellt werden.
– Endloses Blockieren (engl. Deadlock).
– Verhungern (engl. Starvation). Beispielsweise erzielt ein Prozess keinenFortschritt, da er nie rechnend gesetzt wird, obwohl er rechenbereit wäre.In Rechnerkernvergabe gibt es jedoch immer einen anderen rechenbereitenProzess, der eine höhere Priorität hat.
• Die Eigenschaften können in zwei Klassen eingeteilt werden.
– Sicherheitseigenschaften (engl. safety): Sicherstellen, dass gewisse uner-wünschte Zustände und unerwünschte Aktionsverläufe nicht auftreten; For-mulierung durch Invarianten (z.B. wechselseitig ausgeschlossene Nutzungder CPU). Hier geht es nicht um Datensicherheit, d.h. persistente Speiche-rung von Daten, damit sie auch nach einem Systemcrash noch zur Verfügungstehen. Es geht auch nicht um Datenschutz, d.h. dass Daten nicht für andereProzesse lesbar sind.
– Lebendigkeitseigenschaften (engl. liveness): Garantieren, dass gewisseerwünschte Zustände bzw. Aktionsmuster in den Abläufen irgendwannauch auftreten (z.B. erwünschter Ablauf: rechenbereiter Prozess machtirgendwann auch Fortschritte). Möglicherweise ist dafür die dynamischeAnpassung der Priorität notwendig.
3.3.2 Verhaltensbeschreibung
Verhaltensbeschreibungen eines dynamischen Systems sind Beschreibungen derEigenschaften des Systems und deren Veränderungen über der Zeit. Das Verhalteneines Systems kann mit Spuren in einem 2-dimensionalen Raum beschriebenwerden:
Die 1. Dimension ist die Zeit, mit der das Fortschreiten der Ausführung derBerechnungen erfasst wird, d.h. hier geht es um die Folge von Ausführungenvon elementaren Aktionen, die jeweils Ereignisse auslösen.
Die 2. Dimension ist der Raum der Eigenschaften des Systems, mit dem dieSystemzustände in Zeitpunkten erfasst werden. Zu Zeitpunkten wird jeweilsein Schnappschuss des Systemzustands genommen. Über die Zeitachse wirdeine Folge von Zuständen angegeben, die sich mit der Ausführung derAktionen (Berechnungen) ergibt.
48
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
Die Verhaltensbeschreibung setzt sich aus den Basiseinheiten Aktionen undZustände zusammen.
• Eigenschaftenveränderungen sind Ausführungen von elementaren Aktionen.Ausführungen von komplexen Berechnungen können mit Kombinationen vonAusführungen dieser elementaren Aktionen beschrieben werden. Es sind zweiSichten möglich.
– Die Sicht auf die Tätigkeiten, die auszuführen sind; in dieser Sichtsind die Basiseinheiten die atomaren Aktionen. Eine Aktion kann einMaschinenbefehl oder eine Java Anweisung sein.
– Die Sicht auf die Veränderungen, die erfolgen und beobachtet werdenkönnen; in dieser Sicht sind die Basiseinheiten die atomaren Ereignisse,die eintreten. Die Ausführung einer Aktion führt zu einem Ereignis imRechensystem. Aktionen und Ereignisse sind dual zueinander und könnennach Bedarf genutzt werden; hier wird überwiegend die Ereignissichtbenutzt. Aktionen können mehrfach ausgeführt werden; sie resultieren inmehrfachen Ereignissen.
Beispiel: Aktion - Knopf drücken; Ereignis - die Ampel ist rot.
• Aktionen bzw. Ereignisse sind zeitlich geordnet. In einem sequentiellenSystem werden die elementaren Aktionen sequentiell ausgeführt, d.h. esexistiert eine lineare Ordnung bzgl. der Zeitachse. Diese Zeitachse fürVerhaltensbeschreibungen hat mit der gewohnten, physikalischen Zeit dielineare Ordnung gemeinsam; sie abstrahiert jedoch als diskrete Zeit von derDauer der Ausführung von Aktionen. In einem parallelen System müssenzusätzlich auch nebenläufige Aktionen betrachtet werden, d.h. für sie kann keinezeitliche Reihenfolge bestimmt werden.
• Zustände des Systems anhand der Werte der Datenobjekte. Folge vonZuständen gemäß der Zeitachse. Jedem Zeitpunkt wird der Zustand derDatenobjekte, der mit dem Zeitpunkt erreicht ist, zugeordnet. Für jedenZeitpunkt wird damit ein Schnappschuss vom System angegeben; über derZeitachse wird die Folge der Zustände angegeben, die sich mit der Ausführungder Berechnungen ergibt.
• SpurenEs sind zwei Varianten von Verhaltensbeschreibungen zweckmässig.
1. Ereignisspuren: Sie beschreiben den zeitlichen Ablauf der Berechnungeneines Systems mit Ereignissen, die linear geordnet sind.
49
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
2. Zustandsspuren: Sie beschreiben den zeitlichen Ablauf der Berechnungeneines Systems anhand der auftretenden Zustände der Datenobjekte. Ereignis-spur und Zustandsspur sind eng miteinander verknüpft. Bei Auftreten einesEreignisses wird jeweils ein Schnappschuss des Systems genommen. DieserSchnappschuss stellt ein Element der Zustandsspur dar.
3.3.3 Ereignisse und Aktionsstrukturen
In diesem Abschnitt wird der Begriff Prozess anhand von Aktionsstrukturen ma-thematisch gefasst. Dies ermöglicht die mathematische Modellierung beliebiger,nichtkontinuierlicher ("diskreter") Abläufe verteilter Systeme, insbesondere vonProzessen in Rechenanlagen. Durch diese Modellierung können jedoch auch an-dersartige, technische oder betriebliche Vorgänge, die sich aus Einzelaktionen zu-sammensetzen und zwischen denen kausale Beziehungen bestehen, erfasst wer-den.
Prozess
Gegeben seien eine Menge (das "Universum") E* von Ereignissen (engl. events)und eine Menge A von Aktionen (engl. actions).
• DefinitionEin Triple p = (E, ≤, α) nennen wir einen Prozess oder auch eineAktionsstruktur, falls folgende Aussagen gelten:
– E ⊆ E*, E heißt die Ereignismenge.
– ≤ ist eine partielle Ordnung über E, ≤ ist die Kausalitätsrelation.Die partielle Ordnung ist eine reflexive, transitive und antisymmetrischeRelation.
– α: E→ A ist die Aktionsmarkierung des Prozesses p.
– Die Abbildung α ordnet jedem Ereignis eine Aktion zu. In dieser Definitionvon Aktionsstrukturen ist auch der leere Prozess eingeschlossen. Er wirddurch die Aktionsstruktur dargestellt, die aus der leeren Ereignismengebesteht.
• Beispiel: FußgängerübergangWir betrachten einen Prozess mit 14 Ereignissen. Jedem Ereignis werdenAktionen zugeordnet.
50
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
Ereignis Aktione1 Knopf wird gedrückte2 Ampel für Autofahrer schaltet auf Gelbe3 Ampel für Autofahrer schaltet auf Rote4 Auto hält auf Spur 1e5 Ampel für Fußgänger schaltet auf Grüne6 Auto hält auf Spur 2e7 Fußgänger benutzt Fußgängerübergange8 Auto hält auf Spur 3e9 Ampel für Fußgänger schaltet auf Rote10 Ampel für Autofahrer schaltet auf Rot und Gelbe11 Ampel für Autofahrer schaltet auf Grüne12 Auto fährt an auf Spur 1e13 Auto fährt an auf Spur 2e14 Auto fährt an auf Spur 3e15 Knopf wird gedrücktDie Ausführung einer Aktion löst ein Ereignis aus. Wird dieselbe Aktionmehrmals ausgeführt, so wird jeweils ein neues Ereignis ausgelöst (siehe e1und e15).
– Die Relation der kausalen Abhängigkeiten sei gegeben durch:e1 ≤ e2, e2 ≤ e3, e3 ≤ e4, e3 ≤ e5, e3 ≤ e6, e5 ≤ e7,e3 ≤ e8, e5 ≤ e9, e9 ≤ e10, e10 ≤ e11, e11 ≤ e12,e11 ≤ e13, e11 ≤ e14, e4 ≤ e12, e6 ≤ e13, e8 ≤ e14, e9 ≤ e15.Die kausalen Abhängigkeiten ergeben keine vollständige Ordnung.
– Diese Beziehungen erzeugen (durch die Bildung der reflexiv transitivenHülle) eine partielle Ordnung, die die Kausalität zwischen den Ereignissenbeschreibt. Man beachte, dass hier beispielsweise das Ereignis e12 nurstattfindet, nachdem die Ereignisse e4 und e11 stattgefunden haben.
– Graphische DarstellungEndliche Prozesse lassen sich anschaulich durch knotenmarkierte, gerichtete,zyklenfreie Graphen darstellen, Die Knoten repräsentieren die Ereignisseund sind durch die zugeordneten Aktionen markiert. Ereignisse werdennicht wiederholt, nur die Aktionen werden wiederholt, d.h. jede wiederholteAusführung der gleichen Aktion führt zu einem neuen Ereignis; deshalbzyklenfrei,
51
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
e1 e2 e3 e4
e6
e5
e8
e7
e9 e10 e11
e12
e14
e13
e15
• Charakterisierung von ProzessenIn einem Prozess hat jedes Ereignis eine eindeutige Identität ("X betritt am19.1.2001 um 11:15 h den Hörsaal"), eine Aktion kann jedoch mehrfachstattfinden (die Aktion "X betritt den Hörsaal" kann mehrfach stattfinden).Dementsprechend kann in einem Prozess verschiedenen Ereignissen die gleicheAktion zugeordnet sein. Ereignisse haben einen eindeutigen Bezeichner;Prädikate sind eine andere Möglichkeit, Ereignisse zu identifizieren, z.B.Ermordung Kennedy’s oder die Kreuzigung Christi.
– Parallel, nebenläufigFür einen Prozess p = (E, ≤, α) nennen wir zwei Ereignisse e1, e2 ∈ Eparallel oder nebenläufig (engl. concurrent), falls sie im Prozess p nicht ineiner kausalen Relation stehen, d.h. wenn gilt:¬(e1 ≤ e2 oder e2 ≤ e1)
∗ Parallele Ereignisse sind kausal unabhängig, sie können zeitlich nebenein-ander oder in beliebiger Reihenfolge stattfinden.
– SequentiellEin Prozess p = (E, ≤, α) heißt sequentiell, wenn in ihm kein Paar vonparallelen Ereignissen auftritt, d.h. die Kausalitätsrelation ≤ eine lineareOrdnung ist. Damit gilt für zwei beliebige Ereignisse e1 und e2 stetsentweder e1 ≤ e2 oder e2 ≤ e1.
– Der Ablauf eines Programmes kann auch als Prozess im Sinne derAktionsstrukturen gedeutet werden. Sequentielle Programme erzeugensequentielle Prozesse.
– EndlichEin Prozess p = (E, ≤, α) heißt endlich, falls seine Ereignismengeeine endliche Menge ist. Beispielsweise ist das Abspielen einer CD einendlicher Prozess, während ein Betriebssystem einen unendlichen Prozess
52
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
repräsentiert. Unendliche Prozesse besitzen unendliche Ereignismengen.Unendliche Prozesse können jedoch endlich beschreibbar sein.main () { while true {} }
Kausale Abhängigkeiten
Häufig finden wir in Prozessen unterschiedliche Ursachen für die kausaleBeziehung e ≤ d zwischen Ereignissen e und d. Im einzelnen können dreiverschiedene Arten unterschieden werden.
• Echt kausale Beziehungendas Ereignis e ist kausal für das Ereignis d in dem Sinn, dass d ohne e niemalsauftreten kann.
– Beispiele = Geldeinwurf, d = Kartenausgabe; e ≤ d, d.h. der Fahrkartenautomat gibterst dann eine Fahrkarte aus, wenn der passende Geldbetrag eingeworfenwurde.
• zeitliche Beziehungendas Ereignis e endet, bevor das Ereignis d beginnt.
– Beispiel: Nachricht muss gesendet sein, bevor sie empfangen werden kann.Zeitliche Beziehungen können, aber müssen nicht echt kausal sein. Auto 1fährt auf Spur 1, Auto 2 fährt eine Minute später auf Spur 2; es gibt einezeitliche Beziehung, jedoch keine kausale Beziehung.
– Happend-beforeDie kausale Beziehung impliziert also eine zeitliche Relation; das ist diebekannte happened before-Beziehung von L. Lamport. Die Umkehrunggilt nicht. Die zeitliche Relation zwischen Ereignissen sagt nichts über dieKausalität aus.
∗ Wichtig: Ereignisse wurden als atomare Ereignisse modelliert. D.h.Beginn und Ende fallen auf einen Zeitpunkt zusammen. Ein alternativerAnsatz wäre die Spezifikation eines Zeitintervalls für ein Ereignis mitAnfangs- und Endzeitpunkt. Damit könnten auch Überlappungen vonEreignissen modelliert werden.∗ Die Happend-before Relation spielt im Kontext von Verteilten Anwendun-
gen eine wichtige Rolle (siehe Vorlesung Verteilte Anwendungen (URL:http://www11.in.tum.de/lehre/vorlesungen/archiv)). Insbesondere in der
53
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
Gruppenkommunikation wird sie eingesetzt, um die an alle Gruppenmit-glieder gesandten Nachrichten zu sequentialisieren. Auf diese Weise sollerreicht werden, dass alle Gruppenmitglieder in einen für die Gruppe kon-sistenten Zustand versetzt werden.
• SystembeschränkungenSystembeschränkungen, z.B. wechselseitiger Ausschluss. Das Ereignis e darfnicht parallel zum Ereignis d auftreten.
– Beispiele = Fußgänger überquert die Fahrbahn beim Übergang, undd = Auto überfährt den Übergang.e und d dürfen nicht parallel ausgeführt werden, aber es besteht keine ech-te kausale Abhängigkeit zwischen e und d. Ereignisse, welche mit Aktionenmarkiert sind, die aufgrund von Systembeschränkungen nicht parallel statt-finden können, sind nicht unbedingt in einem "echt" kausalen Zusammen-hang. Trotzdem sollten sie nicht als parallele Ereignisse auftreten. Um dieseSystembeschränkungen mit den eingeführten Modellierungskonzepten (un-interpretierte Aktionen) zu erfassen, müssten sie in eine (künstliche) kausaleAbhängigkeit gebracht werden; das ist aber meist nicht sehr sinnvoll. Wirwerden später sinnvollere Möglichkeiten kennen lernen.
Sequentialisierung
Idee: vereinfachte Darstellung paralleler Abläufe, aus der Sicht eines Beobachters.Ein sequentieller Prozess hat genau eine vollständige Sequentialisierung, nämlichdie vorgegebene Reihenfolge der Ereignisse. Durch α ergibt sich aus derEreignisreihenfolge eine Folge von Aktionen. Vollständige Sequentialisierung:partielle Kausalitätsordnung zu linearer Ordnung ergänzen.
• DefinitionEin Prozess p1 = (E1, ≤1, α1) heißt eine Sequentialisierung eines Prozesses p2= (E2, ≤2, α2), falls gilt:
E1 = E2∀ e, d ∈ E1: e ≤2 d⇒ e ≤1 dα1 = α2
– Ist p1 sequentiell, so heißt die Sequentialisierung vollständig. Die Vervoll-ständigung einer partiellen Ordnung zu einer linearen Ordnung heißt topolo-gisches Sortieren.
54
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
• Ein sequentieller Beobachter eines Prozesses ist ein Beobachter, der dieEreignisse eines Prozesses und die entsprechenden Aktionen in einemsequentiellen Ablaufprotokoll festhält. Parallele Aktionen werden dabei ineine zufällige Reihenfolge gebracht. Das Ergebnis der Beobachtung istein sequentieller Prozess, der einer zufällig gewählten Sequentialisierungentspricht. Gehen wir von sequentiellen Beobachtern aus, so erhalten wirsequentielle Prozesse als Beobachtungen.
• Existiert für einen nichtsequentiellen Prozess eine Reihe von Beobachtungen,die alle vollständige Sequentialisierungen des Prozesses darstellen, so lässt sichaus diesen Beobachtungen der Prozess teilweise rekonstruieren. Kennen wir dieGesamtmenge aller Sequentialisierungen, so lässt sich der Prozess eindeutigrekonstruieren. Für den Beweis siehe Broy, Band II, S 12.
• Die Ausführung eines Programms auf einer Rechenanlage kann ebenfallsals Prozess dargestellt werden. Gewisse Anweisungen ("Aktionen") einesProgramms zerfallen bei der Ausführung auf einer Rechenanlage in eine Reihevon Einzelaktionen.
• BeispielFür das Beispiel des Fußgängerübergangs ist folgendes eine vollständigeSequentialisierung.
e1 e2 e3 e4 e6 e5 e7 e8 e9
e10 e11 e14 e12 e13 e15
• SpurenDarstellung sequentieller Prozesse mittels Spuren. Sequentielle Prozesse sindSpezialfälle paralleler Prozesse. Für die Darstellung sequentieller Prozessebietet sich eine wesentlich einfachere Darstellungsform als Aktionsstrukturen.Wir können ganz auf die explizite Angabe von Ereignismengen verzichten undstattdessen endliche oder unendliche Sequenzen von Aktionen verwenden.
– Sei A eine Menge von Aktionen, dann bezeichnen wir mit A+ die Mengeder endlichen Folgen von Aktionen aus A und mit A∞ die Menge derunendlichen Folgen von Aktionen.
55
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
– Jedem sequentiellen Prozess können wir eindeutig eine Folge von Aktionenzuordnen, wie sprechen von der Spur (engl. trace). Sei p = (E, ≤, α) einsequentieller Prozess. Wir definieren:
∗ spur : {p | p ist sequentieller Prozess }→ A+ ∪ A∞
∗ spur(p) = empty, falls E = Ø∗ spur(p) = <a> · spur(p | E \ {e}), falls E 6= Ø, wobei e das gemäß der
Kausalitätsordnung kleinste Ereignis in p ist und α(e) = a gilt.p | E \ {e} bezeichnet den Teilprozess, der durch die Einschränkungauf die Ereignismenge E \ {e} entsteht.
"·" ist hier die Konkatenation von Aktionen, die sich durch die Ereignisseergeben. spur ist eine Abbildung auf die Menge der Aktionen. Als Ergebnisliefert spur einen Strom (engl. stream) von Aktionen.
– Für einen nichtsequentiellen Prozess p gilt:Spuren(p) = {spur(q) : Prozess q ist eine vollständige Sequentialisierungvon p}
Spuren sind ein einfacheres Modell für sequentielle Abläufe eines Systemsals Aktionsstrukturen. Da bei nichtsequentiellen Systemen in vielen Anwen-dungen die Frage, welche Aktionen parallel zueinander auftreten können,von untergeordneter Bedeutung ist, ist es naheliegend für solche Systemevereinfachend statt ihrer nebenläufigen Prozesse deren Sequentialisierungenals Abläufe zu betrachten. In vielen Ansätzen zur Modellierung verteilter Sy-steme werden nicht Prozesse mit ihrer expliziten Darstellung von Parallelität,sondern die technisch etwas einfacher zu handhabenden Mengen von Akti-onsströmen verwendet.
3.3.4 Aktionen als Zustandsübergänge
Neben der Beschreibung von Systemen durch die Prozesse, die deren Abläufebilden, ist es naheliegend, Systeme durch Zustände und ihr Verhalten durch Zu-standsänderungen zu modellieren. ⇒ Zustandsraum = Menge aller Systemzu-stände. Dazu geben wir für ein System einen Zustandsraum an. Dieser bestehtaus der Menge aller Zustände, die das System einnehmen kann. Auf dieser Basisbeschreiben wir dann alle Zustandsübergänge, die im System auftreten können.
Interpretierte Aktionen
Aktionen werden Zustandsänderungen als Bedeutung zugeordnet. Bisher habenwir die Mengen der Aktionen nicht weiter interpretiert. Eine Deutung für Ak-tionen in Prozessen liefern Zustandsänderungen. Dazu weisen wir Aktionen Zu-
56
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
standsänderungen als Bedeutung zu, d.h. Aktionen bewirken Zustandsänderun-gen. Dabei interessiert uns insbesondere die Frage, ob wir über diese Zuordnungauch Prozessen eindeutig eine Bedeutung zuordnen können.
Modell
Zu diesem Zweck definieren wir nichtdeterministische Zustandsautomaten mitTransitionsaktionen.
• ZustandsautomatEin nichtdeterministischer Zustandsautomat ist gegeben durch:
– S, eine Menge von Zuständen, genannt Zustandsraum,
– A, eine Menge von Transitionsaktionen,
– R ⊆ S × A × S eine Zustandsübergangsrelation, Zustand⇒Aktion Zustand’
∗ Seien s0, s1 ∈ S und a ∈ A gegeben. (s0, a, s1) ∈ R bedeutet, dassim Zustand s0 die Aktion a ausgeführt werden kann und dies zumNachfolgezustand s1 ∈ S führen kann.∗ Diese Art von Automaten heißt nichtdeterministisch, da in einem
Zustand mehrere Transitionsaktionen möglich sein können und eineTransitionsaktion zu unterschiedlichen Nachfolgezuständen führen kann.∗ Wir schreiben (für gegebene Relation R) s0→a s1, um auszudrücken, dass
(s0, a, s1) ∈ R gilt.
– S0 eine Menge von möglichen Anfangszuständen.
• Beispiel FahrkartenautomatAkzeptiert werden 1- und 2 DMark Münzen. Mittels zweier Knöpfe kann manzwischen einer Kurzstrecke für 1 DM oder einer normalen Fahrt für 2 DMwählen. Der Automat gibt Wechselgeld zurück.
– Menge der ZuständeS ⊆ S1 × S2 mit
S1= {Wahl, kurz, normal} und S2= {-1,0,1,2}
mit der folgenden Interpretation eines Zustandes s = (x, y): 1
1x und y repräsentieren jeweils Zustandswerte. S1 spezifiert die Streckenwahl, S2 definiert dasWechselgeld.
57
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
x= Wahl: Automat wartet auf die Wahltastex= kurz: eine Kurzstreckenkarte wurde gewählt und ist noch auszugebenx= normal: eine normale Fahrkarte wurde gewählt und ist nochauszugebeny= -1 : es ist noch 1 DM zurückzugebeny= 0 : es ist kein Geld mehr einzuwerfen oder zurückzugebeny= 1 : es muss noch 1 DM eingeworfen werdeny= 2 : es muss noch 2 DM eingeworfen werden
– Menge der TransitionsaktionenA = {Wk, Wn, E1, E2, R1, Ak, An }, mit
Wk: Wahl einer KurzstreckenkarteWn: Wahl einer normalen FahrkarteE1: Einwurf eines 1DM StückesE2: Einwurf eines 2DM StückesR1: Rückgabe eines 1DM StückesAk: Ausgabe einer Fahrkarte für KurzstreckeAn: Ausgabe einer Normalfahrkarte
– Zustandsübergänge
(Wahl, 0)(normal, 2)
(normal, 1) (normal, 0) (kurz, 0) (kurz, 1)
(normal, -1) (Wahl, -1) (kurz, -1)
Wn Wk
E1
E2E2
E1
R1
An
R1
An
Ak
R1
E1
AkE2
• AktionsspurJedem Zustandsautomaten lassen sich ausgehend von der gegebenen Mengevon Anfangszuständen Spuren zuordnen.
– DefinitionGegeben sei ein Zustandsautomat Z = (S, A, R, S0). Eine Folge ai, wobei 1≤ i ≤ k mit k ∈ IN ∪ {∞}, ist eine endliche oder unendliche Aktionsspurdes Zustandsautomaten, falls eine Folge von Zuständen si existiert, mit si ∈S, s1 ∈ S0 und
58
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
si-1→aisi für alle i mit 1 < i ≤ k
– Eine Aktion a heißt deterministisch, wenn für jeden Zustand s ∈ S höchstensein Nachfolgezustand sf ∈ S existiert mit
s→a sf– Beispiel
Auswertung eines Programms mit Zustandsänderung. Das Programmy = 1;x = 10;while (x > 0) {
y = x * y; x = x - 1;}berechnet die Fakultätsfunktion. Nach seiner Ausführung gilt 10! = y. DerAblauf dieses Programms entspricht der sequentiellen Aktionsstruktur, derenEreignisse, Aktionen und Zustände in der folgenden Tabelle angegeben sind.Ereignis Aktion Zustand x Zustand ya0 y = 1 undefiniert 1b0 x = 10 10 1a1 (x > 0) ? 10 1b1 y = x * y 10 10c1 x = x -1 9 10... ... ... ...a10 (x > 0)? 1 10!b10 y = x * y 1 10!c10 x = x - 1 0 10!a11 (x > 0)? 0 10!Hier bezeichnen Aktionen wie (x > 0)? Abfrageaktionen, die denDatenzustandsraum nicht ändern. Nehmen wir jedoch Kontrollzustände(etwa einen Befehlszähler) mit zu den Zuständen des Zustandsraumshinzu, so ändert auch diese Abfrage den Zustand. Zustände sind für dasobige Programm durch Paare (n, m) von Zahlen gegeben, die die Werteder Programmvariablen x und y repräsentieren. Mit jeder Zuweisung ineinem prozeduralen Programm wird eine Aktion verbunden, die einerZustandsänderungsabbildung entspricht.
Konflikte
Im Zusammenhang mit Programmen und den ihnen zugeordneten Prozessenstellt sich die Frage, welche Zustandsänderungen ohne Schwierigkeiten zeitlichparallel durchgeführt werden können. In vielen Fällen lassen sich Aktionenzeitlich nebeneinander ausführen. Gewisse Zustandsänderungen können aber
59
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
nicht ohne Konflikte nebeneinander ausgeführt werden. Wir sagen, dass dieseAktionen im Konflikt miteinander sind. Sollen beispielsweise zwei Anweisungenan die gleiche Programmvariable x parallel ausgeführt werden, so lässt sich dementsprechenden Prozess keine Zustandsänderungsabbildung eindeutig zuordnen.In beiden Aktionen soll die Programmvariable x geändert werden. Die Aktionensind im Konflikt.
• BeispielMögliche Konflikte bei parallel durchzuführenden Zuweisungen. Wir betrach-ten die Aktionen, die den folgenden beiden Zuweisungen entsprechen:
(1) x = x + 1(2) x = 2 * x
Die Zuweisungen stehen im Konflikt zueinander.
– Werden sie parallel ausgeführt, so kann dem entsprechenden Prozesskeine Zustandsänderung eindeutig zugeordnet werden; wir sagen auch, dieAktionen stören sich wechselseitig.
• StörungsfreiheitFrage: Gibt es Kriterien, um auf einfache Weise solche Konflikte zu erkennen,so dass sie durch eine Reihenfolgeregelung gelöst werden können? Die Fragekann mit ja beantwortet werden; es gibt Kriterien, und zwar die Bernstein-Bedingungen.
– VorbereitungFür eine Transitionsaktion a gelte:
V(a)⊆ S ist Vorbereich, d.h. die Menge der gelesenen Zustandsvariablen.
N(a)⊆ S ist Nachbereich, d.h. die Menge der geschriebenen Zustandsva-riablen.
– BeispielSei S = {x, y, z}(1) a1: x = x+3y+z V(a1)={x,y,z}, N(a1)={x}(2) a2: y = 2*x V(a2)={x}, N(a2)={y}Zwischen dem Vorbereich von a2 und dem Nachbereich von a1 gibt es eineÜberlappung.
– Definition StörungsfreiheitGegeben sei ein Prozess p= (E,≤, α). Der Prozess p heißt störungsfrei, genaudann, wenn für jedes Paar von Ereignissen e1, e2 ∈ E gilt:
60
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
1.) e1 ≤ e2 oder e2 ≤ e1 oder2.) V(α(e1)) ∩ N(α(e2)) = N(α(e1)) ∩ V(α(e2)) = N(α(e1)) ∩ N(α(e2)) = Ø.
e1 und e2 sind parallel. Vorbereich und Nachbereich überschneiden sichnicht.Die Bedingung (2) nennt man auch Bernstein-Bedingungen. "Gilt die Bern-steinbedingung, dann ist die Reihenfolge der Ausführung der beiden Zu-weisungen ohne Einfluss auf den schließlich erreichten Endzustand. DerStörungsbegriff umfasst auch unerwünschte Situationen in konventionellenRechnern, in denen ein gleichzeitiges Lesen und Schreiben, sowie mehrfa-ches gleichzeitiges Schreiben auf einer Speicherzelle auch technisch zu ei-nem Konflikt führt."
– Für störungsfreie Systeme gilt, dass unter Einhaltung der mit ≤ festgelegtenReihenfolge, die Ausführungsreihenfolge der parallelen Ereignisse undderen Aktionen keinen Einfluss auf die berechneten Ergebnisse hat. "DieBernstein-Bedingungen sind auch im Zusammenhang mit parallelisierendenCompilern wichtig. Parallelisierende Compiler versuchen, Anweisungendes zu compilierenden Programms, die keine gemeinsamen Datenobjektebenutzen, für eine parallele Bearbeitung vorzubereiten (z.B. Ausnutzen vielerPipeliningstufen von RISC-Prozessoren). Dazu kann man die sequentiellenAktionen (Anweisungen) schrittweise aus der ≤ Relation entfernen, solangedie Bernsteinbedingung nicht verletzt wird."
3.3.5 Petri-Netze
Ein Prozess beschreibt einen möglichen Ablauf eines verteilten Systems. Ver-teilte Systeme besitzen viele Abläufe, d.h. ein System wird durch die Men-ge von Abläufen beschrieben. Gesucht wird deshalb ein Modell zur Beschrei-bung von Systemen und deren möglichen Abläufen. Drei Vertreter solcher For-malismen sind Petri-Netze (graphische Beschreibungsmethode), Agenten (for-male Beschreibungssprache, siehe Broy Band II) und prädikatenlogische For-meln zur Beschreibung von Abläufen. Im folgenden werden Petri-Netze (URL:http://de.wikipedia.org/wiki/Petri-Netz) vorgestellt, die eine graphen-orientierteBeschreibung verteilter Systeme und deren Abläufen ermöglicht.
Allgemeines
Formalismus von C.A. Petri 1962 entwickelt. Ansatz führte zu einer Theorie zurAnalyse und Entwicklung nebenläufiger Systeme.
61
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
• informelle CharakterisierungEin Petri-Netz ist gerichteter Graph mit Kanten und zweierlei Knoten.
– Knoten: Stellen (graphisch Kreise) und Transitionen (graphisch Rechtecke)
– Kanten: von Stellen zu Transitionen oder von Transitionen zu Stellen
– Belegung der Stellen mit Marken/Werten (Token);
∗ In einem boolschen Netz sind als Werte nur 0 oder 1 zugelassen.∗ In einem Stellen/Transitionsnetz sind für die Belegung der Stellen
natürlichzahlige Werte zugelassen; die maximale Belegung definiert dieStellenkapazität.
– Zustand: definiert durch Belegung der Stellen;Zustandsübergang durch sogenannte Schaltregeln (engl. firing rule); Bele-gung ändert sich. Man spricht in diesem Zusammenhang vom Schalten einerTransition.Das dynamische Verhalten eines Netzes läßt sich durch Schaltvorgängebeschreiben. Transitionen schalten, indem sie von allen Eingangsplätzen eineMarke abziehen (bei 1-wertigen Kanten) und auf allen Ausgangsplätzen eineMarke hinzufügen. Ein Schaltvorgang kann insbesondere die Gesamtzahl derMarken in einem Netz ändern. Eine einzelne Transition ist schaltbereit, wennalle ihre Eingangsplätze echt positiv belegt sind; bei mehrwertigen Kantenmüssen entsprechend viele Marken bei den Eingangsplätze vorhanden sein.
– Markierung der Kanten, Kantengewichte: Gewichtung gibt an, wievieleMarken beim Schalten einer Transition von den Eingangsknoten (Stellen)der Transition abgezogen und den Ausgangsknoten (Stellen) der Transitionhinzugefügt werden.
• Beispiel eines Petri-Netzesgrobe Modellierung einer Materialverwaltung.
62
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
Bestellung
Bestell-
aufnahme
Lieferauftrag
Auslieferung
Waren
Produktions-
auftragLagerProduktion
Bestellungen kommen zur Bestellaufnahme, die Lieferaufträge an die Auslie-ferung erteilt. Diese bedient sich aus einem Lager und liefert Ware aus. Umdas Lager aufzufüllen, müssen Produktionsaufträge an die Produktion erteiltwerden. Aus der graphischen Darstellung ist ersichtlich, dass Transitionen Tä-tigkeiten repräsentieren, während Stellen eher Zustände darstellen. Marken, dieStellen zugeordnet sind und einen dynamischen Ablauf ermöglichen, werdenerst weiter unten eingeführt.
Definition: Petri-Netz
Ein Petri-Netz ist ein Tripel (S, T, F) mitS ist eine endliche Menge von Stellen (engl. place)T ist eine endliche Menge von Transitionen (engl. transition) und es gilt: S ∩T = Ø d.h. Stellen und Transitionen sind disjunkt.F ist die Flussrelation mit F ⊆ (S × T) ∪ (T × S)Für einen Knoten x ∈ (S ∪ T) gilt:
·x = {y | y F x} den Vorbereich von xx· = {y | x F y} den Nachbereich von x
x kann dabei eine Stelle oder eine Transition sein.
• Mit obiger Definition ist die statische Struktur eines Netzes formal erfasst. Diegraphische Darstellung wurde bereits anhand des obigen Beispiel gezeigt.
• Für das Beispiel Materialverwaltung gilt beispielsweise:
·Bestellaufnahme = {Bestellung}Bestellaufnahme· = {Produktionsauftrag, Lieferauftrag}
63
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
• VerfeinerungNetzstrukturen können schrittweise verfeinert, konkretisiert werden. Wichtig:Globale Struktur muss bei Verfeinerung erhalten bleiben, d.h. alle Kanten ineine verfeinerte Transition und alle Kanten aus dieser verfeinerten Transitionbleiben erhalten. Die innere Struktur der Transition kann wiederum inStellen, Transitionen und Kanten aufgeschlüsselt werden. Die zu verfeinerndeTransition kann nach außen hin als Blackbox gesehen werden.
– BeispielVerfeinerung der Materialverwaltung: z.B. der Komponente Auslieferung.Anhand des Lieferauftrages wird der Lieferschein geschrieben, der zusam-men mit dem Produkt verpackt und versandt wird.
Auslieferung
Waren
Lager
Lieferauftrag
Lieferschein-
erstellungLieferschein
Verpacken
verpackte
Produkte
Versenden
Auslieferung ist nach außen hin eine Transition. Dies bedeutet, dass dieEingangskanten von Auslieferung jeweils zu einer Transition führen müssen.
Markierung und Schaltregeln
Zur Erfassung des dynamischen Verhaltens erweitern wir die Definition einesPetri-Netzes zunächst um Markierungen und geben dann die Schaltregeln an.
• MarkierungGegeben sei ein Petri-Netz (S, T, F).
64
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
– Eine Abbildung c: S→ IN ∪ {∞} gibt die Kapazität einer Stelle an. Wennin den von uns verwendeten Netzen die Stellen nicht explizit markiert sind,dann bedeutet dies eine unbeschränkte Kapazität.
– Eine Abbildung w: F→ IN ∪ {0} gibt die Gewichtung einer Kante an. Wennin den von uns verwendeten Netzen die Kanten nicht explizit markiert sind,dann bedeutet dies eine implizite Gewichtung mit dem Gewicht 1.
– Eine Abbildung M: S → IN heißt natürlichzahlige Markierung der Stellen.Die Markierung beschreibt einen Zustand des Netzes.
Es muss gelten: ∀ s ∈ S: M(s) ≤ c(s)Ein solches Netz heißt Stellen-Transitionsnetz
– Falls gilt M: S→ IB, mit IB = {0, 1}, dann heißt das Netz: Bedin-gungs/Ereignisnetz oder Boolesches Netz. Demnach entsprechen BoolschePetri-Netze natürlichzahligen Petri-Netzen, bei denen jede Stelle die Kapazi-tät 1 hat (oder einen boolschen Wert mit true (=1) bzw. false (=0) hat). EineTransition t kann nur dann schalten, wenn alle Stellen, zu denen Kanten vont aus führen, mit false markiert sind.
• SchaltregelnDas Verhalten eines Netzes wird durch Schaltvorgänge beschrieben. Gegebensei ein Petri-Netz (S, T, F), die Funktionen c, w und eine AnfangsmarkierungM0.
– Ein Zustandsübergang erfolgt durch das Schalten von Transitionen, wobeigilt: Eine Transition t ∈ T kann schalten (ist transitionsbereit), wenn folgendeBedingungen erfüllt sind:
Für alle s ∈ ·t gilt: M(s) ≥ w((s,t))Für alle s ∈ t· gilt: M(s) ≤ c(s) - w((t,s))
w(s,t) spezifiziert die für die Kante s→ t erforderliche Marken. Der zweiteFall bedeutet, dass vor Schalten der Transition die aktuelle Markierung derStelle kleiner oder gleich als die Kapazität der Stelle minus der zugehörigenKantengewichtung ist, d.h. die generierten Marken müssen in der Ziel-StellePlatz haben.
– Durch das Schalten von t wird eine Folgemarkierung M’ zu M erzeugt, mitFür alle s ∈ ·t \ t· gilt: M’(s) = M(s) - w((s,t))Für alle s’ ∈ t· \ ·t gilt: M’(s’) = M(s’) + w((t,s’))Für alle s" ∈ (·t ∩ t·) gilt: M’(s") = M(s") - w((s",t)) + w((t,s"))Sonst: M’(s) = M(s)
– Das Modell trifft keine Festlegungen über die Schaltdauer einer Transition,man geht davon aus, dass das Schalten keine Zeit erfordert. Die Definition
65
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
besagt, dass eine Transition nur schalten kann, wenn in ihren Eingangsstellenmindestens soviele Marken liegen, wie die Gewichtung der jeweiligenKanten angibt und wenn außerdem gewährleistet ist, dass durch das Schaltendie Kapazität ihrer Ausgangstellen nicht überschritten wird. Durch dasSchalten werden entsprechend der Kantengewichtung Marken von allenEingangstellen abgezogen und ebenfalls entsprechend der GewichtungMarken den Ausgangstellen hinzugefügt.
– Beispiel: Schalten einer TransitionGegeben sei eine Kantengewichtungsfunktion w, die jede Kante mit 1gewichtet, also
w: F→ 1
vor dem Schalten nach dem Schalten
– Beispiel: Schalten mit Kantengewicht
vor dem Schalten nach dem Schalten
2
3
2
3
– Beispiel: nichtschaltbare TransitionIn der linken Situation enthält die Stelle s2 zu wenige Tokens, da gemäßder Kantenmarkierung bei jedem Schalten der Transition t1 zwei Markenvon der Stelle s2 konsumiert werden. In der rechten Situation liegt dagegen
66
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
ein Markenüberfluss vor. Die Transition t1 kann nicht schalten, da auf derStelle s4 bereits ein Token liegt und damit die Kapazität der Stelle (1)bereits erschöpft ist. Durch ein Schalten würde ein weiteres Token der Stellehinzugefügt werden und die Kapazität überschreiten.
s3s3
s4
Markenmangel Markenüberfluss bei s4
2 2s2
s1
s2
s1
s4
Kapazität 1
t1 t1
Animation Petrinetzsiehe online Version
Nebenläufigkeit
Mit Petri-Netzen lassen sich nebenläufige Systeme auf einfache Weise modellie-ren. Betrachten wir zum Beispiel vier Aktivitäten t1, ... , t4, wobei jede Aktivitätdurch eine Transition modelliert wird. Nach Beendigung von t1 (z.B. Einlesen vonEingabewerten) können t2 (z.B. Berechne ggt) und t3 (z.B. Berechne Fibonacci)nebenläufig aktiv sein, aber sie müssen beide beendet sein, bevor t4 ausgeführtwird.
t1
t2
t3
t4
• Nichtdeterminismus
67
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
Bei einer gegebenen Markierung M können Konflikte hinsichtlich derSchaltbereitschaft von Transitionen auftreten. Zwei Transitionen t1 und t2 sindim Konflikt, wenn sie gemeinsame Eingangs- und Ausgangsstellen besitzen,die so markiert sind, dass nur eine von beidem Transitionen schalten kann.Es erfolgt eine nichtdeterministische Auswahl. Es erfolgt also eine zufälligeAuswahl der schaltbaren Transitionen.
– BeispielErzeuger/Verbraucher mit Konfliktbelegung. Nach dem nebenläufigenSchalten der Transitionen a und b des Netzes (siehe Situation oben) ergibtsich eine Konfliktbelegung (siehe Situation unten), in der nur entweder dieTransition c oder die Transition d schalten kann.
a c e d b
Erzeuger Verbraucher
nebenläufiges
Schalten
a c e d b
Konflikt
belegung
bzgl c und d
Eigenschaften von Netzen
Für ein gegebenes Petri-Netz, das das Verhalten eines verteilten Systemsmodelliert, sind wir daran interessiert, zu klären, ob das System bei gegebenerAnfangsmarkierung bestimmte Eigenschaften besitzt. Eigenschaften sind dieErreichbarkeit und die Lebendigkeit.
• ErreichbarkeitHäufig ist man an der Frage interessiert, ob das Netz ausgehend von einerMarkierung M irgendwann eine Folgemarkierung M’ erreicht. Das ist die Frageder Erreichbarkeit von Zuständen.
68
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
– Erreichbare MarkierungGegeben sei ein Petri-Netz (S, T, F) mit der Markierung M. Eine endlicheSequenz ρ = t1, t2, ..., tn mit ti ∈ T heißt von M aktivierte endlicheSchaltfolge, wenn Markierungen M1, M2, ..., Mn existieren mit
M M1t1
M2t2
Mntn
d.h. M Mn
In diesem Fall ist Mn von M aus erreichbar.M’ ist von M erreichbar, wenn es eine Sequenz ρ gibt, die von M inden Endzustand M’ führt. Um die erreichbaren Markierungen eines Netzeszu erfassen, modelliert man das Netz als einen Zustandsautomat, derüblicherweise als Graph dargestellt wird (Erreichbarkeitsgraph). Die Knotendes Graphen sind die erreichbaren Markierungen und die Kanten sind mitTransitionen beschriftet.
– Beispiel: BahnnetzVier Städte sind durch Bahngleise, die nur in einer Richtung befahrbar sind,im Kreis verbunden. Zwei Züge fahren auf der Strecke.
Aufgabe: Das System ist so zu konstruieren, dass sich niemals beide Zügeauf derselben Strecke befinden.
Lösung: Die Strecken werden mit Stellen s1, ... , s4 modelliert. EineMarke auf der Stelle si bedeutet, dass ein Zug auf der i-ten Strecke fährt.Durch die zusätzlichen Kontrollstellen k1, .. , k4 soll garantiert werden,dass in keiner erreichbaren Markierung mehr als eine Marke auf einer derStellen si liegt. ki kontrolliert den Zugang zur Strecke si (Stelle).
t4
t3
s4 k4
s1
s3
k1
k3
k2
t1
t2
Bahnnetzs2
Der Graph zeigt jeweils einen Zug auf Strecke s2 und s4.
69
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
k1, s2, k3, s4
k1, k2, s3, s4 s1, s2, k3, k4
s1, k2, s3, k4
k1, s2, s3, k4 s1, k2, k3, s4
t2 t4
t2t4
t1 t3
t1t3Erreichbarkeitsgraph
Die Zustände werden durch die Menge der markierten Stellen in einererreichbaren Markierung beschrieben. Der Erreichbarkeitsgraph zeigt, dasskein Zustand ereichbar ist, in dem mehr als eine Marke, also mehr als einZug, auf einer Stelle si liegt. Damit ist die gewünschte Eigenschaft korrektmodelliert.Die Frage, ob es einen Algorithmus gibt, der entscheidet, ob eine Markierungaus einer gegebenen Anfangsmarkierung aus erreichbar ist oder nicht,(Entscheidbarkeit des Erreichbarkeitsproblems), war ca. 10 Jahre lang offen.Prof. E.W. Mayr hat die Entscheidbarkeit 1980 in seiner Dissertation (an derTUM) bewiesen. Aber: der Algorithmus besitzt sehr hohe Komplexität, er istnicht effizient durchführbar.
• LebendigkeitseigenschaftenWie zu Beginn des Kapitels bereits erwähnt, verwendet man System-modelle häufig, um Lebendigkeitseigenschaften zu analysieren. Stellen-Transitionsnetze werden oft in Bereichen verwendet, in denen es auf die An-zahl und die Verteilung veränderlicher Objekte ankommt. (z.B. Daten in einemRechner, Waren in einem Lager, Werkstücke). Man ist daran interessiert zu er-kennen, ob es in einem System zu Blockierungen kommen kann, so dass Teiledes Systems blockiert sind oder der gesamte Ablauf zum Stillstand kommt.Ursachen für solche Situationen sind Mangel oder Stau, der durch die verän-derlichen Objekte ausgelöst wird.
– Netzdarstellungaktive Systemelemente als Transitionen (Prozessor, Maschine, etc.)passive Systemteile als Stellen (Speicher, Lager, etc.)veränderliche Objekte als MarkenFür Lebendigkeitsuntersuchungen sind Netzteile interessant, die niemalsmarkiert werden oder die niemals ihre Marken verlieren.
70
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
– DefinitionGegeben sei ein Petri-Netz (S, T, F) mit der Anfangsmarkierung M0.
∗ Das Netz heißt lebendig, wenn für jede erreichbare Markierung M und fürjede Transition t ∈ T eine Markierung M’ existiert, die aus M erreichbar istund in der t transitionsbereit ist. Informell: jede Transition t kann immerwieder irgendwann einmal schalten.∗ Die von M0 aus erreichbare Markierung M beschreibt eine vollständige
Verklemmung (eng. deadlock), wenn es keine Transition t ∈ T gibt, dieunter M schalten kann.∗ Die von M0 aus erreichbare Markierung M beschreibt eine lokale
Verklemmung, wenn es eine Transition t ∈ T gibt, so dass ausgehend vonM keine Folgemarkierung M’ erreichbar ist, in der t transitionsbereit ist.∗ Ist (S, T, F) mit Anfangsmarkierung M0 lebendig, dann ist es auch
verklemmungsfrei. Lebendige Netze stellen sicher, dass es weder zu einemMarkenmangel noch zu einem Überfluss kommt. Die Eigenschaft derLebendigkeit eines Netzes ist insbesondere für Systeme, die für einenEndlosbetrieb ausgelegt sind (z.B. Betriebssysteme) wichtig.
– Beispiel: Lebendiges Netz
Aufgabe: Modellierung eines FIFO-Puffers mit Kapazität 3. Und zwar so,dass er verklemmungsfrei und lebendig ist.
Lösung: Das System besteht aus 3 Zellen, die jeweils eine Nachrichtaufnehmen können (die Stellen repräsentieren die Speicherzellen). DieTransition t1 modelliert das Eingeben einer neuen Nachricht und dieTransition t4 modelliert die Ausgabe der Nachricht. Mit den Transitionenti werden die Nachrichten von Zelle si-1 zur Zelle si weitergereicht.Voraussetzung ist, dass die entsprechende Zelle leer ist. Der Zustand "Zellesi ist leer", wird durch die markierte Stelle ki modelliert.Das modellierte Netz ist verklemmungsfrei und lebendig. Falls der FIFOPuffer in ein größeres System eingebunden ist, müssen die Transition t1 (fürdie Eingabe von Nachrichten) und t4 (für die Ausgabe von Nachrichten) indas Gesamtsystem integriert werden.
71
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
t1 t2t2 t3 t4
s1 s2 s3
Eingabe einer
Nachricht
Ausgabe einer
Nachricht
k1 k2 k3
– Beispiel: Verklemmung2 Studenten benötigen ein 2-bändiges Lehrbuch. Student 1 leiht sich zunächstnur Band 1 aus und Student 2 leiht sich vorsorglich den noch vorhandenenBand 2 aus. Bevor Student 1 seinen ersten Band zurückgibt, möchte er nochden zweiten ausleihen. Auch Student 2 gibt seinen ausgeliehenen Band nichtzurück, sondern versucht, den ersten Band auszuleihen.
∗ Vor der AusleiheAnfangszustand des Netzes vor der Ausleihe. Die nachfolgende Abbildungzeigt zunächst das Netz, bevor einer der Studenten ein Buch ausleihtund die zweite Abbildung zeigt das Netz, nachdem die Studenten diejeweiligen Bände ausgeliehen haben.
72
Schlichter, TU München 3.3. MODELLIERUNG PARALLELER SYSTEME
Band 1
ausleihen
Band 2
ausleihen
beide Bände
zurückgeben
Band 1
ausleihen
Band 2
ausleihen
beide Bände
zurückgeben
Student 1 Band1 Band 2 Student 2
∗ Nach der AusleiheZustand des Netzes nach dem Schalten Transitionen, d.h. nach derAusleihe. Diese Abbildung zeigt, dass das Netz verklemmt ist; esgibt keinen Systemfortschritt mehr. Was ist das Problem unseresModells? Bei Student 1 und Student 2 haben die Ausleihe der Bänderunterschiedliche Reihenfolgen; bei gleicher Reihenfolge der Ausleihe trittkeine Verklemmung ein.
73
Schlichter, TU München 3.4. THREAD-KONZEPT
Band 1
ausleihen
Band 2
ausleihen
beide Bände
zurückgeben
Band 1
ausleihen
Band 2
ausleihen
beide Bände
zurückgeben
Student 1 Band1 Band 2 Student 2
• Weitere Eigenschaften
Weitere interessante Eigenschaften - nur ganz informell - sind
– FairnessGegeben sei ein Netz N mit Anfangsmarkierung M. Das Netz ist unfair füreine Transition t, wenn es eine unendliche Sequenz gibt, in der t nur endlichoft auftritt, obwohl t unendlich oft transitionsbereit ist.
– Verhungernt verhungert (engl. Starvation): Es gibt eine unendliche Sequenz, in der dieTransition t niemals auftritt. Falls unfaire Sequenz: trotz Transitionsbereit-schaft von t.
3.4 Thread-Konzept
Threads sind ein BS-Konzept für die Modellierung und Realisierung vonnebenläufigen Aktionen in einem Rechensystem. Threads (Kontrollflüsse) 2
beschreiben die Aktivitäten in einem Rechensystem. Sie können als virtuelle
2[nehmer2001 S97]
74
Schlichter, TU München 3.4. THREAD-KONZEPT
Prozessoren aufgefasst werden, die jeweils für die Ausführung eines zugeordnetenProgramms in einem Adressraum verantwortlich sind. Threads konkurrieren umdie physische CPU, um ablaufen zu können. In traditionellen Umgebungen hatjeder Prozess genau einen Thread, der den Kontrollfluss des Prozess repräsentiert,während in Multithreaded-Umgebungen ein Prozess mehrere Threads besitzenkann.
Prozess
Thread Thread
Benutzer
Adressraum
Betriebssystem
3.4.1 Charakterisierung von Threads
Aus BS-Sicht ist ein Prozess definiertdurch einen Adressraum.eine darin gespeicherte Handlungsvorschrift in Form eines sequentiellenProgramms (Programmcode).einen oder mehreren Aktivitätsträgern, die dynamisch die Handlungsvor-schrift ausführen⇒ Threads.
Motivation
Ein Thread ist die Abstraktion eines physischen Prozessors; er ist ein Träger einersequentiellen Aktivität. Gründe für die Einführung von Threads:
• mehrere Threads ermöglichen Parallelität innerhalb eines Prozesses unterNutzung des gemeinsamen Adressraums. Durch die Nutzung des gemeinsamenAdressraums wird die Interaktion zwischen den Threads (Kommunikation undgemeinsame Nutzung von Daten) erleichtert. Jeder Thread für sich gesehenrepräsentiert ein streng sequentielles Verarbeitungsmodell.
• Aufwand für Erzeugen und Löschen von Threads ist geringer als für Prozesse.Threads führen nicht so einen großen Ballast an Information mit sich als
75
Schlichter, TU München 3.4. THREAD-KONZEPT
Prozesse. Beispielsweise muss bei der Erzeugung eines Prozesses durchdas BS ein neuer Adressraum generiert werden; Threads laufen im bereitsvorhandenen Adressraum ab. Deshalb spricht man bei Threads auch vonLeichtgewichtsprozesse ("light weight processes"), da sie erheblich wenigerVerwaltungsinformation als normale Prozesse ("heavy weight processes")benötigen.
• Verbesserung der Performanz der Applikationsausführung durch Nutzungmehrerer Threads. Dieses Argument ist besonders dann von Bedeutung, wenndie Applikation (und damit der zugehörige Prozess) sowohl CPU- als auch E/A-intensive Aktivitäten beinhaltet. E/A-Wartezeiten innerhalb einer Applikationkönnen durch andere rechenbereite Threads der Applikation genutzt werden.Dagegen gewinnen CPU-dominierte Applikationen durch die Parallelisierungmittels Threads weniger an Performanz (falls nur eine CPU zur Verfügungsteht).
• Threads ermöglichen bei einem Multiprozessor-Rechensystem echte Paralleli-tät innerhalb einer Applikation.
Prozess vs. Thread
Prozesse und Threads haben unterschiedliche Zielsetzungen:
Prozesse gruppieren Ressourcen,
Threads sind Aktivitätsträger, die zur Ausführung einer CPU zugeteiltwerden.
• Threadspezifische InformationJeder Thread umfasst eine Reihe von Informationen, die seinen aktuellenZustand charakterisieren:
Befehlszähler, aktuelle Registerwerte, Keller, Ablaufzustand des Thread.
Ebenso wie ein Prozess befindet sich ein Thread in einem der nachfolgendenZustände: rechenwillig, rechnend, wartend, terminiert. Entsprechend denausgeführten Aktionen (z.B. Ein-/Ausgabe) und der Zuteilung bzw. des Entzugsder CPU finden Zustandsübergänge statt. Jeder Thread hat seinen eigenenKeller, in dem die Unterprogrammaufrufe verwaltet werden. Jeder Thread hatseinen eigenen Satz an Registern (darunter auch den Befehlszähler), die gerettet
76
Schlichter, TU München 3.4. THREAD-KONZEPT
werden müssen, falls einem Thread die CPU entzogen wird. Bei einer CPU-Zuteilung werden die geretteten Registerwerte des Threads in die jeweiligenRegister geladen.
• Prozessspezifische InformationVerschiedene Threads eines Prozesses sind nicht so ganz unabhängig wieverschiedene Prozesse. Die nachfolgende Information/Ressourcen wird vonallen Threads eines Prozesses geteilt. Jeder Thread des Prozesses kann sieverwenden bzw. darauf zugreifen.
Adressraum, globale Variable, offene Dateien, Kindprozesse (z.B. erzeugtmit fork), eingetroffene Alarme bzw. Interrupts, Verwaltungsinformation
Dies sind Eigenschaften des Prozesses und nicht eines einzelnen Threads.Beispielsweise, wenn ein Thread eine Datei öffnet, dann ist diese Datei auchfür die anderen Threads sichtbar, und sie können in sie schreiben bzw. aus ihrlesen. Diese Information ist i.a. zwischen Prozessen nicht sichtbar, außer dassvom Vaterprozess an den Kindprozess Dateideskriptoren vererbt werden.
Beispiel: Web-Server
Ein Prozess kann mehrere Threads umfassen, die unterschiedliche Aufgaben über-nehmen. Beispielsweise kann ein Web-Server einen Verteiler-Thread ("dispat-cher") und mehrere Server-Threads ("worker-thread") umfassen.
Web-Serverprozess
Benutzer
Adressraum
Betriebssystem
Verteiler-
Thread
Server-
Thread
Netzwerk-Verbindung
Anforderung
Auf diese Weise ist es möglich den Server als eine Menge von sequentiellenThreads zu realisieren. Der Verteiler-Thread ist eine unendliche Schleife, die die
77
Schlichter, TU München 3.4. THREAD-KONZEPT
Schnittstelle für den Eingang von Service-Anforderungen darstellt.
• Der Verteiler-Thread dient zur Annahme von Service-Anforderungen undgibt sie weiter an einen der Server-Threads zur Bearbeitung. Server-Threadskönnen bei Eintreffen einer Service-Anforderung jeweils dynamisch erzeugtwerden, und nach Erledigung der Anforderung bzw. nach Zustellung derAntwort terminiert werden. Zur Verbesserung der Antwortzeiten kann derWeb-Server bereits einen Pool von Server-Threads erzeugen, denen jeweilsdynamisch Anforderungen zugeteilt werden können. Server-Threads werdennach Bearbeitung einer Anforderung nicht beendet, sondern wieder in den Poolder freien Server-Threads eingereiht. Bei Bedarf können zusätzliche Server-Threads erzeugt werden, falls alle Server-Threads aus dem Pool bereits belegtsind.
• Alle Server-Threads nutzen den gemeinsamen Web-Cache.
3.4.2 Threads in Java
Java unterstützt die Programmierung mit Threads, um nebenläufige Abläufeinnerhalb einer Applikation zu ermöglichen. Java Threads können sowohl in Java-Programmen als auch in Java-Applets verwendet werden. Die Implementierungder Java Virtual Machine selbst beruht auf Threads: Der Java-Müllsammler(Garbage collector) ist z.B. ein Thread zum Sammeln von nicht längerreferenzierten Objekten, der nebenläufig zum Java Programm abläuft. Hiererfolgt nur eine sehr kurze Wiederholung einiger der Aspekte, die bereits in derInformatik-Einführungsvorlesung behandelt wurden. 3
Definition
Threads können durch Implementierung der Schnittstelle Runnable realisiertwerden. Eine weitere Möglichkeit besteht durch SubClassing der Klasse Threadselbst, d.h.
public class ReturnDigest extends Thread { ....... }
• Thread Implementierungen überschreiben die run-Methode der SchnittstelleRunnable.3siehe Einführung in die Informatik I/II von Prof. Seidl.
78
Schlichter, TU München 3.4. THREAD-KONZEPT
public class CallbackDigest implements Runnable {....public void run() { .... }
}
• Thread Instanzen werden durch den Aufruf der start-Methode der SchnittstelleRunnable gestartet. Diese Methode sollte durch eine Thread-Implementierungnicht verändert werden. Die start-Methode ruft die run-Methode auf, wodurchdie Instanz der Thread-Implementierung ausgeführt wird.
public static void main(String[] args) {....CallbackDigest cb = new CallbackDigest(...);Thread t = new Thread(cb);t.start();
}
Die Anweisung t.start() ruft die run-Methode der Klasse CallbackDigestauf.
Ergebnisrückgabe
Der Ablauf der Threads ist asynchron, d.h. die Ausführungsreihenfolge einerMenge von Threads ist nicht fest vordefiniert. Dies ist insbesondere beikooperierenden Threads von Bedeutung, z.B. bei der Ergebnisrückgabe einesThread an einen anderen Thread. Die Ausführungsreihenfolge ergibt sichdurch die CPU-Zuteilung (Scheduling) durch das Betriebssystem oder dasLaufzeitsystem. Dies bedeutet, dass bei der Kommunikation zwischen Threadsnicht von einem bestimmten Zeitverhalten der Threads ausgegangen werden kann,d.h. wann welche Threads ausgeführt werden.
• Direkter AnsatzAngenommen jeder Thread liest eine Datei und erzeugt daraus die zugehörigeHash-Information (z.B. verwendet für verschlüsselte Datenübertragung).
public class ReturnDigest implements Runnable {private File input;private byte[] digest;public ReturnDigest(File input) { this.input = input; }public void run() {
......digest = .......
}public byte[] getDigest() { return digest; }
79
Schlichter, TU München 3.4. THREAD-KONZEPT
}
public class ReturnDigestUserInterface {
......public static void main(String[] args) {
......for (int i = 0; i < args.length; i++) {
File f = new File(args[i]);ReturnDigest dr = new ReturnDigest(f);Thread t = new Thread(dr); t.start(); BerechnungHash.....byte[] digest = dr.getDigest(); Abruf von Hash....
}}
}
Jeder Thread speichert das Ergebnis der Dateibearbeitung in der Variablendigest, auf die über die Methode getDigest zugegriffen werden kann.t.start() ruft die run-Methode auf und berechnet die Hash-Information, diein der lokalen Variablen digest gespeichert wird.
– Die Ausführung führt zu dem Fehler
Exception in thread "main" java.lang.NullPointerExceptionat ReturnDigestUserInterface.main.Die Variable digest wird vor der Thread-Initalisierung benutzt. Dies liegtdaran, dass das Hauptprogramm nach der Erzeugung des Thread Zugriffauf die Variable digest erhält, ohne dass der Thread die Möglichkeit derIntialisierung bzw. zur Berechnung des Wertes für digest erhielt.
In einer single-threaded Umgebung würde dieses Programm korrekt ab-laufen, da nach t.start() sofort der entsprechende Thread ausgeführtwird.In einer multi-threaded Umgebung laufen die Threads dagegen asyn-chron ab, d.h. die CPU-Zuteilung hängt vom Laufzeitsystem (bzw. Be-triebssystem ab). Man könnte nun den main-Thread künstlich verzögern,jedoch es besteht eine "Race-Condition" zwischen den kooperierendenThreads und man kann keine Aussage über die Java Virtual Machine ma-chen, wann welcher Thread rechnend gesetzt wird.
Aufruf des interaktiven Beispiels: "java ReturnDigestUserInterface testda-tei1.txt testdatei2.txt testdatei3.txt".
80
Schlichter, TU München 3.5. SYNCHRONISATION
• Callback AnsatzNicht das main-Programm holt die Ergebnisse ab, sondern die aufgerufenenThreads rufen jeweils eine Methode des main-Programms auf, um dieErgebnisse zu übergeben⇒ Callback .
public class CallbackDigest implements Runnable {private File input;public CallbackDigest(File input) { this.input = input; }public void run() {
......byte[] digest = ........;CallbackDigestUserInterface.receiveDigest(digest);
}public byte[] getDigest() { return digest; }
}
public class CallbackDigestUserInterface {
......public static void receiveDigest(byte[] digest) {
.....}public static void main(String[] args) {
......for (int i = 0; i < args.length; i++) {
File f = new File(args[i]);CallbackDigest dr = new CallbackDigest(f);Thread t = new Thread(dr); t.start();
}}
}
Im Gegensatz zum main-Programm des direkten Ansatzes dient das main-Programm dieses Ansatzes nur zum Starten der verschiedenen Threads. Esversucht nicht die Berechnungen der getriggerten Threads direkt zu lesenund zu verarbeiten. Dies wird durch separate Methode receiveDigesterledigt. Aufruf des interaktiven Beispiels: "java CallbackDigestUserInterfacetestdatei1.txt testdatei2.txt testdatei3.txt".
3.5 Synchronisation
Eine wichtige Systemeigenschaft betrifft die Synchronisation paralleler Ereignis-se. In einem Rechensystem konkurrieren parallele Aktivitäten um wiederholt ex-
81
Schlichter, TU München 3.5. SYNCHRONISATION
klusiv (d.h. zu einem Zeitpunkt darf höchstens eine Aktivität die Ressource nut-zen) benutzbare Ressourcen, wie beispielsweise die CPU, den Drucker etc. Zu-sätzlich dazu können aber parallele Aktivitäten auch kooperieren, indem sie Datenüber gemeinsam benutzte exklusive Objekte austauschen oder sich Nachrichtenzusenden. In all diesen Fällen haben wir das Problem, den wechselseitigen Aus-schluss (engl. mutual exclusion) zu gewährleisten, d.h. sicherzustellen, dass nurhöchstens ein Prozess zu einem gegebenen Zeitpunkt eine exklusiv benutzbareRessource belegt.
3.5.1 Beispiele
Die beiden Beispiele basieren auf der speicherbasierten Prozessinteraktion,d.h. Prozesse (oder auch Threads) interagieren über gemeinsam zugreifbareSpeicherzellen.
Beispiel: gemeinsame Daten
P1 und P2 sind nebenläufige Prozesse, die in einem Multiprozessorsystem parallelablaufen. Die Variable x ist gemeinsame Variable. Prozess P1 läuft auf CPU 0mit Prozess P2 auf CPU 1 gleichzeitig ab. Das Problem ergibt sich auch beiquasiparallelem Ablauf (zeitliche Verschränkung der Arbeit der Prozesse). Z seiein Zeitpunkt nach Ausführung der Aktionen A und B. Welchen Wert hat x zumZeitpunkt Z?
Das Ergebnis des Ablaufs kann je nach zeitlichem Ablauf x = 1, 2, 3 sein.
Der grundlegende Nichtdeterminismus der Nebenläufigkeit wegen der Asynchro-nität schlägt hier auf die Ergebnisse der Prozesse durch.
82
Schlichter, TU München 3.5. SYNCHRONISATION
int x; x = 0
Prozess P1 Prozess P2
A: x = x + 1
B: x = x + 2
Zeitpunkt Z
• Das Ergebnis ist vom zeitlichen Ablauf abhängig. Es sind folgende Fällemöglich:
– Fall 1P1 liest x = 0, erhöht, speichert x = 1;P2 liest x = 1, erhöht, speichert x = 3; => Wert von x = 3
– Fall 2P2 liest x = 0, erhöht, speichert x = 2;P1 liest x = 2, erhöht, speichert x = 3; => Wert von x = 3
– Fall 3P1 und P2 lesen x = 0;P1 erhöht, speichert x = 1;P2 erhöht, speichert x = 2; => Wert von x = 2
– Fall 4P1 und P2 lesen x = 0;P2 erhöht, speichert x = 2;P1 erhöht, speichert x = 1; => Wert von x = 1
• Verhinderung des Nichtdeterminismus nur dadurch möglich, dass man garan-tiert, dass die Veränderung von x in den beiden Prozessen unter wechselseiti-gem Ausschluss (engl. mutual exclusion) erfolgt. Die Asynchronität der Pro-zesse muss also genau an dieser Stelle eingeschränkt werden. Vernderung be-steht in diesem Zusammenhang aus 3 Schritten: Lesen des Wertes, Erhöhen undSpeichern des neuen Wertes.
83
Schlichter, TU München 3.5. SYNCHRONISATION
Erzeuger-Verbraucher-Problem
Ein Beispiel für einen synchronisierten Zugriff auf eine gemeinsame Ressource,nämlich einen Puffer 4 , haben wir bereits kennengelernt. Interpretiert man dasbereits angesprochene→ Petri-Netz (siehe Seite 68) als eine Komposition aus dreiTeilen:
einem Erzeuger von Nachrichten (links),
einem Puffer für Nachrichten (Mitte) und
einem Verbraucher von Nachrichten (rechts).
So kann man sehen, dass durch diese Modellierung gewährleistet wird, dassErzeuger und Verbraucher nicht gleichzeitig etwas in den Puffer eintragen undaus ihm entnehmen können; sie greifen wechselseitig ausgeschlossen zu.
3.5.2 Definition: Wechselseitiger Ausschluss
Gegeben sei ein Petri-Netz (S, T, F) und eine Anfangsmarkierung M0.Wenn zwei Transitionen t1, t2 ∈ T wechselseitig ausgeschlossen sind,dann ist keine Markierung M’ erreichbar, so dass t1 und t2 unter dieserMarkierung gleichzeitig transaktionsbereit sind. Wir sagen, dass Transitionen, diewechselseitig ausgeschlossen auszuführen sind, kritische Abschnitte (engl criticalsection, critical region) eines Systemablaufs modellieren.
• Beispiel: gemeinsame DatenDer Zugriff auf gemeinsame Ressourcen, z.B. auf gemeinsame Variable,muss koordiniert werden. Bei exklusiven Ressourcen wird die Nutzungsequentialisiert. Die gemeinsame Ressource wird in einem kritischen Bereichbzgl. der gemeinsamen Ressource benutzt.
4Dieses Problem wurde bereits in der Einführungsvorlesung zu Informatik ausführlichbehandelt.
84
Schlichter, TU München 3.5. SYNCHRONISATION
Prozess P1:
main () {
.......
region x do
x = x + 1:
end region
........
}
Prozess P2:
main () {
.......
region x do
x = x + 2:
end region
........
}
3.5.3 Modellierung
Modelliert man parallele Einheiten, die kritische Abschnitte besitzen, durch Petri-Netze, so sind vier Phasen dieser parallelen Aktivitäten von Interesse:
1. Ausführen unkritischer Abschnitte/Transaktionen2. Betreten eines kritischen Abschnitts3. Ausführen der Transaktion(en) des kritischen Abschnitts4. Verlassen des kritischen Abschnitts.
Modellierung jeder Phase durch eine Transition; Koordinierung des wechselseiti-gen Ausschluss durch Kontrollstelle s.
t2
t3
t4
Prozess 1
t1
Prozess 2
Eintritt
Austritt Austritt
Eintritt
sk.A.
t1: Phase 1; unkritische Transition
t2: Phase 2; Eintritt in kritischen Abschnitt
t3: Phase 3; Ausführung des kritischen
Abschnitts
t4: Phase 4; Verlassen des kritischen
Abschnitts
s: Kontrollstelle
• Beispiel: Leser-Schreiber-Problem
85
Schlichter, TU München 3.5. SYNCHRONISATION
Betrachten wir als Beispiel ein weiteres klassisches Synchronisationsproblem:das Leser-Schreiber-Problem. Eine einfache Version des Leser-Schreiber-Problems ist wie folgt gegeben. Das System umfasst Lese-Aktivitäten, die inihrem kritischen Abschnitt lesend auf eine gemeinsame Ressource zugreifenund Schreib-Aktivitäten, die in ihrem kritischen Abschnitt schreibend auf diegemeinsame Ressource zugreifen. Wir fordern:
1. Lese-Aktionen im kritischen Abschnitt können parallel stattfinden, wobeidie Anzahl der parallelen Leser begrenzt sei, z.B. auf drei.2. Lese- und Schreib-Aktionen sind wechselseitig ausgeschlossen.3. auch Schreib-Aktionen sind untereinander wechselseitig ausgeschlossen.
Die Abbildung zeigt eine mögliche Modellierung mittels eines Petri-Netzesmit drei Lesern und drei Schreibern. Die Anfangsmarkierung der Stelle sbeschreibt die Anzahl der Leser, die maximal parallel im kritischen Abschnittarbeiten dürfen. Will ein Schreiber den kritischen Abschnitt betreten, so müssenalle drei Marken auf s liegen (kein Leser im kritischen Abschnitt). Durchdie Kantengewichtung, werden beim Betreten des kritischen Abschnitts alleMarken von s durch den Schreiber konsumiert. Beim Verlassen des kritischenAbschnitts, werden wieder drei Marken produziert, also allen Lesern wieder einZugriff ermöglicht.
Leser Schreiber
Eintritt
Austritt Austritt
Eintritt
sk.A. k.A.
3
3
Jedes Token im Leserteilnetz repräsentiert einen Leser; jedes Token imSchreiberteilnetz repräsentiert einen Schreiber.
86
Schlichter, TU München 3.5. SYNCHRONISATION
3.5.4 Synchronisierungskonzepte
Ziel: Einführung wichtiger Realisierungskonzepte zur Synchronisierung parallelerAbläufe. Dazu Konkretisierung des Prozessbegriffs. Um die modellierten Eigen-schaften eines System zu realisieren, benötigt man Konzepte zur Formulierungparalleler Abläufe. Auf der programmiersprachlichen Ebene sind dies Sprachkon-strukte, wie die Java-Threads oder die Ada-Tasks. Für das Folgende benötigenwir einen Prozessbegriff, der den abstrakten → Prozessbegriff (siehe Seite 52)zunächst nur so konkretisiert, dass wir damit erste wichtige Konzepte zur Rea-lisierung von Abhängigkeiten zwischen parallelen Aktivitäten einführen können.Dies ist ein erster Schritt in die Richtung auf einen Prozess, wie er auf der Be-triebssystemebene benötigt wird. Auf die weitere Konkretisierung eines Prozessesals Betriebssystem-Verwaltungseinheit zusammen mit den Maßnahmen zur seinerVerwaltung gehen wir in den folgenden Abschnitten ein.
Prozess - Konkretisierung
Ein Prozess ist ein eindeutig identifizierbarer Ablauf eines Programms ineinem Rechensystem. Der Ablauf ist bestimmt durch die Befehle und Datendes Programms. Ein Prozess kann unterschiedliche Zustände besitzen. Wirunterscheiden die Zustände erzeugt, rechnend, rechenwillig, wartend, terminiert.Die Zustände eines Prozesses und Beispiele für Aktionen, die Zustandsübergängezur Folge haben, sind in der Abbildung angegeben.
rechnenderzeugt
wartend
termi-
niert
rechen-
willig
fork start
end
E/A-Auftrag
CPU-Entzug
CPU
Zuteilung
E/A-
Auftrag
beendet
killkill
Zur Verwaltung eines Prozesses wird eine Datenstruktur benötigt, die die Infor-mation, die einen Prozess charakterisiert, beinhaltet. Dies ist der Prozess-Kontext(Prozess-Deskriptor), der auf dieser Konkretisierungsebene den eindeutigen Pro-zessnamen und die Prozesszustände umfasst und später noch erweitert wird (z.B.
87
Schlichter, TU München 3.5. SYNCHRONISATION
Priorität, Registerinhalte).
Konzepte für wechselseitigen Ausschluss
Die Netz-Modellierung hat bereits gezeigt, dass man zur Synchronisation vonProzessen spezifische Kontrollkomponenten benötigt (z.B. zusätzliche Stellenim Petri-Netz, oder Kapazitätsbeschränkungen, die implizit durch die abstrakteKontrollkomponente, die die Transitionsbereitschaft von Transitionen prüft,kontrolliert werden).
Weiterhin hat die Modellierung gezeigt, dass durch die Synchronisationsmaßnah-men, die ja im wesentlichen durch absichtlich herbeigeführte Konflikte modelliertwurden, ggf. unfaire Abläufe auftreten, die in einem realisierten System natürlichunerwünscht sind. Das heißt, wir benötigen geeignete Konzepte, durch die dieseKontrollaufgaben wahrgenommen werden und ein unfaires Verhalten vermiedenwird.
• AnforderungenFolgende Anforderungen sind an eine Realisierung des wechselseitigenAusschlusses (w.A.) zu stellen:
– Die kritischen Abschnitte der Prozesse sind wechselseitig auszuschließen.
– Eine Realisierung des w.A. darf nicht von einer Annahme über dieReihenfolge, in der die Prozesse ihre kritischen Abschnitte ausführen,abhängen.
– Eine Realisierung des w.A. darf nicht von Annahmen über die Ausführungs-zeit der Prozesse abhängen.
– Unter der Annahme, dass Prozesse nach endlicher Zeit ihre kritischenAbschnitte wieder verlassen, muss gelten, dass kein Prozess einen anderenProzess unendlich lange daran hindern darf, seinen kritischen Abschnittauszuführen.
• Jede Realisierung des w.A. benötigt eine Basis, mit festgelegten atomaren, d.h.nicht teilbaren Operationen. Diese unteilbaren Basisoperationen sind von Hard-und/oder Software zur Verfügung zu stellen. Informell: mit einer atomarenOperation kann überprüft werden, ob der kritische Abschnitt frei ist; fallsja kann er sofort betreten werden (und der kritische Abschnitt damit belegtwerden). Falls die Abfrage und das Betreten nicht atomar sind, können mehrerezeitlich-verzahnte Abfrage stattfinden, und gegebenenfalls mehrere Prozesseden kritischen Abschnitt betreten.
88
Schlichter, TU München 3.5. SYNCHRONISATION
• UnterbrechungssperreDer Ablauf des Prozesses darf nicht unterbrochen werden.
– In Ein-Prozessorsystemen (1 CPU) kann es ausreichend sein, mit Enable undDisable Interrupt Operationen dafür zu sorgen, dass der Prozess, der einenkritischen Abschnitt ausführt, dabei nicht unterbrochen wird. Dies ist nureine sinnvolle Vorgehensweise, wenn die kritischen Abschnitte kurz sind, daansonsten die Systemantwortzeiten sehr hoch werden und u.U. E/A-Aufträgenicht rechtzeitig behandelt werden. Atomarität durch Unterbrechungssperrefunktioniert nicht unbedingt bei Mehrprozessormaschinen.
– Realisierung mit Unterbrechungssperre ist nützlich für den Betriebssystem-kern, aber sollte nicht für allgemeine Benutzerprogramme zur Verfügung ste-hen. Maschine ’hängt’, wenn Benutzerprogramm den kritischen Abschnittnicht mehr verlässt.
• Test-and-Set OperationenTest-and-Set Operationen (Test-And-Set-Lock, TSL) erlauben auf Hardware-Ebene (Maschinenbefehl) das Lesen und Schreiben einer Speicherzelle alsatomare Operation.
– Semantik eines Test-and-Set-BefehlsDie Instruktion liest den Inhalt eines Speicherwortes in ein Register undschreibt einen Wert ungleich Null an die Adresse dieses Wortes. Diese beidenOperationen werden als atomare, unteilbare Sequenz ausgeführt.
Sei a die zu untersuchende Speicherzelle; der Wert 1 in der Speicherzellekann dahingehend interpretiert werden, dass der Zugang in den kritischenBereich nicht möglich ist.
Befehl "TSL R, a" entspricht dannRegister R = inhalt von a;a = 1
Falls R = 1 ist, ist der kritische Bereich bereits belegt, andernfalls war erfrei und er wurde vom ausführenden Prozess belegt.
Durch Hardware bereitgestellte atomare Lese- und Schreiboperationen findetman z.B. in Sun SPARC mit Befehl: compare and swap; entsprechendes gibtes bei Motorola, Intel 80x86, Mips R4000.
∗ Problem: wie Atomarität bei Rechensystem mit mehreren CPUs gewähr-leistet?∗ Lösung: Die CPU, die die TSL-Instruktion ausführt, blockiert den
Speicherbus, um andere CPU’s (Multi-Prozessorumgebung) daran zuhindern, auf die Speichereinheit zuzugreifen.
89
Schlichter, TU München 3.5. SYNCHRONISATION
• Dienste mit passivem WartenUnterscheidung zwischen
aktivem Warten: Prozess muss periodisch selber prüfen, ob die Vorausset-zungen zum Weiterarbeiten erfüllt sind.
passivem Warten: Prozess wird in Warte-Zustand versetzt und aufgeweckt,wenn das Ereignis, auf das er wartet, eingetreten ist.
Aktives Warten hat den Nachteil, dass für andere Prozesse nutzbare CPU-Zyklen durch das wiederholte Anfragen, ob die Voraussetzungen zumWeiterarbeiten erfüllt sind, nutzlos verschwendet werden. Nachfolgend werdeneinige Dienste für passives Warten kurz aufgelistet.
– Methoden oder Dienste, so dass unter Mithilfe des Betriebssystems einProzess in den Zustand wartend übergeführt wird.
– beim Eintreten eines passenden "Weckereignisses" wird der Prozessvom Betriebssystem vom Zustand wartend in den Zustand rechenbereitübergeführt.
– Beispiel: Java wait und notify.Wait: passives Warten auf das Eintreffen einer Bedingung und atomargleichzeitig Freigabe der umfassenden Sperre einer synchronizedMethode. Wait/notify nur innerhalb von synchronized nutzbar!Notify: Benachrichtigen eines wartenden Threads.
Aber: in Java nicht möglich anzugeben, auf WAS ein Thread warten sollbzw. WELCHE Bedingung eingetreten ist. Nach dem Aufwecken mussder Thread also noch einmal explizit prüfen, ob der Weckruf den Threadwirklich betrifft. In Unix gibt es die Aufrufe Sleep and Wakeup; diessind Betriebssystemaufrufe, mit denen der Aufrufer blockiert und wiederrechenbereit gesetzt werden kann.
• Semaphor-KonzeptDas Semaphor-Konzept ermöglicht die Realisierung des w.A. auf einem hö-heren Abstraktionslevel als die bereits angesprochenen Hardwareoperationen.Zur Realisierung wird aber auf diese wieder zurückgegriffen. Realisierung vonSemaphoren mit aktivem und passivem Warten möglich.
• Monitor-Konzept
90
Schlichter, TU München 3.5. SYNCHRONISATION
Das Monitor-Konzept basiert auf der Idee, die in einem kritischen Bereichbearbeiteten Daten zusammen mit den darauf definierten Zugriffsoperationenin einer sprachlichen Einheit - dem Monitor - zusammenzufassen.
soll Probleme, wie sie bei der Programmierung von Semaphoren auftreten,vermeiden. Beispiele sind die Vertauschung der P-Operationen beiSemaphoren, oder das Vergessen der zugehörigen V-Operation. BeiMonitoren wird die richtige Reihenfolge der Synchronisierungsoperationendurch den Compiler generiert.
zu einem Zeitpunkt höchstens ein Prozess innerhalb des Monitors aktiv.Prozesse können zwar jederzeit die Methoden (Prozeduren) eines Monitorsaufrufen, jedoch können sie nicht direkt auf die internen Daten einesMonitors zugreifen. Zu jedem Augenblick kann nur ein Prozess innerhalbdes Monitors aktiv sein. Der erfolgreiche Aufruf einer Monitorprozedurist gleichbedeutend mit der Sperre des Monitors, die bis zum Verlassender Monitorprozedur bestehen bleibt. Die Vorteile des Monitor-Konzeptsgegenüber den Semaphoren ist a) die gemeinsamen Daten werden in derProgrammstruktur der beteiligten Prozesse explizit sichtbar gemacht, undb) Monitore kapseln alle relevanten Daten und Algorithmen des kritischenBereichs.
Initialisierungscode
Operationen
Gemeinsame Daten
Warte
schlange
– Definition von Bedingungsvariablen zur Spezifikation anwendungsspezifi-scher Bedingungen. Innerhalb eines Monitors können Condition-Variable de-finiert werden, die anwendungsspezifische Bedingungen formulieren. JedeCondition-Variable steht für eine Bedingung, die für die Fortsetzung einesProzesses in einer Monitorprozedur erfüllt sein muss. Falls die Bedingungnicht erfüllt ist, wird die wait-Operation auf dieser Condition-Variable aus-geführt. Mit signal können Prozesse wieder aufgeweckt werden.
– Operationen auf Bedingungsvariable cond
91
Schlichter, TU München 3.5. SYNCHRONISATION
cond.wait(): Prozess wird wartend gesetzt. Er bleibt solange war-tend, bis ein anderer Prozess die signal-Operation auf der Bedingungsva-riablen cond ausführt.
cond.signal(): ein wartender Prozess wird aktiviert. Falls keinProzess wartet, hat signal keine Auswirkungen. Falls ein Prozess Qaktiviert wird, sorgt das Monitorkonzept dafür, dass nun nicht beideProzesse, der aktivierende Prozess P und der aktivierte Prozess Q imMonitor aktiv sind.
signal and wait: P wartet entweder bis Q den Monitor verlässt oder wartetauf eine andere Bedingung.signal and continue: Q wartet entweder bis P den Monitor verlässt oderwartet noch auf eine andere Bedingung.
3.5.5 Semaphore
Semaphore wurden 1968 von Dijkstra eingeführt. Ein Semaphor (Signalmast) isteine ganzzahlige Koordinierungsvariable s, auf der nur die drei vordefiniertenOperationen (Methoden) zulässig sind:
Initialisierung,Prolog P (kommt von protekt),Epilog V (kommt von vrej).
In der Einführungsvorlesung von Prof. Seidl wurden die Bezeichnung down für Pund up für V verwendet.
Operationen
Die Operationen P und V sind atomar; sie sind unteilbar und sie werdenwechselseitig ausgeschlossen ausgeführt.
Sei s die Koordinierungsvariable, dann sind die P und V Operationen wienachfolgend definiert.
Die Operation müssen mit Hilfe von Systemdiensten so realisiert werden, dasssie wechselseitig ausgeschlossen ausgeführt werden. Vorsicht: hier gibt es keineganz einheitliche Definition in der Literatur für die beiden Operationen. MöglicheRealisierung auf Hardware-Ebene mittels des Test-and-Set Maschinenbefehls. DieP und V Operationen werden mit Hilfe von TSL im BS-Kern auf Maschinenebenerealisiert.
92
Schlichter, TU München 3.5. SYNCHRONISATION
• Informelle Charakterisierungpublic void P (int s) {
s = s - 1;if ( s < 0 ) { Prozess in die Menge der bzgl. s wartendenProzesse einreihen }
}
public void V (int s) {s = s + 1;if ( s ≤ 0 ) { führe genau einen der bzgl. s wartendenProzesse in den Zustand rechenwillig über }
}s ist mit einem ganzzahligen Wert vorbesetzt, z.B. s = 1. Falls s mit einem Wertgrößer 1 vorbesetzt ist, bedeutet dies die Anzahl der Prozesse, die gleichzeitigim kritischen Bereich erlaubt sind. Die beiden Funktionen müssen jeweilsatomar ausgeführt werden, d.h. nicht als Java Programm.
• Binäres Semaphor: die Kontrollvariable s nimmt nur boolesche Werte an.
man spricht auch von Mutex.
– Mutex in PosixEin Posix Mutex ist als binäres Semaphor eine einfache Sperre, die dieNutzung gemeinsamer Ressourcen absichert.
pthread_mutex_init(mutex)⇒ initialisiert und konfiguriert ein Mutex.pthread_mutex_lock(mutex) ⇒ entspricht der P-Operation; sperrt einMutex.pthread_mutex_unlock(mutex) ⇒ entspricht der V-Operation; gibt einMutex frei.
Mutex Objekte und Semaphore mit Integer Werten stehen auch in Windowszur Verfügung.
Einsatz von Semaphoren
Notation: Zur Vereinfachung gehen wir im Folgenden von einem vordefiniertenTyp semaphor(int s) aus, der die P und V Operationen als vordefinierte,atomare Methoden anbietet. Semaphor-Objekte werden als Instanzen bezüglichdes Typs semaphor erzeugt, wobei bei der Instantiierung das Semaphor mit demParameter s initialisiert wird.
• Zugang zu kritischen Abschnitten
93
Schlichter, TU München 3.5. SYNCHRONISATION
Realisierung der kritischen Abschnitte von Prozessen, in denen auf eineexklusiv benutzbare Ressource X zugegriffen wird:
1. Definition eines Semaphor-Objekts wa: semaphor(1), d.h. Initialisierung derKontrollvariable des Semaphor-Objekts wa mit 1.
2. Klammern der kritischen Abschnitte, in denen auf die Ressource Xzugegriffen wird, mit P und V Operationen:
wa.PCode mit Zugriffen auf Xwa.V
• Die Anforderungen an Lösungen des wechselseitigen Ausschlusses sind mitdem Semaphor-Konzept aus folgenden Gründen erfüllt:
– Wechselseitiger Ausschluss für alle kritischen Abschnitte. Aufgrund derInitialisierung der Koordinierungsvariablen mit 1 kann sich stets nur einProzess in einem kritischen Abschnitt befinden.
– keine Reihenfolge-Annahmen. Annahmen über die Ausführungsreihenfolgeder kritischen Abschnitte gehen nicht ein.
– keine Ausführungszeit-Annahmen. Es werden keine Annahmen über dieAusführungszeiten der Prozesse gemacht.
– kein Verhungern. Hier muss bei der Realisierung des Semaphors einefaire Strategie, z.B. FIFO (First-In-First-Out), zum Einsatz kommen. Wenndie blockierten Prozesse aus dem Warteraum nach FIFO entnommenwerden und jeder kritische Abschnitt mit der P- und der V-Operation desSemaphors geklammert ist, wird jeder blockierte Prozess nach endlicher Zeitentblockiert und kann somit seinen kritischen Abschnitt ausführen.
Beispiel Erzeuger-Verbraucher
Im Modellierungsteil wurde das → Erzeuger-Verbraucher-Problem (sieheSeite 68) bereits kurz vorgestellt.
Der Erzeuger-Prozess E erzeugt Datenelemente und schreibt sie in einenPuffer W.Der Verbraucher-Prozess V liest Datenelemente aus dem Puffer undverarbeitet sie.Der Zugriff der beiden Prozesse auf den Puffer ist zu synchronisieren.
Lösung dieses Problems mittels Semaphor.
94
Schlichter, TU München 3.5. SYNCHRONISATION
• Variante 1Zugriff auf Puffer W erfolgt durch Semaphor wa: semaphor(1); sowohl derErzeuger-Prozess E als auch der Verbraucher-Prozess V rufen vor jedem Zugriffauf den Puffer W die entsprechenden Operationen des Semaphors wa auf.
Erzeuger E:
while (true) {
produziere
wa.P
schreibe nach W
wa.V
}
Verbraucher V:
while (true) {
wa.P
entnimm aus W, falls Element da; sonst warte
wa.V
verarbeite
}
Problem: es kann eine Verklemmung auftreten, wenn der Verbraucher wa.Pausführt und warten muss, weil der Puffer kein Element enthält. Andererseitskann der Erzeuger den Puffer nicht betreten, da bereits der Verbraucher denPuffer exklusiv belegt hat.
• Variante 2Einführen eines zusätzlichen Semaphors voll: semaphor(0), das die Datenele-mente im Puffer zählt:
Erzeuger E:
while (true) {
produziere
wa.P
schreibe nach W
wa.V
voll.V
}
Verbraucher V:
while (true) {
voll.P
wa.P
entnimm aus W
wa.V
verarbeite
}
Für den Erzeuger ergibt sich natürlich ein analoges Problem, falls der Puffer Wnur eine beschränkte Kapazität besitzt. Eine Abhilfe kann analog wieder durchdie Einführung eines weiteren Semaphors "leer" erreicht werden. Dieses stelltsicher, dass der Erzeuger den Puffer nicht betritt, wenn der Puffer bereits vollist.
• Variante 3
95
Schlichter, TU München 3.5. SYNCHRONISATION
Einführen eines zusätzlichen Semaphors leer: semaphor(n), das die Anzahl derfreien Elemente im Puffer zählt:
Erzeuger E:
while (true) {
produziere Einheit;
leer.P;
wa.P;
schreibe Einheit nach W;
wa.V;
voll.V;
}
Verbraucher V:
while (true) {
voll.P;
wa.P;
entnimm Einheit aus W
wa.V
leer.V;
verarbeiteEinheit;
}
wa.semaphor(1); //kontrolliert den Zugang zum kritischen Bereich
voll.semaphor(0); //zählt die Anzahl der Einheiten im Puffer
leer.semaphor(n); //zählt die Anzahl der freien Pufferplätze
Darf die Reihenfolge der P-Operationen für die Semaphore leer, voll, wabeim Erzeuger bzw. beim Verbraucher vertauscht werden, ohne dass sichAblaufprobleme ergeben?
Beispiel Philosophenproblem
Zu den klassischen Synchronisationsproblemen zählt das Problem der speisendenPhilosophen ("Dining Philosophers"). In einem Elfenbeinturm leben fünfPhilosophen. Der Tageszyklus eines jeden Philosophen besteht abwechselnd ausEssen und Denken. Die fünf Philosophen essen an einem runden Tisch, auf dem inder Mitte eine Schüssel voller Reis steht. Jeder Philosoph hat seinen festen Platzan dem Tisch und zwischen zwei Plätzen liegt genau ein Stäbchen. Das Problemder Philosophen besteht nun darin, dass der Reis nur mit genau zwei Stäbchenzu essen sind. Darüber hinaus darf jeder Philosoph nur das direkt rechts und dasdirekt links neben ihm liegende Stäbchen zum Essen benutzen. Das bedeutet, dasszwei benachbarte Philosophen nicht gleichzeitig essen können.
96
Schlichter, TU München 3.5. SYNCHRONISATION
1
04
3
2
0
1
2
3
4
• Realisierung mit Semaphoren
– Variante 1Für eine Lösung des Philosophenproblems seien die folgenden 5 Semaphoredefiniert: stab_0, stab_1, ...., stab_4, wobei jedes der 5 Semaphore mit 1initialisiert ist. Jeder Philosoph j, mit j ∈ {0,...,4}, führe den folgendenAlgorithmus aus:philosoph_j:
while (true) {Denken;stab_i.P; mit i = jstab_i.P; mit i = j + 1 mod 5Essenstab_i.V; mit i = jstab_i.V; mit i = j + 1 mod 5
}Der angegebene Algorithmus liefert keine korrekte Lösung des wechselsei-tigen Ausschlusses! Wenn alle fünf Philosophen gleichzeitig die erste P-Operation (stab_i.P mit i = j) ausführen, d.h. alle gleichzeitig ihr linkes Stäb-chen nehmen, folgt daraus eine Verklemmungs-Situation, da kein Philosophdas zweite Stäbchen nehmen kann. Bei Ausführung der zweiten P-Operationstab_i.P; mit i=j+1 mod 5 werden alle Philosophen blockiert. Die Philoso-phen verhungern somit.
– Variante 2Nur vier Philosophen dürfen gleichzeitig zu ihrem linken Stäbchengreifen. Dies wird durch Einführung eines weiteren Semaphors tisch:semaphor(4), das mit 4 initialisiert wird, erreicht. Der "Anweisungsteil"jedes Philosophen wird zusätzlich mit tisch.P und tisch.V geklammert.
97
Schlichter, TU München 3.5. SYNCHRONISATION
Dadurch ist gewährleistet, dass höchstens vier Philosophen gleichzeitig ihrlinkes Stäbchen nehmen können und somit immer mindestens ein Philosophauch sein zweites Stäbchen nehmen und damit essen kann. Es ergibt sichalso folgende Lösung: Jeder Philosoph j, mit j ∈ {0,...,4} führt den folgendenAlgorithmus aus:philosoph_j:
while (true) {Denken;tisch.Pstab_i.P; mit i = jstab_i.P; mit i = j + 1 mod 5Essenstab_i.V; mit i = jstab_i.V; mit i = j + 1 mod 5tisch.V
}Ein weiterer wichtiger Aspekt ist die Reihenfolge bei der Ausführungvon P Operation, falls mehrere Semaphore belegt werden müssen.Eine unterschiedliche Reihenfolge der P-Operationen bei den beteiligtenProzessen kann leicht zu einer Verklemmung führen.
3.5.6 Synchronisierung von Java Threads
Java unterstützt synchronisierte Methoden. 5
public synchronized void methodname(...) { ... }Eine synchronisierte Methode kann nur exklusiv von einem Java Thread betretenwerden. Andere Threads können die synchronisierte Methode erst dann betreten,wenn der erste Java Thread die Methode wieder verlässt. Einer der wartendenThreads wird aktiviert. 6
Beispiel TakeANumber Class
Nur ein Thread kann zu einem Zeitpunkt eine Nummer ziehenclass TakeANumber {
private int next = 0; //next place in linepublic synchronized int nextNumber() {
next = next + 1; return next;} //nextNumber
} //TakeANumber5siehe Informatik II, Kap. 14 von Prof. Brügge6[morelli2000, S727; harold2001, S141]
98
Schlichter, TU München 3.5. SYNCHRONISATION
Wenn ein Thread die synchronized Methode betritt und ausführt, kann keinanderer Thread diese Methode solange nicht ausführen, bis nicht der erste Threaddie Methode wieder verlässt.public class Customer extends Thread {
private static int number = 1000; //initial customer IDprivate int id;private TakeANumber takeANumber;public Customer(TakeANumber gadget) {
id = ++number;takeANumber = gadget;
} //Customer constructorpublic void run() {
try {sleep( (int)(Math.random() * 1000) );System.out.println("Customer "+id+" takes ticket " +takeANumber.nextNumber());
} catch ......} //run
} //Customerpublic class Bakery {
public static void main(String args[]) {System.out.println("Starting Customer threads");TakeANumber numberGadget = new TakeANumber();.........for (int k = 0; k < 5; k++) {
Customer customer = new Customer(numberGadget);customer.start();
}} // main
} //BakeryDie Kunden kommen hierbei nicht alle gleichzeitig, sondern die Ankunftszeitwird zufällig gewählt; sleep heißt, der jeweilige Kunde wird nach seinerErzeugung für eine zufällige Zeit "Schlafen" gelegt, bevor er als Kunde eineNummer zieht. Durch "geeignete" Wahl der Zufallszahl können Kunden auch"fast" gleichzeitig eine Nummer ziehen. Was hier nun noch fehlt, ist eineVerkäuferklasse, die jeweils die Kunden entsprechend ihrer gezogenen Nummerbedient (siehe Morelli Kap 15, S 728).
Java Monitor
Ein Monitor ist ein Java-Objekt, das synchronisierte Methoden enthält.
• Ein Monitor stellt sicher, dass nur ein Thread zur Zeit in einer der
99
Schlichter, TU München 3.6. VERKLEMMUNGEN
synchronisierten Methoden sein kann. Bei Aufruf einer synchronisierteMethode wird das Objekt gesperrt.
• Während das Objekt gesperrt ist, können keine anderen synchronisiertenMethoden des Objekts aufgerufen werden. Andere Threads müssen warten, bisder erste Thread die synchronisierte Methode wieder verlässt, und damit dieSperre freigibt.
• Kritische Abschnitte können in Java als Objekte mit den zugehörigensynchronisierten Methoden spezifiziert werden. Synchronisierte Methodenkönnen je nach der verwendeten Java Virtual Machine sehr aufwendig undlangsam sein. Weiterhin ist zu beachten, dass zwar innerhalb eines Monitorseine synchronisierte Methode andere synchronisierte Methoden blockiert, nichtjedoch unsynchronisierte Methoden. Dies kann u.U. zu Problemen führen.
3.6 Verklemmungen
Mit Verklemmung (engl. deadlock) bezeichnet man einen Zustand, in dem diebeteiligten Prozesse wechselseitig auf den Eintritt von Bedingungen warten, dienur durch andere Prozesse in dieser Gruppe selbst hergestellt werden können.Verklemmungen können durch die gemeinsame Verwendung von Ressourcen(synonym verwenden wir auch den Begriff Betriebsmittel), wie z.B. CPU,Arbeitsspeicher, E/A-Geräte, Dateien auftreten. Ein Beispiel aus der allgemeinenPraxis ist eine Verkehrskreuzung, wobei alle 4 Fahrzeuge geradeaus über dieKreuzung fahren wollen; falls jedes Fahrzeug in die Kreuzung einfährt, könnensie sich gegenseitig blockieren. 7
Der Austausch von Information über gemeinsame Speicherbereiche ist einehäufige Situation (speicherbasierte Prozessinteraktion), die bei unkorrekterVerwendung von Synchronisationsoperationen (z.B. P und V bei Semaphoren)leicht zu Verklemmungen führen kann; siehe die → Variante 1 (siehe Seite 95)des Erzeuger-Verbraucher Lösungsansatzes. Dieser Abschnitt skizziert nur dieAnsätze zur Erkennung, Vermeidung und Verhinderung von Verklemmungen.
3.6.1 Allgemeines
Es lässt sich zeigen, dass die folgenden Bedingungen notwendig und hinreichenddafür sind, dass eine Verklemmung auftreten kann.
7Stallings S263.
100
Schlichter, TU München 3.6. VERKLEMMUNGEN
1. Die gemeinsam benutzbaren Ressourcen können nicht parallel genutzt werden,d.h. sie sind nur exklusiv benutzbar.
2. Die zugeteilten/belegten Ressourcen können nicht entzogen werden, d.h. dieNutzung ist nicht unterbrechbar.
3. Prozesse belegen die schon zugeteilten Ressourcen auch dann, wenn sie aufdie Zuteilung weiterer Ressourcen warten, d.h. wenn sie weitere Ressourcenanfordern.
4. Es gibt eine zyklische Kette von Prozessen, von denen jeder mindestens eineRessource belegt, die der nächste Prozess in der Kette benötigt, d.h. zirkuläreWartebedingung.
3.6.2 Belegungs-Anforderungsgraph
Die Zuteilung/Belegung und Anforderung von Ressourcen kann man sichan einem Graphen, dem Belegungs-Anforderungsgraph, veranschaulichen. DieKnoten sind die Prozesse und Ressourcen, die Kanten spiegeln Belegungen undAnforderungen wider.
• BeispielSeien P = {P1, ... , Pn} Prozesse und R= {R1, ... , Rm} Ressourcen, z.B. n = 3und m = 4. Beispiel eines Belegungs/Anforderungsgraphen.
P1 R1fordert
R2
belegt
P2
belegt
fordertR3
fordert
P3
belegt
R4belegt
P1 und P2 warten gegenseitig aufeinander. P1 wartet auf R1, die durch P2 belegtist, und P2 wartet auf R2, die durch P1 belegt ist.
3.6.3 Verklemmungs-Ignorierung
In vielen Systemen wird eine ’Vogel-Strauß’-Politik in bezug auf die Deadlock-problematik verfolgt, d.h. es werden keine Maßnahmen eingesetzt, sondern es
101
Schlichter, TU München 3.6. VERKLEMMUNGEN
wird gehofft, dass alles gut geht. In Unix wird diese Philosophie z.B. bei derVerwaltung der Prozesstabelle verfolgt. Es ist der manuelle Eingriff des Syste-madministrators erforderlich. Prozesstabelle ist eher einfach. Sie kann jedoch beider Erzeugung neuer Prozesse durch "fork" überlaufen, d.h. es können keine neu-en Prozesse mehr eingetragen und damit erzeugt werden. Prozesse warten bis sieeinen neuen Prozess erfolgreich erzeugen können. Die Tabelle ist jedoch groß ge-nug, so dass dieser Fall sehr selten eintritt. Meist tritt er nur bei einem fehlerhaftprogrammierten Programm, z.B. unendliche while Schleife, die bei jedem Durch-lauf ein fork absetzt.
3.6.4 Verklemmungs-Erkennung
In der Praxis häufig angewendete Strategie: Verklemmungen in Kauf nehmen,sie erkennen und beseitigen. Man versucht eine Verklemmung festzustellenund sie, sollte sie eingetreten sein, zu beseitigen. Indiz für Verklemmungen,z.B. angeforderte Ressource ist nach einer gewissen Zeit immer noch nichtzugewiesen.
• Erkennungs-AlgorithmusAnsatz 1: Suche nach Zyklen im Belegungs/Anforderungsgraph.Ansatz 2: Prüfen, ob es eine Reihenfolge für die Ausführung der Prozesse gibt,so dass alle Prozesse terminieren können.
• Vorgehen für Ansatz 2
1. Starte mit Prozessmenge P, die alle Prozesse enthält,
2. suche Prozess p aus P, dessen zusätzliche Anforderungen im aktuellenZustand erfüllbar sind, (Problem ist: woher kennt man den zusätzlichenRessourcenbedarf)
3. falls gefunden, simuliere, dass p seine belegten Ressourcen wieder freigibt,
4. entferne p aus P und gehe zu 2
5. falls kein Prozess mehr in P, dann terminiert Suche: keine Verklemmung,
6. falls P 6= Ø und in Schritt 2 kein Prozess mehr gefunden wird, dessenAnforderungen erfüllbar sind, dann terminiert die Suche; P enthält die Mengeder verklemmten Prozesse.
• Auflösung einer Verklemmung in der Regel durch Abbruch einzelnerProzesse. Dies erfordert in der Regel einen manuellen Eingriff bei derAuswahl der abzubrechenden Prozesse. Problem: Prozesse müssen erneut
102
Schlichter, TU München 3.6. VERKLEMMUNGEN
ausgeführt werden, bei Nicht-Determinismus ggf. anderes Verhalten der neuenProzessabläufe. Ein temporäres Entziehen der Ressourcen eines der beteiligtenProzesse ist in der Regel sehr schwierig.
3.6.5 Verklemmungs-Verhinderung
Die Verhinderungssverfahren beruhen darauf, dass man durch die Festlegung vonRegeln dafür sorgt, dass mindestens eine der für das Auftreten von Deadlocksnotwendigen Bedingungen nicht erfüllt ist. Aber: solche Regeln lassen sich nichtfür jedes Verklemmungsproblem finden. Deshalb wird meist ein allgemeinererAlgorithmus gesucht: Vermeidungs-Algorithmus.
• Festgelegte lineare ReihenfolgeBedingung "Zyklus tritt auf" in Belegungs-/ Anforderungsgraph darf nichterfüllt werden. Dazu wird eine lineare Ordnung über den Ressourcen definiert:R1 < R2 < ... Rm.
Die Prozesse dürfen dann Ressourcen nur gemäß dieser Ordnung anfordern,
d.h. ein Prozess, der Ressource Ri belegt, darf nur Ressourcen Rj anfordern,für die gilt: Rj > Ri.
Problem: wie Ordnung festlegen? Daumenregel: wichtige Ressourcen, diegut ausgelastet genutzt werden sollten, dürfen nicht zulange einem Prozesszugeordnet werden. Deshalb sollte für eine solche Ressource Rj gelten: Rj >Ri, für unwichtigere Ri. Ein Problem sind jedoch interaktive Prozesse, da dieRessourcen nicht von vorneherein feststehen, sondern sie sich erst im Laufe derInteraktion mit dem Nutzer ergeben.
• Andere Möglichkeiten sind:
a) Zuteilung aller benötigten Ressourcen zu einem Zeitpunkt.
b) zwangsweiser Entzug aller belegter Ressourcen, falls eine Ressourcen-Anforderung nicht erfüllt werden kann. Gerade durch die Virtualisierungund die Bereitstellung logischer Geräte konnte dieser Ansatz verfolgtwerden. Durch die eingeführte Indirektionsstufe ist es möglich, einemProzess ohne dessen Wissen physische Ressourcen in kritischen Situationenzu entziehen und damit eine der 4 notwendigen Bedingungen für dasEntstehen einer Verklemmung außer Kraft zu setzen.
103
Schlichter, TU München 3.6. VERKLEMMUNGEN
c) Spooling: nur der Spooler Prozess hat als einziger die Ressourcezugeteilt; Zugriffe anderer Prozesse gehen über diesen Prozess. Beispiel istdas Spooling von Druckaufträgen. Die Ressource ist exklusiv dem SpoolerProzess zugeordnet., d.h. die Ressource wird nicht mehr gemeinsambenutzt. Der Spooler Prozess verwaltet eine Auftragswarteschlange fürAufträge von Prozessen.
3.6.6 Verklemmungs-Vermeidung
Die Vermeidungsverfahren basieren auf der Idee,
die zukünftigen Betriebsmittelanforderungen von Prozessen zu analysieren(bzw. diese geeignet abzuschätzen) und
solche Zustände zu verbieten (sie also zu verhindern), die zu Verklemmungenführen könnten.
Die Verklemmungs-Vermeidung unterscheidet sich von der Verklemmungs-Verhinderung dadurch, dass sie erst während des Betriebs und nicht schon beider Softwareentwicklung greift.Ein Beispiel ist der Bankiers-Algorithmus, der 1965 von Dijkstra entwickeltwurde.
Veranschaulichung des Algorithmus
Veranschaulichung des Verfahrens anhand eines Bankenszenarios.
• AusgangspunktIdee: Verwaltung von nur einer Ressourcen-Klasse, nämlich den Bankkrediten.
– Bankier besitzt festen Geldbetrag und verleiht Geld an seine Kunden.
– Alle Kunden sind dem Bankier bekannt, jeder Kunde hat einen eigenenmaximalen Kreditrahmen, der kleiner als die zur Verfügung stehendeGeldmenge des Bankiers ist.
– Bankier hat weniger Geld als die Summe dieser Kreditrahmen.
– Kunden können jederzeit Geld in der Höhe ihres jeweiligen Kreditrahmensfordern, müssen aber ggf. in Kauf nehmen, dass der Bankier diese Forderungerst nach endlicher Zeit erfüllt.
• Aufgabe des Bankiers
104
Schlichter, TU München 3.6. VERKLEMMUNGEN
Verleihen des Geldes so, dass jeder Kunde seine Geschäfte in endlicherZeit durchführen kann und Kunden möglichst parallel bedient werden. Diesequentielle Abfolge ist natürlich eine triviale Lösung.
Idee: Reihenfolge für Kreditvergabe finden, so dass selbst bei denkbar un-günstigsten Kreditforderungen die Durchführung aller Geschäfte sicherge-stellt ist.
ungünstigster Fall: alle Kunden fordern Geld bis zu ihrem jeweiligen max.Kreditrahmen, ohne Kredite zurückzuzahlen.
• Grobes Vorgehen1. falls ein Kunde (Prozess) eine Anforderung hat, die aktuell erfüllbar ist,so teilt man das Geld (die Ressource) probeweise zu und2. untersucht für den sich damit ergebenden Zustand, ob jetzt eineVerklemmung vorliegt, indem3. für alle anderen Kunden von deren ungünstigsten Anforderungenausgegangen wird und4. ein Erkennungs-Algorithmus ausgeführt wird.
Falls keine Verklemmung auftritt, kann die Zuteilung tatsächlich erfolgen,anderenfalls könnte bei einer Zuteilung ein Deadlock auftreten (muss abernicht), weshalb die Anforderung nicht erfüllt wird.
• BeispielAusgangspunkt ist die folgende Situation der vier Kunden A, B, C, D (Einheitenjeweils in Tausend Euro):
Kunde aktueller Kredit max. KreditrahmenA 1 6B 1 5C 1 4D 4 7
Es seien noch 3 Einheiten (Tausend Euro) in der Bank als Kredit verfügbar.
– Annahme: Kunde C fordere eine weitere Einheit als Kredit an. DieseAnforderung wird probeweise zugeteilt und mündet nicht in einem Deadlock,da zuerst C (max noch 2 Einheiten bis Kreditrahmen) bedient werden kann.
Wenn C seine Einheiten wieder zurückgezahlt hat, können B oder D undschließlich A bedient werden.
Probleme bei Vermeidungsverfahren: zukünftige maximale Anforderungenmüssen bekannt sein; anderenfalls nur worst-case Abschätzungen möglich.
105
Schlichter, TU München 3.6. VERKLEMMUNGEN
Algorithmus ist sehr zeit- und speicherplatzaufwendig. Der Habermann-Algorithmus ist eine Erweiterung des Verfahrens auf verschiedene Ressour-cen.
3.6.7 Vergleich der Ansätze
Ansatz Verfahren Vorteile NachteileErkennung periodischer
Aufruf desErkennungsAlgorithmus
Prozesserzeugungwird nicht verzö-gert; erleichtertinteraktive Reak-tion
Verlust durch Ab-bruch
Verhinderung feste Reihefolgebei der Zuteilung
keine Verklem-mungsanalysezur Laufzeitnotwendig; Über-prüfung währendÜbersetzung
keine inkremen-tellen Anfragenfür Ressourcenmöglich
Zuteilung allerRessourcen aufeinmal
keine Präemp-tion (Entzug)von Ressourcennotwendig; gutfür Prozesse miteinzelner Aktivi-tätsphase (singleburst)
ineffizient;verzögert Pro-zesserzeugung;Bedarf für Res-sourcen mussbekannt sein
Vermeidung Bankiers-Algorithmus
keine Präemp-tion (Entzug)von Ressourcennotwendig
zukünftigerBedarf mussbekannt sein;Prozesse könnenlängere Zeitblockiert werden
106
Kapitel 4
Prozess- und Prozessorverwaltung
Ein Prozess ist der Ablauf eines Programms in einem Rechensystem. DieserAblauf ist eine Verwaltungseinheit im jeweiligen Betriebssystem. Der Prozessist ein Grundbaustein einer Parallelverarbeitung unter einem Betriebssystem, d.h.sie laufen im Prinzip parallel ab. Falls nur eine CPU vorhanden ist, erfolgt dieBearbeitung quasiparallel, d.h. in einem zeitlichen Wechsel.
4.1 Fragestellungen
Dieser Abschnitt gibt eine kurze Einführung in eine der wichtigen Verwaltungs-aufgaben eines Betriebssystems:
• Verwaltung von Prozessen.
• Verwaltung des Prozessors, d.h. Zuteilung der CPU an rechenbereite Prozesse(Scheduling). Festlegung, welche Anwendung darf wann rechnen?
• Unterbrechungskonzept. Bei Eintreten von bestimmten Ereignissen kann dieAusführung von Benutzerprogrammen unterbrochen werden, z.B. Warten aufEingabe. Dies ermöglicht den Mehrprogrammbetrieb, und damit eine bessereAusnutzung und Auslastung aller Geräte eines Rechensystems.
4.2 Prozessverwaltung
Dieser Abschnitt behandelt das Prozesskonzept, Datenstrukturen zur Beschrei-bung des aktuellen Prozesszustandes sowie Dienste zum Aufruf von Systemfunk-tionen.
107
Schlichter, TU München 4.2. PROZESSVERWALTUNG
Prozesse repräsentieren eine Aktivität; sie haben ein Programm, Eingaben,Ausgaben und einen Zustand.
4.2.1 Prozesskonzept
Wir unterscheiden Benutzerprozesse, die Anwendungsprogrammen in Ausfüh-rung entsprechen, und Systemprozesse, die Programme/Dienste des Betriebssy-stems durchführen.
a) Jeder Prozess besitzt einen eigenen Prozessadressraum.b) Spezielle Systemprozesse sind die Dämonen (engl. daemon); das sind
Hilfsprozesse, die ständig existieren, die meiste Zeit aber passiv sind. Sieerfüllen i. d. R. Service-Funktionen und werden dazu durch das Eintretenvon Ereignissen aufgeweckt (z.B. Datei zum Drucken eingetroffen) oderwerden von Zeit zu Zeit aktiv, um selber zu prüfen, ob Dienste zuerbringen sind.
Dienste der Prozessverwaltung
Die Prozesse werden durch das Betriebssystem verwaltet.
• Auslösende Ereignisse für die Erzeugung eines Prozesses
Initialisierung des Systems. Beim Booten des Betriebssystems werden eineReihe von Prozessen gestartet, z.B. Prozesse, die als Dämon im Hintergrundlaufen (Print-Spooler, HTTP-Serverprozess).
Systemaufruf zum Erzeugen eines Prozesses durch einen anderen Prozess.
Benutzeranforderung zum Starten eines neuen Prozesses (Start einerApplikation).
Auslösung eines Stapelauftrags (Batch Job).
• Formen der Terminierung von Prozessen
Normale Beendigung (freiwillig).
Vorzeitige Beendigung bei einem durch den Prozess selbst erkannten Fehler(freiwillig).
Vorzeitige Beendigung bei einem katastrophalen Fehler, erkannt durch dasBS (unfreiwillig). Ein Beispiel ist ein Zugriff auf einen Nullpointer, dernicht durch ein Exception-Handling abgefangen wird.
Terminierung durch einen anderen Prozess (unfreiwillig). Ein Beispiel istdie Beendigung über den Task Manager oder die Ausführung der kill-Funktion.
108
Schlichter, TU München 4.2. PROZESSVERWALTUNG
• Prozess-Auswahl, Strategien zur Prozessorzuteilung: Scheduling. Der Schedu-ler ist für Multitasking-Betriebssysteme von Bedeutung. Er wählt den nächstenauszuführenden Prozess aus der Menge der rechenbereiten Prozesse aus. Dabeiwerden in den Betriebssystemen unterschiedliche Verfahren angewandt, z.B.Auswahl nach Prioritäten oder Zeitscheibenverfahren (Round Robin).
• Prozessor-Anbindung; Dispatching. Die Durchführung des Übergangs einesProzesses in den Zustand rechnend erfolgt durch den Dispatcher. Beispielswei-se teilt er den vom Scheduler ausgewählten Prozess der CPU zu. Der Prozessgeht vom Zustand rechenbereit in den Zustand rechnend über; der Prozess wirdausgeführt. Dabei muss sichergestellt, dass der entsprechende Kontext des Pro-zesses (z.B. seine Register) geladen werden.
Prozesskontrollblock
Jeder Prozess muss als eine Verwaltungseinheit beschrieben sein. Ein Prozesswird durch seinen Prozess-Kontext und dieser durch den Prozesskontrollblock(PCB) beschrieben. Ein PCB wird meist programmiersprachlich als Verbund(struct) spezifiziert. Ein PCB (process control block) enthält i.d.R. folgendeInformationen:
• eindeutiger Name, z.B. fortlaufende Nummerierung des Prozesses (z.B. pid inUnix)
• Name des Benutzers, dem der Prozess zugeordnet ist
• der momentane Prozesszustand (wartend, rechnend, rechenwillig, ...)
• falls der Prozess rechnend ist, Angabe der zugeordneten CPU
• falls der Prozess wartend ist, eine Spezifikation des Ereignisses, auf das derProzess wartet (z.B. Adresse eines Semaphors).
• die Ablaufpriorität des Prozesses
• die Inhalte der programmierbaren Register (die Anzahl ist abhängig von derjeweiligen CPU-Architektur), z.B. Kellerpointer.
• die Inhalte der Register, in denen die Anfangsadresse und Länge der pro-zessspezifischen Speicherabbildungstabellen enthalten sind (virtuelle Adressie-rung).
109
Schlichter, TU München 4.2. PROZESSVERWALTUNG
• das Programmstatuswort (PSW).Beispiele für dem Inhalt des PWS’s sind derAblaufmodus (Benutzer- oder Systemmodus), die momentane Ablaufpriorität,die Adressierungsart im Benutzermodus (virtuelle oder direkte Adressierung)und die Ergebnisse der letzten Vergleichsoperation auf Maschinenebene(sogenannte Condition-Code Register, z.B. das N-Register (Ergebnis der letztenOperation negativ).
• PCB unter Linux ist durch die Struktur task_struct spezifiert; definiert unterinclude/linux/sched.h
1 . Dies ist eine umfangreiche Struktur, die Information zum Scheduling (z.B.Zustand und Priorität), Prozess-ID, Vaterprozess, Kinder enthält. Daneben wer-den Informationen Benutzer-/Gruppeninformationen und Ressourceninforma-tionen (Locks, threads, etc) gespeichert.
Daneben kann ein PCB noch weitere Statistiken über die Historie des Prozessesspeichern, die beim Scheduling ausgewertet werden.
Prozesslisten
Die Prozesse werden in Zustandslisten verwaltet, die als verkettete Liste der PCBsrealisiert sind.
für E/A-Geräte (z.B. Platte, Terminal) existiert i.d.R. jeweils eine eigeneWarteschlange, die die PCBs der wartenden Prozesse enthält.
Falls mehrere CPUs vorhanden sind, verweist "rechnend" auf mehrere Elemente.
Rechnend
Rechenwillig
Wartend
Prozessidentifikation
Registerzustand
Scheduling Information (z.B.
Priorität)
Adressrauminformation
Sonstiges
nächster PCB
Ready-Queue
Prozesskontrollblock PCB
Da der PCB eine Datenstruktur des Betriebssystems ist, kann die Ablage nicht imBenutzeradressraum erfolgen. Da weiterhin die Prozesse nicht kellerartig aktiviert
1Achilles S 21
110
Schlichter, TU München 4.2. PROZESSVERWALTUNG
und deaktiviert werden, sondern in beliebiger Folge, kann er auch nicht im Kellerdes Betriebssystems abgelegt werden, sondern es wird dafür die Halde verwendet.
Zustandsmodell
Das Prozess-Zustandsmodell unterscheidet neben den bereits vorgestelltenZuständen rechenwillig, rechnend, wartend auch den Zustand ausgelagert.Letzterer Zustand tritt ein, wenn der Adressraum aufgrund Speichermangels ausdem Arbeitsspeicher auf den Hintergrundspeicher verlagert wird ("swapping").Beispielsweise verwaltet Windows auf der Festplatte eine Swap-Datei, in dieProzesse ausgelagert werden.
rechnend
wartend
rechenwillig
ausgelagert
ready
assign
block
add retire
resign
swap outswap in
Zustandsübergänge sind:
add: ein neu erzeugter Prozess wird zu der Menge der rechenwilligen Prozessehinzugefügt;
assign: als Folge eines Kontextwechsels wird dem Prozess die CPU zugeordnet;
block: aufgrund eines EA-Aufrufs oder einer Synchronisationsoperation wird derProzess wartend gesetzt;
ready: nach Beendigung der angestoßenen Operation wechselt der Prozess in denZustand rechenwillig; er bewirbt sich erneut um die CPU;
resign: dem rechnenden Prozess wird die CPU entzogen; er bewirbt sichanschließend erneut um die CPU;
retire: der aktuell rechnende Prozess terminiert;
swap out: der Prozess wird auf die Festplatte ausgelagert;
111
Schlichter, TU München 4.2. PROZESSVERWALTUNG
swap in: der Prozess wird von der Festplatte in den Arbeitsspeicher geladen.
Prozesserzeugung
Ein Prozess kann andere Prozesse erschaffen. Diese sind die Kindprozesse (childprocess) und der Erschaffer ist der Vater (parent process). Vater
kann auf Beendigung von Kind warten, oderparallel weiterlaufen.
• Prozesserzeugung: 2 Vorgehensweisen
Windows NT: Vaterprozess veranlasst eine Reihe von Systemaufrufen, diedas Kind entstehen lassen.
Unix: Vater klont sich mit Systemaufruf fork(); Kind ändert selbst seinAufgabe.
• Unix ProzesserzeugungAufruf von fork() führt zu einem fast exakten Duplikat des Vaterprozesses.Unterschiede sind
unterschiedlicher process identifier (PID)
der Ergebniswert von fork()Vater: PID des KindprozessesKind: 0
Mit Hilfe der PID kann der Vaterprozess den Kindprozess adressieren, z.B. umihn zu beenden.
– Beispielprogramm#include <stdio.h>int main(int argc, char *argv[]) {
char *myname = argv[1];int cpid = fork();if cpid == 0 {
printf("The child of %s is %d\n", myname, getpid());.......return (0);
} else {printf("My child is %d\n", cpid);/* wird vom Vaterprozess durchlaufen */.....return(0);
}}
112
Schlichter, TU München 4.2. PROZESSVERWALTUNG
– Kind hat vieles mit dem Vater gemeinsam:liest dieselben Dateien, gleicher Benutzername, benutzt dieselben Daten
– Unix Kind fängt mit dem Code des Vaters an und ändert sich dannSystemaufruf exec(): ersetzt das Programmbild des Vaters mit einemanderen.
Nach exec() beginnt die Ausführung am Anfang bei main(). NT hingegenbeginnt immer am AnfangBeispielprogramm für exec#include <stdio.h>int main(int argc, char *argv[]) {
char *myname = argv[1];int cpid = fork();if cpid == 0 {
int rc;rc = execl("/bin/ls", "ls", "-l", (char *) 0);printf("Fehler bei execl Aufruf: %d\n", rc);exit(1);
} else {/* wird vom Vaterprozess durchlaufen */
}}Die Familie der exec-Systemaufrufe laden ein neues Programm in denAdressraum und führen dies aus. Damit is auch der vorherige Programmcodeverschwunden. Dies bedeutet, dass nach einer erfolgreichen Ausführungvon execl die nachfolgenden Anweisungen printf und exit nicht mehrvorhanden sind. Sie werden nur ausgeführt, falls execl fehlschlägt. Bei execlwerden die Parameter als Strings übergeben mit
das auszuführende Programmder Name des Programmsdie an das Programm zu übergebende Parameter(char *) 0) markiert das Ende.
exit(1) meldet einen Fehler; exit(0) bedeutet Rückkehr ohne Fehler.
– PrinzipablaufMit der Systemfunktion wait wartet der Vaterprozess auf den Kindprozess.
wait vor Beendigung des Kindes: Vater ist blockiert.wait nach Beendigung des Kindes: Kind wird nach Beendigung zumZombieprozess.
Nach Beendigung des Kindes erhält der Vaterprozess Information über denBeendigungsstatus (normal, Abbruch) und den Rückgabewert der Funktionexit des Kindes (nur bei normaler Beendigung, ansonsten undefiniert).
113
Schlichter, TU München 4.2. PROZESSVERWALTUNG
Falls der Kindprozess vor dem wait des Vaters beendet wird, entsteht ein"Zombieprozess".
Ein Zombieprozess führt keinen Code mehr aus. Er belegt nur nochTabelleneinträge im BS, da der Rückgabewert und der Beendigungsstatusfür den Elternprozess bereitgehalten werden müssen.
Vater
forkVater
Kind
wait
exit
Vater
Vater
forkVater
Kind
wait
exit
Vater
Zombieprozess
Der Aufruf von wait des Vaterprozesses ist norwendig, da sonst dauerhafteZombieprozesse entstehen können. Terminiert der Vaterprozess vor demKindprozess, verwaist er und wird als Kind dem init-Systemprozesszugeordnet; dieser führt zu gegebener Zeit ein wait für alle Kinderprozesseaus.
• Linux unterstützt den Systemaufruf clone() zur Erzeugung neuer Thread-Kopien. Im Aufruf werden eine Menge von Flags spezifiziert, z.B.
CLONE_FS: Dateisysteminformation gemeinsam mit Aufrufer, z.B. aktu-elles Arbeitsverzeichnis.
CLONE_VM: gemeinsamer Arbeitsspeicher.
CLONE_FILES: die offenen Dateien sind gemeinsam.
Prozesse und Vererbung
Bei der Verwaltung von Vater-/Kindprozess sind eine Reihe von Entscheidungenzu treffen:
• Ausführung
Vaterprozess und Kind werden gleichzeitig ausgeführt, oder
der Vaterprozess wartet darauf, dass das Kind beendet wird
114
Schlichter, TU München 4.2. PROZESSVERWALTUNG
• Ressourcen
Vater und Kind teilen sich alle Ressourcen.
Vater und Kind teilen sich einen Teil der Ressourcen.
Vater und Kind haben keine Ressourcen gemeinsam.
• Adressraum
Das Kind ist ein Duplikat des Vaters.
Das Kind führt durch automatisches Laden ein neues Programm aus (exec-Systemaufruf).
• Threads
Das Kind dupliziert alle Threads des Vaters.
Das Kind dupliziert nur den Thread des Vaters, der die fork-Operationausgelöst hat. Falls nach der fork-Operation der exec-Systemaufrufausgeführt wird, wird sowieso der komplette Prozess ersetzt.
4.2.2 Dispatcher
Aufgabe des Dispatchers: Realisieren der Zustandsübergänge zwischen rechnendund rechenwillig: Prozessor binden und entbinden. Dazu ist ein Kontextwechselerforderlich. Dabei ist zu berücksichtigen, dass die Prozesslisten entsprechendaktualisiert werden, d.h. der PCB des ausgewählten Prozess muss aus derrechenwillig-Liste entfernt werden und in die rechnend-Liste eingetragen werden.
Kontextwechsel
CPU wird entzogen und einer anderen Aktivität zugeteilt; ein Kontextwechsel isterforderlich, falls der rechnende Prozess P1 in den Zustand wartend oder z.B.durch Prozessorentzug in den Zustand rechenwillig übergeführt wird.
• Problemaktueller Ausführungskontext des Prozesses muss gesichert werden undKontext des nächsten rechenbereiten Prozesses muss geladen werden. Falls fürden Zugriff auf eine Datei X nur ein Dateizeiger zur Verfügung steht, dannmuss die Position des Dateizeigers gerettet werden. Wenn Prozess P1 wiederrechnend wird, dann soll er an der Position weiterlesen, an der er unterbrochenwurde; falls zwischenzeitlich ein anderer Prozess P2 ebenfalls die Datei gelesen
115
Schlichter, TU München 4.2. PROZESSVERWALTUNG
und den Dateizeiger verändert hat, darf dies bei der Fortsetzung von P1 keineAuswirkung haben. In Unix erhält jeder Prozess einen eigenen Dateizeiger.
Achtung: je umfangreicher ein PCB ist, desto "teurer" sind Prozesswechsel,d.h. das Umschalten der CPU zwischen den Prozessen.
Threads
Threads haben einen sehr viel kleineren Kontext ⇒ Umschalten zwischenThreads innerhalb eines Prozesses sehr schnell, da Adressraum und andereRessourcen (z.B. Dateien) gemeinsam genutzt werden. Auch TLB-Einträge(→ Translation lookaside Buffer (siehe Seite 165)) der Seitenadressierungmüssen nicht invalidiert werden. Damit ergeben sich auch keine Folgekostendurch Laden von Seiten bei cache-Misses. Dagegen ist das Umschalten vonThreads, die unterschiedlichen Prozessen angehören, ebenso aufwendig wie einProzesswechsel.
Beispiel: Kontext-Wechsel in Unix
Kontextwechsel z.B. durch den Aufruf der Systemoperation sleep durch einenProzess. Beim Aufruf der Operation sleep ist ein Warteraum, in den derProzess eingefügt werden soll, anzugeben (z.B. E/A-Warteraum, oder wartenauf Terminieren eines Kind-Prozesses). Bei der Ausführung von sleep werdenvergröbert folgende Schritte durchgeführt.
1. Maskieren von Interrupts; Ausblenden von Unterbrechungen, da derKontextwechsel nicht gestört werden soll.2. Lokalisieren der benötigten Warteschlange;3. Neuberechnung der Priorität des Prozesses;4. Einfügen des Prozesses in die Warteschlange;5. Aufruf der Operation zum Kontextwechsel.
Bei der Ausführung der Operation zum Kontextwechsel wird vom Scheduler dernächste Prozess ausgesucht, dem der Prozessor zugeteilt werden soll, und mitdieser Information wird die Operation resume aufgerufen.
Zunächst wird der Zustand des noch aktuellen Prozesses aus den Registern inden Prozesskontrollblock des Prozesses gespeichert.
Dann wird die Adresse des Prozesskontrollblocks des neu zu bindendenProzesses sowie der Zustand des neuen Prozesskontrollblocks in die Registergeladen und der Kontextwechsel ist durchgeführt.
116
Schlichter, TU München 4.2. PROZESSVERWALTUNG
Durch das Maskieren von Interrupts kann das Warten auf die relevantenEreignisse eingestellt werden, d.h. die anderen Interrupts werden ausgeblendet;der Kontextwechsel soll nicht gestört werden.
4.2.3 Arbeitsmodi
Ziel für den Betrieb von Rechensystemen: kontrollierter Zugriff auf Hardware-komponenten nur durch BS. Dadurch soll verhindert werden, dass Benutzer oderSoftwaresysteme Hardwarekomponenten unsachgemäß nutzen, und implizit an-dere nebenläufige Aktivitäten schädigen.
Lösung: alle Zugriffe auf Hardware nur über privilegierte Befehle zulässig;Frage: wer darf privilegierte Befehle ausführen⇒Antwort: Prozesse in einemprivilegierten Modus.
Herkömmlich unterscheidet man zwischen dem Benutzer- (engl. user mode) unddem Systemmodus (engl. kernel mode).
• BenutzermodusEs sind nur die nicht privilegierten Befehle verfügbar. Damit ist der Zugriff aufProzessadressraum und unkritische Register, wie Befehlszähler, Indexregistermöglich. Benutzerprozesse werden im Benutzermodus ausgeführt. KritischeRegister, über die der Kontext eines Prozesses beeinflusst werden kann(z.B. Ablaufpriorität, Arbeitsmodus) können nur im Systemmodus verändertwerden. Wird versucht, einen privilegierten Befehl auszuführen, gibt es einenBefehlsalarm.
• SystemmodusEs sind auch die privilegierten Befehle verfügbar (z.B. Anhalten der Maschine,Verändern der Ablaufpriorität). Die Dienste des Betriebssystemkerns werdenim Systemmodus ausgeführt.
• Nutzung der Hardware-Komponenten nur über Dienste des BS: Aufruf einesBS-Dienstes über spezielle Befehle: den Systemaufruf. Dies führt zu einer →Unterbrechung (siehe Seite 134) und damit zu einem kontrollierten Eingang indas BS (z.B. Zugriffsrechte des aufrufenden Prozesses prüfen).
4.2.4 Systemaufrufe
Ein Systemaufruf ist eine Funktion, die von einem Benutzerprozess aufgerufenwird, um einen BS-Kerndienst aufzuführen.
117
Schlichter, TU München 4.2. PROZESSVERWALTUNG
1. Der Systemaufruf überprüft die übergebenen Parameter und bildet darauseine Datenstruktur, um die Daten an den BS-Kern weiterzureichen.
2. Danach wird eine spezielle Instruktion, ein Software Interrupt (Trap), aus-geführt. Diese Instruktion identifiziert über einen Operanden den gewünsch-ten Systemdienst.
3. Bei Ausführung der Trap-Instruktion wird der Zustand des Benutzerprozes-ses gerettet und es findet ein Wechsel in den Systemmodus statt.
In manchen Programmiersprachen sind Systemaufrufe (C, C++) über denAufruf von Prozeduren der Laufzeitumgebung, die ihrerseits die Systemaufrufedurchführen, möglich. In Java ist kein direkter Systemaufruf möglich, sonderndies erfolgt i.a. über Methoden, die in anderen Sprachen geschrieben sind, meistC, C++.
• BeispielLesen von Daten aus einer Datei und Kopieren in eine andere Datei. Dabeitreten die folgenden Systemaufrufe auf:
(1) Schreiben des Prompts auf Bildschirm: Angabe der Dateinamen(2) Lesen der Tastatureingabe (bzw. Analoges bei Mouse-Eingabe)(3) Öffnen der zu lesenden Datei (open)(4) Erzeugen der neuen Datei(5) ggf. Fehlerbehandlung: Nachricht auf Bildschirm(6) Schleife: Lesen von Eingabedatei (ein Systemaufruf) und schreiben in
zweite Datei (auch Systemaufruf)(7) Schließen beider Dateien(8) Ausgabe auf Bildschirm
Jeder Schritt ist jeweils ein Systemaufruf. Durch die Verwendung vonLaufzeitroutinen ergibt sich eine höhere Abstraktionsebene ⇒ Aufruf einerRoutine, die die notwendigen Systemaufrufe durchführt.
4.2.5 Realisierung von Threads
Es existieren zwei grundlegende Ansätze, Threads in einem Rechensystemzu realisieren: im Benutzer-Adressraum (Benutzermodus) oder im System-Adressraum (Systemmodus).
• im Benutzer-AdressraumDer BS-Kern verwaltet nur single-threaded Prozesse. Damit ist es auch möglichein Thread-Package für ein Betriebssystem zu realisieren, das auf BS-Ebenekeine Threads unterstützt.
118
Schlichter, TU München 4.2. PROZESSVERWALTUNG
Prozess Thread
Laufzeit-
system
Benutzer
Adressraum
(Benutzermodus)
BS-KernSystem
Adressraum
(Systemmodus)
Prozess-
tabelleThread
tabelle
– Threads werden durch Laufzeitsystem im Benutzeradressraum verwaltet.Eine Thread-Tabelle speichert Informationen (Register, Zustand, etc.) überThreads pro Prozess.
– Prozessorzuteilung im BS-Kern erfolgt an Prozesse. Laufzeitsystem be-stimmt, welcher Thread rechnend gesetzt wird. Jedes Laufzeitsystem hat sei-nen eigenen Thread-Scheduler. Damit ist es möglich, dass jeder Prozess sei-ne eigene Variante des Scheduling-Algorithmus nutzt, d.h. die Auswahl desnächsten auszuführenden Threads. Beispielsweise kann durch eine geeigneteStrategie verhindert werden, dass der Garbage Collector zu einem ungünsti-gen Zeitpunkt unterbrochen wird.
– Problem: Systemaufruf eines Threads blockiert die anderen Threadsdes Prozesses. Dadurch wird gerade dies verhindert, was mit Threadsin Applikationen erreicht werden soll, d.h. die Ausführung parallelerAktivitätssequenzen, wobei trotz Blockierung einiger Threads andereThreads desselben Prozesses weiterlaufen können.
– Problem: wie wird einem Thread die CPU entzogen? Threads müssen dieCPU durch Ausführung des Befehls thread_yield freiwillig aufgeben. DasLaufzeitsystem wählt dann einen anderen rechenwilligen Thread aus. Fallsein Thread die CPU nicht aufgibt, kann ihm vom Laufzeitsystem nicht (wieim BS-Kern) die CPU entzogen werden. Innerhalb eines Prozesses existierenkeine Clock-Interrupts.
• im System-AdressraumNeben den Prozessen werden im BS-Kern auch alle Threads verwaltet. Damitkönnen auch alle Funktionen zur Verwaltung von Prozessen, z.B. CPU-
119
Schlichter, TU München 4.2. PROZESSVERWALTUNG
Zuteilung, für Threads verwendet werden. Dies bedeutet jedoch auch, dass beiErzeugung bzw. Terminierung von Threads jeweils Systemaufrufe durchgeführtwerden müssen. Systemaufrufe sind jedoch i.a. aufwendig.
Prozess Thread
Benutzer
Adressraum
(Benutzermodus)
BS-KernSystem
Adressraum
(Systemmodus)
Prozess-
tabelle
Thread
tabelle
– Thread-Tabelle speichert Informationen (Register, Zustand, etc.) überThreads.
– Prozessorzuteilung im BS-Kern erfolgt an Threads. Falls ein Threadblockiert, kann die Prozessorzuteilung entscheiden, ob ein anderer Threadaus demselben Prozess die CPU zugeteilt bekommt, oder ein Thread einesanderen Prozesses.
– Der Systemaufruf eines Threads blockiert nicht die anderen Threads desProzesses.
• Es wurden auch hybride Ansätze verfolgt, die eine Kombination beiderMöglichkeiten realisieren. Der BS-Kern verwaltet sogenannte Kernel-Threads.Das Betriebssystem kennt nur Kernel-Threads und teilt diese der CPU zurAusführung zu. Threads des Benutzer-Adressraums (User-Threads) werdenjeweils auf Kernel-Threads abgebildet, dabei können gleichzeitig mehrereUser-Threads eines Prozesses verfügbaren Kernel-Threads zugeordnet werden.Auf einen einzelnen Kernel-Thread können gleichzeitig auch mehrere User-Threads abgebildet werden (Multiplexing).
120
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
BS-Kern
Kernel
Thread
Prozess User-Thread
4.3 Prozessorverwaltung
Eine wesentliche Aufgabe der Prozessorverwaltung besteht darin zu entscheiden,welcher der um den bzw. die Prozessor(en) konkurrierenden Prozesse (bzw.Threads) zu einem Zeitpunkt an den bzw. die Prozessor(en) gebunden wird.Dazu steht die BS-Komponente Scheduler zur Verfügung. Die Durchführung der→ Zustandsübergangs (siehe Seite 111) eines Prozesses von rechenwillig nachrechnend ist Aufgabe des Dispatchers, während der Scheduler aus der Listeder möglichen Prozesse einen geeigneten auswählt. Der Scheduler wählt denProzess aus, der durch einen assign-Zustandsübergang nach rechnend übergeht.In folgenden Situationen 2
muss ein Scheduler auf jeden Fall aktiviert werden:
ein neuer Prozess wird erzeugt;
ein Prozess terminiert;
ein Prozess blockiert aufgrund eines EA-Auftrags;
eine EA-Unterbrechung tritt auf.
Daneben kann das Betriebssystem einem Prozess die CPU entziehen, falls erbereits zulange rechnend ist (Ablauf der Zeitscheibe).
• Prozessablauf besteht aus einer Sequenz von alternierenden CPU- und E/A-Perioden. Während der E/A-Perioden wartet der Prozess auf die Beendigung2[Tanenbaum2001, S134]
121
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
der Ein-/Ausgabe. Dies Wartezeit kann von anderen rechenwilligen Prozessengenutzt werden. Ein E/A-orientierter Prozess hat viele kurze CPU-Perioden;ein CPU-orientierter Prozess hat wenige lange CPU-Perioden.
• Zeitliche Verschränkung der Prozessbearbeitung bei einer CPU.
Zeit
Prozess A
BS-Kern
Prozess B
A hat CPU
Unterbrechung
BS-Kern
hat CPU
Zuweisung
CPU an B
Unterbrechung
A hat CPU
B hat CPU
BS-Kern
hat CPU
Zuweisung
CPU an A
Unterscheidung zwischen Prozess-Scheduling und Thread-Scheduling. Imersten Fall findet die Prozessorzuteilung nur zu ganzen Prozessen statt.Multithreading findet im Benutzermodus statt. Im 2. Fall sind unterschiedlicheVarianten des Multithreading möglich: auf Benutzerebene oder als Kernel-Threads. Für beide Arten können dieselben Strategien verwendet werden.
4.3.1 Kriterien
Der Scheduler wählt aus der Menge der rechenwilligen Prozesse den nächstenauszuführenden Prozess aus. Es existieren unterschiedliche Verfahren die von derjeweiligen Prozessorverwaltungsstrategie abhängen. Mögliche Leistungskriterienfür ein Schedulingverfahren:
• Fairness. Jeder Prozess soll einen fairen Anteil der CPU zum Rechnen erhalten.
• Effizienz, Prozessorauslastung. Dies ist ein Maß für die Auslastung einesProzessors. Ziel sollte es sein, dass möglichst alle Teile der Rechenanlageeffizient genutzt werden, z.B. CPU und EA-Geräte sollten möglichst gutausgelastet sein.
122
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
• Antwortzeit für interaktive Benutzer (Dialogverarbeitung). Für interaktive An-wendungen muss die Zeitspanne zwischen Ankunft, z.B. einer Benutzereingabeund einer potentiellen Reaktion möglichst kurz sein.
• Wartezeit, insbesondere für Batch-Jobs (Stapelverarbeitung). Darunter ist dieVerweilzeit in der Bereit-Liste zu verstehen, d.h. die Zeitdauer in der einemrechenwilligen Prozess kein physischer Prozessor zugeordnet ist.
• Ausführungszeit, d.h. Zeitspanne von Auftragsbeginn bis Auftragsende. DieAusführungszeit enthält alle Zeiten in Warteschlangen, der Ausführung und derEin-/Ausgabe. Sie sollte minimal sein.
• Abschlusszeit, insbesondere für Realzeitsysteme. Hier geht es darum, ob dieRealzeitgarantien eingehalten werden. Wird der Prozess rechtzeitig fertig undliefert seine Ergebnisse aus (z.B. das Videobild)?
• Durchsatz, Anzahl der Aufträge pro Zeiteinheit. Die Zahl der Aufträge proZeiteinheit ist ein Maß für die Systemauslastung und sollte maximal sein.
Kriterien der Betriebsarten
Die Ziele der Schedulingverfahren hängen von der Umgebung und denBetriebsarten des Rechensystems ab.
• Alle Systeme
Fairness - jeder Prozess bekommt Rechenzeit der CPU.Balance - alle Teile des Systems sind ausgelastet.
Policy Enforcement - Scheduling Policy wird nach außen sichtbardurchgeführt.
• Stapelbetrieb
Durchsatz - maximiere nach Aufträge pro Zeiteinheit.Ausführungszeit - minimiere die Zeit von Start bis zur Beendigung.
CPU-Belegung - belege CPU konstant mit Aufträgen.
• Dialogbetrieb - interaktive Systeme
Antwortzeit - antworte schnellstmöglich auf Anfragen.
Proportionalität - Erwartungshaltung der Nutzer berücksichtigen. DerBenutzer erwartet, dass der Aufbau einer Internetverbindung länger dauertals deren Abbruch. Ein weiteres Beispiel ist die Dateiauswahlbox imWindows Explorer: die Erstellung der Liste zu den hierarchisch oberenVerzeichnissen sollte schnell erfolgen (ist jedoch nicht immer so).
123
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
• Echtzeitsysteme
Abschlusszeit - kein Verlust von Daten.
Vorhersagbarkeit - Qualitätsverlust bei Multimedia vermeiden. Schwan-kungen können durch Pufferung von Informationen (Frames) ausgeglichenwerden, solange die Schwankungen in einem gewissen Rahmen bleiben.
Mit den Leistungskriterien gibt es Probleme: a) die Optimierungsziele sindteilweise widersprüchlich (z.B. eine Strategie, die den Durchsatz optimiert istnicht notwendigerweise geeignet, um kurze Antwortzeiten zu ermöglichen),und b) das Prozessverhalten (z.B. wann kommt der nächste E/A-Befehl) kannvom Scheduler nicht exakt vorausgesagt werden. Deshalb werden Scheduling-Strategien meist abhängig von der Betriebsart gewählt (Dialogbetrieb vs.Stapelbetrieb).
4.3.2 Scheduling-Strategien
Es werden zwischen zwei Klassen unterschieden: nicht-unterbrechende (nonpre-emptive) und unterbrechende Strategien (preemptive).
nicht unterbrechend: Scheduling nur dann möglich, wenn der rechnendeProzess blockiert wird oder wenn er terminiert, d.h. Prozess behält CPU biser sie selber abgibt.
Beispiel: Microsoft Windows 3.x; unterbrechende Strategien erst abWindows 95
unterbrechend: Unterbrechung beim Eintreten von speziellen Ereignissen,u.a. Eintreffen eines Prozesses mit höherer Priorität oder Prozess geht inWartezustand. Problematisch ist diese Strategie für die Ausführung vonOperationen des BS-Kerns. Lösung bei vielen Betriebssystemen (z.B. Unix):Ausführung von BS-Kernoperationen sind nicht unterbrechbar (Vorsicht: hierin bezug auf Scheduling, Interrupts können auftreten).
Zeitscheibenstrategie
Die Zeitscheibenstrategie (Round Robin) ist unterbrechend. Ziel ist diegleichmäßige Verteilung der Rechenzeit auf rechenwillige Prozesse. Round Robinist eine weit verbreitete preemptive Schedulingvariante. Das Verfahren ordnetjedem rechenwilligen Prozess ein definiertes Zeitquantum (Zeitscheibe) zu. In 4.3BSD Unix beträgt z.B. die Zeitscheibe 100 ms. Nach dem Kontextwechsel ist
124
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
der Prozess entweder bis zum Ablauf des Zeitquantums oder bis zum Auftreteneiner blockierenden Systemfunktion im Besitz der CPU (je nachdem was zuersteintritt). Alle rechenwilligen Prozesse werden in einer FIFO-Warteschlangeverwaltet. Nach Ablauf der Zeitscheibe wird der Prozess am Ende der FIFO-Warteschlange eingereiht.
• Es werden die Prozesse an den Prozessor jeweils für ein festgelegtesZeitquantum q gebunden und spätestens nach dem Ablauf dieser Zeitspannewird den Prozessen der Prozessor wieder entzogen.
• zyklisches Bedienen der Prozesse (Round Robin).
• Ready-Queue (Liste der rechenwilligen Prozesse) als zyklische Warteschlangerealisiert.
• Wahl des Zeitquantums:
falls q zu klein: viele unproduktive Kontextwechsel. Es scheint, als ob jederProzess seinen eigenen Prozessor besitzt; processor sharing.falls q zu groß: Round Robin wird zu einem reinen FCFS Scheduling(First Come First Served), da die Wahrscheinlichkeit für einen Aufrufeines blockierenden Systemdienst steigt. Ein zu großes Zeitquantum istinsbesondere für interaktive Anwendungen nicht empfehlenswert, da sichdie Wartezeit für einen Prozess, und damit die Reaktionszeit erhöht. Beigroßem Qunatum nährt sich das Systemverhalten an FCFS an. EinzelneProzesse würden sehr lange rechnen, währendessen die anderen Prozessealle warten müssen. Insgesamt erhöht sich die mittlere Wartezeit überalle Prozesse. Bei einem gut gewählten Quantum hat jeder Prozess einenfairen Anteil an der CPU und damit einen Rechenfortschritt. Die mittlereWartezeit über alle Prozesse ist niedriger.Typische Werte für q: 10 bis 100 Millisekunden.
• Für q = 100 ms gilt bei 1 MIPS Maschine (Million Instructions/Second): ca.100.000 Instruktionen/q.
Prioritäten
Diese Strategie ist i.a. unterbrechend. Sie basiert darauf, an die Prozesse Prioritä-ten zu vergeben. Die Prioritätenvergabe kann dabei statisch oder dynamisch sein.Die Prioritätenstrategie kann unterbrechend und nicht-unterbrechend sein. Im er-sten Fall wird der Ablauf eines Prozesses unterbrochen, wenn ein anderer Prozessmit höherer Priorität rechenwillig wird. Im zweiten Fall behält der Prozess die
125
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
CPU solange bis er entweder eine blockierende Systemfunktion aufruft oder dieCPU freiwillig abgibt.
• Prioritäten sind i.a. ein festgelegter Zahlenbereich, z.B. 0, ..., 7. Achtung:häufig: niedrige Zahl entspricht hoher Priorität, muss aber nicht so sein.
• Statische Prioritätenvergabejeder Prozess besitzt für die Dauer seiner Existenz eine feste Priorität.
Problem: Gefahr des Verhungerns von Prozessen mit niedriger PrioritätLösung: Erhöhung der Priorität von lange wartenden Prozessen, d.h.dynamische Prioritäten.
• Dynamische Prioritätenvergabedie Prioritäten der Prozesse können sich dynamisch verändern, d.h. sie werdenin gewissen Zeitabständen neu berechnet.
Idee: lange Wartezeiten berücksichtigen (Erhöhen die Priorität).Prozesse mit großem CPU-Verbrauch sinken in Priorität.E/A-intensive Prozesse steigen in Priorität (damit E/A-Geräte und CPUparallel genutzt werden).
• Zeitscheibenstrategien und Prioritätenvergabe können zu effizienten Verwal-tungsstrategien kombiniert werden. Beispielsweise können Prozesse in Priori-tätsklassen gruppiert werden. Innerhalb einer Gruppe wird die Zeitscheibenstra-tegie verwendet. Beispielweise können 4 Prioritätsklassen eingerichtet werden,wobei die Klasse 4 die höchste Priorität hat. Solange Prozesse in der Klasse4 sind, werden diese jeweils im Zeitscheibenverfahren ausgewählt. Falls dieKlasse 4 leer, werden Prozesse der Klasse 3 ausgewählt usw. Prozesse müssendynamisch den Klassen zugeordnet werden, damit nicht Prozesse der unterstenKlasse verhungern.
• Windows XP SchedulingWindows XP nutzt eine Prioritäten-basierte, unterbrechende Strategie. Threadmit höchster Priorität wird ausgeführt, bis
er terminiert, oderer seine Zeitscheibe ausgeschöpft hat, odereine Blockierung (Systemaufruf, E/A) auftritt.
Es werden Prioritäten von 0 - 31 unterschieden, die in verschiedene Klasseneingeteilt werden
126
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
Echtzeit hoch übernormal
normal unternormal
idle
zeit kri-tisch
31 15 15 15 15 15
höchste 26 15 12 10 8 6übernormal
25 14 11 9 7 5
normal 24 13 10 8 6 4unternormal
23 12 9 7 5 3
niedrigst 22 11 8 6 4 2idle 16 1 1 1 1 1
In jeder Prioritätsklasse (Echtzeit, etc) wird by-Default der Wert der Zeile"normal" gesetzt. Außer der Klasse Echtzeit werden alle Prioritäten dynamischangepasst. Falls ein Thread aufgrund eines ausgeschöpften Zeitquantumsunterbrochen wird, wird die Priorität dekrementiert, jedoch nicht unter denDefault-Wert. Die Schedulingstrategie sowie die Prioritätsklassen mit denzugehörigen Prioritäten gelten auch für Windows 7.
First-Come First-Served
Dieses nicht-unterbrechende Verfahren (FCFS) teilt einen Prozessor in derReihenfolge des Auftragseingangs zu. Ready-Queue wird als FIFO-Listeverwaltet; Verfahren einfach zu realisieren.
• Ein Kontextwechsel findet nur statt, wenn der Prozess eine blockierendeSystemfunktion aufruft oder der Prozess die CPU freiwillig abgibt. Im letztenFall wird der Prozess sofort wieder am Ende der Ready-Queue eingereiht. Imersten Fall wird der Prozess nach Ende der Blockierungsursache wieder amEnde der Ready-Queue eingereiht.
• Es kann eine hohe CPU Auslastung erreicht werden.
• Problem: Durchschnittliche Wartezeit ist hoch.
Beispiel: Prozesse P1,P2,P3 kommen nahezu gleichzeitig zum Zeitpunkt 0an;Dauer ihrer Berechnungszeiten: P1: 24 ms, P2: 3ms, P3: 3ms;bei Reihenfolge P1, P2, P3: mittlere Wartezeit: (0 + 24 + 27)/3 = 17 msbei Reihenfolge P2, P3, P1 mittlere Wartezeit (0+3+6)/3 = 3 ms
127
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
Shortest-Jobs-First
Dieses Verfahren (SJF) führt die Prozessorzuteilung in der Reihenfolge derwachsenden Rechenphasen ("CPU-Burst") zu, d.h. Prozess mit kürzester, nächsterRechenphase erhält Prozessor als nächster. Das Verfahren ist nur bedingtrealisierbar, da die Länge des nächsten CPU-Bursts a priori nicht bekannt ist.In der Praxis wird daher eine Approximation eingesetzt, die auf der Basis dergemessenen Länge der zurückliegenden Bursts und einem Schätzwert für dennächsten Burst ermittelt wird.
• anwendbar, falls die Dauer der nächsten Rechenphase bis E/A-Befehl, Interruptetc. bekannt ist.
• Beispiel: P1: 6ms, P2: 8ms, P3: 7ms, P4: 3ms
Schedule bei SFJ : P4, P1, P3, P2; Wartezeit: (3+16 +9 +0) /4 = 7 msbei FCFS: 10.25 ms (P1 vor P2 vor P3 vor P4)
• Problem: Kenntnis über die Bedienzeiten erforderlich. Für Stapelbetriebgeeignet, da dort Information über Rechenzeiten zur Verfügung stehen(Benutzer geben bei Batch-Jobs Rechenzeit an). Für SJF gibt es wiedernicht-unterbrechende und unterbrechende Varianten. Im letzteren Fall wirdein Prozess unterbrochen, falls ein Prozess rechenwillig, dessen nächsteRechenphase kürzer ist als die noch verbleibende Rechenzeit des momentanrechnenden Prozesses.
• Für interaktive Prozesse wird die Länge der nächsten Rechenphase ("Burst")geschätzt:
Sn+1 = 1/nn∑
i=1
Ti
Ti = Ausführungszeit der i-ten Rechenphase.
Si = Schätzung für die i-te Rechenphase.
S1 = Schätzung für die erste Rechenphase. Diese wird nicht berechnet.
Anpassung der Berechnung (auf diese Weise wird die erneute Berechnung dergesamten Summe vermieden)
Sn+1 = (1/n) * Tn + (n-1)/n * SnHierbei wird jeder Rechenphase gleiches Gewicht gegeben. Durch die Wahleines geeigneten Faktors könnte man die neueren Rechenphasen höhergewichten als die weiter zurückliegenden Rechenphasen, z.B. Sn+1 = a * Tn+ (1-a) * Sn mit 0<a<1.
128
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
4.3.3 Beispiel Unix Scheduling
Beim Unix-Scheduling 3 handelt sich um eine Zeitscheibenstrategie mitdynamischer Prioritätenvergabe. Unix vergibt für seine Prozesse Prioritäten von0 - 127 (0 ist die höchste Priorität), die in 32 Warteschlangen verwaltet werden.Alle Prozesse einer Prioritätsklasse befinden sich in einer Warteschlange, die nacheiner Round-Robin Strategie abgearbeitet wird. Zunächst wird allen Prozessen derhöchsten Priorität die CPU zugeteilt bis die Warteschlange leer ist. Dann kommendie Prozesse mit der nächstniedrigeren Priorität zum Zuge. Die Prioritätenwerden fortlaufend neu berechnet (multilevel-feedback-queue). Die Prioritätender Prozesse, die in einem gewissen Zeitabschnitt viel Rechenzeit verbrauchthaben, werden erniedrigt; Prozesse, die lange gewartet haben, erhalten eine höherePriorität.
• Zeitscheibenstrategie pro Warteschlange bis Warteschlange leer; dann Schedu-ling mit nächst niedrigerer Warteschlange.
• dynamische Berechnung der Prozesspriorität:
(1) u_prio = USER_PRIO + p_cpu/4 + 2 * p_nice
p_cpu ist die Prozessornutzung des rechnenden Prozesses und wird alle 10 msum 1 inkrementiert.p_nice ist ein vom Benutzer bestimmter Gewichtungsfaktor (-20 ≤ p_nice ≤20).USER_PRIO ist die Priorität, die dem Prozess beim Start zugeteilt worden ist.Der Wert von p_cpu wird jede Sekunde angepasst
(2) p_cpu = (2 * load)/(2 * load + 1) * p_cpu + p_nice
load ist eine Abschätzung der CPU-Auslastung.
Die Anpassung (2) sorgt dafür, dass die bisher verbrauchte Rechenzeit nacheiner gewissen Zeit nicht mehr ins Gewicht fällt. Das "short-term-scheduling"unterstützt das interaktive Arbeiten am Rechner. Die Prioritäten von Prozessen,die lange auf die Ausführung von E/A-Operationen warten, werden erhöht.Dagegen werden die Prioritäten von Prozessen, die wesentliche CPU-Zeiten aufsich vereinigen, verringert. Dies bedeutet zusammenfassend, dass ”interaktive”Prozesse den ”Batch”-Prozessen vorgezogen werden.
• neuere Unix Varianten unterstützen Prioritäten von 0 bis 255, unterteilt in
0 - 127: Echtzeitprozesse128 - 177: Systemdienste178 - 255: Benutzerprozesse
3siehe: Leffler u.a. : Das 4.3 BSD Unix Betriebssystem, Addison-Wesley
129
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
• Linux nutzt eine Kombination von dynamischen Prioritäten und Zeitscheiben-verfahren, wobei die Art der Prozesse, Echtzeit oder interaktiv, berücksichtigtwird. 4
Linux hat unterschiedlich lange Zeitscheiben, je nach Priorität, z.B. 200msfür die höchste und 10ms für die niedrigste Priorität.
4.3.4 Thread Scheduling
Die Prozessorzuteilung von Threads hängt von deren Art der → Realisierung(siehe Seite 118) ab.
User-Threads
Realisierung der Threads im Benutzeradressraum ⇒ Kern hat keine Kenntnisbzgl. der Threads. BS-Scheduler wählt nur Prozess aus. Laufzeitsystem desProzesses wählt rechenwilligen Thread des Prozesses aus; es kann ein beliebiges→ Scheduling-Verfahren (siehe Seite 124) für Prozesse verwendet werden. Daauf der Ebene des Laufzeitsystems keine Zeitunterbrechungen (clock interrupts)bearbeitet werden (sie werden auf Betriebssystem-Ebene bearbeitet), könnenThreads so lange laufen, bis sie selbst die CPU freiwillig aufgeben, d.h. einThread kann vom Laufzeitsystem aufgrund des Ablaufs einer Zeitscheibe nichtunterbrochen werden.
• Java Virtual Machines verwenden unterbrechendes Prioritäten-Scheduling fürThreads;
10 ist die höchste und 1 die niedrigste Priorität;
Ein rechenwilliger höher priorer Thread führt zur Unterbrechung einesrechnenden niedriger prioren Thread ("unterbrechender Scheduler").
Weiterhin kann ein Thread auch freiwillig die CPU aufgeben ("cooperativescheduler"). Probleme treten auf, wenn Threads die gleiche Priorität haben.Falls ein cooperative Scheduler verwendet wird, ist der aktuelle Threadsolange rechnend, bis er freiwillig die CPU aufgibt. Falls er dies nichtmacht, sind die anderen rechenwilligen Threads nur wartend (Gefahr desVerhungerns).
Ein unterbrechender Thread-Scheduler wird in gewissen Zeitabständenden aktuell rechnenden Thread unterbrechen, und andere Threads gleicherPriorität auswählen.
4siehe Achilles S 44 für detailliertere Ausführungen.
130
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
Das Ablauf-Verhalten hängt vom Scheduling Verfahren der jeweiligenJVM Implementierung ab, z.B. Windows verwendet unterbrechendes ThreadScheduling, während der Mac bisher cooperative Thread Scheduling realisiert(möglicherweise anders bei MacOS 10).
Kernel-Threads
Realisierung der Threads im Systemadressraum ⇒ BS-Scheduler wählt dennächsten auszuführenden Thread aus.
a) Ist ausgewählter Thread demselben Prozess zugeordnet wie der vorherrechnende Thread⇒ geringer Kontextwechsel.b) Ist ausgewählter Thread nicht demselben Prozess zugeordnet wieder vorher rechnende Thread ⇒ aufwendiger Kontextwechsel. In diesemFall findet auch ein Adressraumwechsel statt, d.h. die Register zurSpeicherabbildung müssen angepasst werden.
4.3.5 Mehrschichtiges Scheduling
Der Scheduler wählt einen der rechenwilligen Prozesse aus. Da diese aber u.U.nicht alle im Arbeitsspeicher vorliegen (Speicherknappheit) und ein Einlagerneines Prozesses von der Platte in den Arbeitsspeicher aufwendig ist, verfügenSysteme häufig über ein Mehr-Schichten Scheduling.
• Short-Term-Scheduler (CPU Scheduler)Auswahl eines geeigneten Prozesses aus der Ready-Queue; wird häufigaufgerufen; Verfahren siehe oben.
• Long-Term-SchedulerAuswahl rechenwilliger neuer Aufträge (meist Jobs aus dem Hintergrundbe-trieb (batch)) und Einlagerung in den Arbeitsspeicher; Einfügen der Prozessein die Ready-Queue. Scheduler kontrolliert den Multiprogramming-Grad, d.h.wieviele Prozesse im Arbeitsspeicher liegen. Long-Term-Scheduler wird relativselten aufgerufen. Wenn ein Prozess das System verläßt, wird dieser Scheduleru.U. erst nach mehreren Minuten aufgerufen.
Kriterium: guten Prozessmix erzielen, d.h. Mischung aus E/A-intensivenund rechenintensiven Prozessen (nur E/A-intensiv: Ready-Queue häufigleer, CPU nicht ausgelastet, andersherum: E/A-Geräte schlecht ausgelastet).
Long-term Scheduling ist nicht immer vorhanden: z.B. in Unix nicht, jederneue Prozess wird in Arbeitsspeicher geladen. Eine andere Zwischenstufe ist
131
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
Medium-term-Scheduling: bei Überlast werden Prozesse auf Hintergrundspei-cher ausgelagert (swap out) und später wieder eingelagert (swap in).
• Graphische Darstellung
Long-term
Scheduler
neue
Aufträge
swap-in
CPU Scheduler
E/A-Warteschlange
Zeit-Interrupt-
Warteschlange
CPU fertig
E/A-Befehl
Zeitscheibe
abgelaufen
sleep-Befehl
Systemaufruf
Ready Queue
ausgeswappte
Prozesseswap-out
Ausführung im
BS-Kern
4.3.6 Echtzeit Scheduling
In Multimedia-Umgebungen treten die zu verarbeitenden kontinuierlichen Daten(Empfangen, Dekodierenen und Anzeigen von Videoframes) in bestimmten, meistperiodischen Zeitabständen auf. Die Operationen auf diese Daten wiederholensich dabei immer wieder und sollen bis zu einem gewissen Zeitpunkt abgeschlos-
132
Schlichter, TU München 4.3. PROZESSORVERWALTUNG
sen sein. Prozesse in Multimedia-Anwendungen 5 führen oft zeitkritische Ope-rationen aus. Bzgl. des Scheduling existieren zwei gegensätzliche Ziele:
a) ein unkritischer Prozess sollte nicht dauerhaft blockiert werden, weilzeitkritische Prozesse eine Ressource gänzlich auslasten. Daher solltenzeitkritische Prozesse und Verwaltungsarbeiten nicht die gesamte Kapazitäteiner Ressource beanspruchen.b) zeitkritische Prozesse dürfen nicht durch Scheduling-Verfahren (Round-Robin oder Prioritäten) am zeitkritischen Fortschritt gehindert werden ⇒Einhaltung von Zeitvorgaben.
• Zuordnung von Kenngrößen zu zeitkritischen Prozessen
Bereitzeit (ready time): frühestmöglicher Ausführungsbeginn einerAktivität.Frist (deadline): spätester Zeitpunkt für die Beendigung einer Aktivität.Ausführungszeit: worst-case Abschätzung für das zur vollständigenAusführung einer Aktivität notwendige Zeitintervall.
In vielen Fällen werden Aktivitäten periodisch ausgeführt. Deshalb werdenhierzu neben der Ausführungszeit Kenngrößen wie Frequenz der Aktivität(Periode) und Versatz des Ausführungsbeginns relativ zum Anfang der Periode(Phase) erfasst.
• Earliest Deadline First (EDF)Der Prozessor wird immer dem Prozess mit der am nächsten in derZukunft liegenden Frist zugeordnet. Es existieren die beiden Varianten:nicht-unterbrechend und unterbrechend. Fasst man die Fristen als Prioritätenauf, dann entspricht dieses Verfahren im Prinzip dem prioritäten-basiertenScheduling.
– nicht-unterbrechendEine Prozessorzuordnung bleibt bis der Prozess eine blockierende System-funktion aufruft oder freiwillig die CPU abgibt. Neue eintreffende Prozessemit kürzeren Fristen werden erst beim nächsten Scheduling berücksichtigt.
– unterbrechendDiese Variante führt einen Kontextwechsel durch, wenn ein Prozessmit einer kürzeren Frist rechenwillig wird. Man kann zeigen, dass diepreemptive Variante immer eine Abarbeitungsreihenfolge mit Einhaltungaller Zeitvorgaben findet, solange mindestens eine solche Reihenfolgeexistiert.
5[Steinmetz1999, S303][Nehmer2001, S123]; Videobilder nicht zu früh, sonst Pufferüberlauf;Videobilder nicht zu spät, sonst Ablaufgeschwindigkeit nicht korrekt.
133
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
• Rate-Monotonic SchedulingRate-Monotonic Scheduling (RMS) ist für periodische Prozesse; RMS ordnetPrioritäten in Abhängigkeit von der Periode zu.
1) Prozesse mit der höchsten Frequenz (kleinste Periode) erhalten diehöchste Priorität.2) Prozesse mit der geringsten Frequenz (längste Periode) erhalten dieniedrigste Priorität.
Die Priorität ist statisch; sie ändert sich nicht für den Rest der Prozesslaufzeit.Prioritäten geben die relative Wichtigkeit eines Prozesses gegenüber derWichtigkeit anderer Prozesse im Rechensystem wider. RMS ist relativ einfachzu handhaben und sie erlaubt eine Abschätzung, ob eine Echtzeitanwendungauf einer bestimmten Rechenanlage ohne Fristverletzung ausgeführt werdenkann oder nicht.
– Auswahl der Prozesse anhand ihrer Priorität. Jedoch auch unter Berücksich-tigung der anderen Kenngrößen, wie z.B. Bereitzeit.
– hochfrequente Prozesse werden minimal verzögert.
– Zerstückelung niederfrequenter Prozesse, da sie häufig wegen hochfrequen-ter Prozesse unterbrochen werden.
4.4 Unterbrechungskonzept
Die optimale Ausnutzung und Auslastung aller Geräte eines Rechensystems legtMehrprogrammbetrieb nahe. Zerlegung der Ausführungsphasen eines Programmsin viele Einzelteile;
- Aufbrechen der Ausführung eines Prozesses in mehrere Phasen: u.a.Rechnen, E/A, Synchronisieren mit Partner.- Die Ausführung der Programme wird in der Regel mehrfach unterbrochen.
4.4.1 Motivation
Ursachen für Unterbrechungen
zugeteilte Prozessorzeit ist aufgebraucht;benötigte Ressourcen stehen aktuell nicht zur Verfügung;ein E/A-Gerät meldet sich zurück;ein Fehler tritt auf, z.B. Division durch 0;Systemaufruf (wurde bereits als spezielle Unterbrechung eingeführt);
134
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
Die ersten 3 Ursachen sind extern veranlasst, während die letzten beidenUnterbrechungen intern ausgelöst werden.
• Bei einer Unterbrechung wird ein gerade aktiver Prozess unterbrochenund eine Unterbrechungsbehandlung durchgeführt. Nach Beendigung derUnterbrechungsbehandlung kann prinzipiell ein beliebiger rechenbereiterProzess fortgesetzt werden.
• Es ist erforderlich, bei der Unterbrechung den CPU Status des gerade aktivenProzesses für die spätere Fortsetzung zu speichern. Als Minimum ist dabeider Befehlszähler und das Programmstatuswort zu retten, da diese bei derEinstellung des neuen Zustandes bei der Unterbrechungsausführung in derCPU verändert werden. Weitere Zustandsinformationen wird dann in derUnterbrechungsbehandlung des Betriebssystems gerettet.
• Forderung: Eine Unterbrechung muss so kontrolliert erfolgen, dass eindefinierter Prozessstatus festgehalten werden kann.
4.4.2 Unterbrechungsarten
Die normale Programmausführung eines Prozessors kann auch durch mehrereArten von Unterbrechungen verändert werden. Man unterscheidet zwischensynchronen und asynchronen Unterbrechungen.
Unterbrechung
synchron asynchron
TrapAlarme
(Exception)Interrupt
Der Aufruf von Systemdiensten des Betriebssystems erfolgt über "Traps"(Software Interrupt). Bei einem Hardware Interrupt meldet z.B. ein Gerät überein HW-Signal ein Ereignis an die Software, z.B. E/A abgeschlossen. .
135
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
Externe, asynchrone Unterbrechungen
Dies sind Unterbrechungen (Interrupts), die von außerhalb des zu unterbrechen-den Prozesses ausgelöst werden, z.B. E/A-Kanal-"Endmeldung". Asynchrone Un-terbrechungen sind Ereignisse im Rechensystem, die über besondere Steuerbus-leitungen an den Prozessor weitergegeben werden. Asynchron bedeutet in diesemKontext, dass der eintreffende Interrupt in keiner kausalen Beziehung zum aktuellausgeführten Befehl steht.
• Der Ablauf im Rechnerkern (RK) wird unterbrochen und eine Unterbrechungs-anfangsbehandlung des Betriebsystemkerns wird aktiviert.
E/A-Kanal 2 CPU (RK) BS-Kern
Ende E/A
Auftrag
Unterbrechungs-
behandlung (UBH)
Interne, synchrone Unterbrechungen
Dies sind Unterbrechungen (Alarme, Exceptions), die durch den zu unterbrechen-den Prozess selbst ausgelöst werden, z.B. Division durch 0. Synchrone Unter-brechungen sind eine unmittelbare Folge der aktuellen Befehlsausführung. Siekönnen auch explizit durch einen speziellen Befehl (Trap) ausgelöst werden. MitHilfe von Traps werden Systemdienste im Betriebssystem aufgerufen. Im Fehler-fall spricht man auch von Alarmen ("exceptions").
• Der Ablauf im RK wird unterbrochen und eine Unterbrechungsanfangsbehand-lung des Systemkerns wird aktiv. In der Unterbrechungsanfangsbehandlungwird der Status des unterbrochenen Prozesses gerettet und es wird die Ursache
136
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
der Unterbrechung identifiziert. Anschließend wird zu der zugehörigen Unter-brechungsbehandlung verzweigt.
CPU (RK) BS-Kern
Unterbrechungs-
behandlung (UBH)
Unterbrechung
arithmetischer Alarm
• Beispiele von internen Unterbrechungen
Speicherschutzalarm: Prozess greift auf Speicherbereich zu, der nichtvorhanden ist oder auf den er nicht zugreifen darf.
Befehlsalarm: dem Operationscode des Maschinenbefehls ist keine Opera-tion zugeordnet.
Seitefehltalarm: Seite der virtuellen Adresse ist nicht im Arbeitsspeicher.
arithm. Alarm: arithm. Operation kann nicht ausgeführt werden, z.B.Division durch 0.
Systemaufruf: kontrollierter Übergang in das Betriebssystem.
4.4.3 Behandlung externer Unterbrechungen
Synchrone und asynchrone Unterbrechungen haben hardwaremäßig die Speiche-rung des aktuellen Prozessorzustandes zur Folge und lösen im Anschluss daraneinen indirekten Sprung über eine im Speicher befindliche Sprungtabelle aus. Da-bei ordnet der Prozessor jeder synchronen und asynchronen Unterbrechung einenfesten Index in der Sprungtabelle zu. An dieser Stelle steht die Anfangsadresseder Unterbrechungsroutine, die entsprechende Folgemaßnahmen einleitet. Fallsmöglich (Ausnahme ist z.B. ein arithmetischer Alarm) kann die unterbrocheneProgrammausführung durch die Wiederherstellung des gespeicherten Prozessor-zustandes zu einem beliebigen, späteren Zeitpunkt fortgesetzt werden.
137
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
Ablauf
• Geräte-Controller meldet Unterbrechung über spezielle Interrupt-Leitung anCPU.
• CPU prüft im Befehlszyklus nach jeder Befehlsausführung, ob eine Unterbre-chung gemeldet wurde.
• Falls Unterbrechung vorliegt: sichern u.a. des aktuellen Befehlszählers, desProgrammstatusworts und Sprung zu einer Unterbrechunganfangsbehandlung,die an festgelegter Speicheradresse steht. Die restlichen Informationen, wieRegister, werden dann von der Unterbrechungsbehandlung gesichert.
Routine untersucht Unterbrechungsursache, die vom Controller überDatenleitung gemeldet wird (Unterbrechungsnummer).
über Unterbrechungsnummer erfolgt die Auswahl der benötigten Unter-brechungsbehandlungsroutine; Nummer ist i.a. Index in eine Tabelle, demUnterbrechungsvektor.
Vektor enthält Speicheradresse der Unterbrechungsbehandlungsroutine.
4.4.4 Konflikte
Konflikte bei Unterbrechungen treten z.B. in folgenden Situationen auf:
(1) während einer Unterbrechungsbehandlung treten weitere Unterbrechun-gen auf;(2) es treffen gleichzeitig mehrere Unterbrechungswünsche ein.
• BeispielE/A-Kanal 1 und E/A-Kanal 2 erledigen beide Aufträge für Prozess A.
138
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
Unterbrechungs-
behandlung (UBH)
E/A-Kanal 1 Prozess A BS-Kern E/A-Kanal 2
Ende E/A
Auftrag
externe
Unterbrechung
externe
Unterbrechung
Ende E/A
Auftrag
Konflikt
• Mögliche Konfliktlösungen
– Andere Unterbrechungen nicht zulassen, d.h. Maskierung von Unterbrechun-gen; anstehende Unterbrechung ignorieren oder vorläufig zurückstellen; Pro-blem: u.a. Rechtzeitigkeit der Unterbrechungsbehandlung. Beispielsweisesollte ein Division durch 0 in UBH sofort behandelt werden.
– Interne Unterbrechungen erfolgen stets sofort und geben der zugehörigenUnterbrechungsbehandlung dieselbe Priorität, wie sie der unterbrochene Ab-lauf hatte. Die Benutzerprozesse haben die niedrigste Ablaufpriorität, näm-lich 0. Unterbrechungen von Unterbrechungsbehandlungen sind möglich.
– Externe Unterbrechungen erhalten Prioritäten z.B. (0,...,31) zugeordnet. Dieaufgerufene Unterbrechungsbehandlung erhält die Priorität (Ablaufpriorität)der auslösenden Unterbrechung.
Eine weitere externe Unterbrechung wird während einer Unterbre-chungsbehandlung zugelassen, wenn die Priorität der neuen Unterbre-chung höher als die Ablaufpriorität der gerade aktiven Unterbrechungs-behandlung ist. Trifft dieser Fall nicht zu, so wird der Unterbrechungs-wunsch zurückgestellt, bis ein Ablauf mit einer niedrigeren Ablaufprio-rität aktiv wird.
Konsequenz: Unterbrechungsroutinen müssen ablaufinvariant (reentrant)sein!
139
Schlichter, TU München 4.4. UNTERBRECHUNGSKONZEPT
• Integration der Unterbrechungsbehandlung in den Befehlszyklus der CPU
prüfen ob interne Unterbrechung aufgetreten,falls ja, Behandlung der Unterbrechungsonst : prüfen ob externe Unterbrechung mit höherer Priorität. Wenn jawähle eine mit höchster Priorität.
Bei Unterbrechung: sichere alten Zustand, stelle neuen Zustand her undführe ersten Befehl der Unterbrechungsbehandlungsroutine aus.
140
Kapitel 5
Speicherverwaltung
Der Adressraum ist eine zentrale Abstraktion, die von der Systemsoftware einesRechensystems zur Verfügung gestellt werden muss. Über den Adressraum sindalle für die Ausführung eines Anwendungsprogramms notwendigen Operationenund Datenstrukturen zugreifbar. Allgemein wird ein Adressraum durch einezusammenhängende Menge von Adressen und deren Inhalte definiert. Diemaximale Größe eines Adressraums kann aus dem Adressbusaufbau derverwendeten Prozessorarchitektur abgeleitet werden. Modernde Rechensystemeunterscheiden zwischen den Adressräumen der Programme und dem physischenAdressraum (Arbeitsspeicher).
5.1 Fragestellungen
Dieser Abschnitt beschäftigt sich mit den Adressräumen für Programme undderen Abbildung auf den physischen Arbeitsspeicher einer Rechenanlage:
• Programmadressraum vs. Maschinenadressraum.
• Direkte Adressierung, Basisadressierung.
• Virtualisierung des Speichers; virtuelle Adressierung, insbesondere Seiten-adressierung.
5.2 Einführung
Die unmittelbare Nutzung des physischen Adressraums (Arbeitsspeichers) bei derAnwendungsentwicklung ist nicht empfehlenswert. Probleme sind folgende:
141
Schlichter, TU München 5.2. EINFÜHRUNG
- Kenntnisse über Struktur und Zusammensetzung des Arbeitsspeichersnotwendig.- Kapazitätsengpässe bei der Arbeitsspeichergröße. Werden die in einemRechensystem bei der Befehlsausführung durch den Rechnerkern auftreten-den Adressen direkt als reale Speicheradressen interpretiert, so kommt manschnell in Kapazitätsengpässe. Die Kapazität des Arbeitsspeichers reicht oftnicht aus, um alle Daten darin abzulegen. Deshalb weicht man auf den Hinter-grundspeicher (Platte) aus, um Teile der Daten eines Prozesses dort abzulegen.
⇒ deshalb Programmerstellung unabhängig von realer Speichergröße und-eigenschaften. Abstrahieren von realen Eigenschaften der Hardware. DieHandhabung der unterschiedlichen Speicher sollte für die Programmierungin höheren Programmiersprachen ohne Belang sein, d.h. der Programmierersoll sich nicht explizit um das Nachladen von benötigten Daten vomHintergrundspeicher in den Arbeitsspeicher und umgekehrt kümmernmüssen. Dies soll automatisch, d.h. transparent für den Programmierergeschehen.
5.2.1 Adressräume
• Maschinenadressraum
Der Arbeitsspeicher besteht aus einer Folge von fortlaufend nummeriertenBytes. Die Nummerierung beginnt bei 0. Die Nummer des Bytes bezeichnetman als seine Adresse, genauer als seine physische Speicheradresse oder seineMaschinenadresse.
• Programmadressraum
Wenn ein Benutzer programmiert, dann benutzt er in seinem ProgrammAdressen, um seine Variablen zu bezeichnen. Diese Adressen nennen wirProgrammadressen.Die Menge der zulässigen Programmadressen ist der Programmadressraum.Dieser ist prozessspezifisch, d.h. Programmadressen haben nur Programm-lokale Bedeutung z.B. als Sprungziele.
• Speicherabbildung
142
Schlichter, TU München 5.2. EINFÜHRUNG
Die CPU muss vor jedem Zugriff auf Befehle und Operanden die jeweiligenProgrammadressen in Maschinenadressen umsetzen. Diese Umsetzung wirddurch Speicherabbildungen geleistet. Die wichtigsten dieser Abbildungenwerden in den folgenden Abschnitten kurz vorgestellt.
direkte Adressierung,Basisadressierung,Seitenadressierung undSegment-Seitenadressierung.
5.2.2 Organisation von Adressräumen
Im Adressraum einer Anwendung müssen alle für die Programmausführung not-wendigen Daten zur Verfügung gestellt werden. Darunter fallen der Programmco-de (Text), der Datenbereich (statische und dynamische Daten) und der Laufzeit-keller. Für jede dieser Informationsarten wird ein Bereich im Adressraum spezi-fiziert, deren Platzierung und Größe durch die Adressraumverwaltung festgelegtwird.
Single-Threaded Adressraum
Programmstatische
Daten
dynamische Daten
(Halde)Keller
niedrige
Adresse
hohe
Adresse
Die Bereiche Programmcode und statische Daten verändern sich typischerweisewährend der Programmausführung nicht. Dagegen können der dynamischeDatenbereich (Halde) und der Laufzeitkeller an Umfang erheblich zunehmen.Beim Laufzeitkeller hängen Größenschwankungen und Ausdehnung von dermaximalen Tiefe der Prozedur/Methodenschachtelung und dem Bedarf an lokalenVariablen ab.
143
Schlichter, TU München 5.2. EINFÜHRUNG
Multi-Threaded Adressraum
Programmstatische
Daten
dynamische Daten
(Halde)
niedrige
Adresse
hohe
Adresse
Keller nKeller 1
Für jeden Kontrollfluss (Thread) wird ein eigener Kellerbereich vorgesehen.Der Abstand zwischen den einzelnen Kellern wird meist standardmäßig vomSystem vorgegeben. Unabhängig von der Anzahl der Laufzeitkeller muss eineÜberschneidung zwischen mehreren Kellern oder zwischen dem untersten Kellerund der Halde vermieden werden.
Beispiel - Adressräume
Moderne Betriebssysteme stellen wenigstens 32 Bit große virtuelle Adressräumefür die Anwendungen zur Verfügung, die jeweils in mehrere Bereiche unterteiltsind. Programmcode, statische Daten, Halde und Laufzeitkeller der Anwendungwerden jeweils in dem Bereich des Adressraums abgelegt, der der Anwendungzugänglich ist.
Windows 32 bit Adressierung
0 4 GByte3 GByte2 GByte1 GByte
Linux 32 bit Adressierung
spezieller Adressbereich (Größe nicht proportional)
Der für die Anwendung nutzbare Adressbereich (weißer Bereich) schwankt
144
Schlichter, TU München 5.2. EINFÜHRUNG
zwischen ca. 2 GByte und 4 GByte. Bei allen BS wird ein unterschiedlichgroßer Adressbereich am Anfang (Adressen 0 und aufwärts) für jeglichen Zugriffgesperrt: bei Windows 95 sind es 4 KByte, bei Windows NT 64 KByte, bei BSDUnix ist es abhängig vom Rechnertyp (4 - 8 KByte). Durch diese Sperrung wirdjeder Zugriff auf diesen Bereich und damit insbesondere das Dereferenziereneines Nullzeigers vom System abgefangen und die Programmausführung miteiner Fehlermeldung abgebrochen. Gleiches gilt für den Bereich zwischen demAdressbereich der Anwendung und des Betriebssystems; auch hier ist ein kleinerBereich, z.B. 64 KB bei Windows, nicht zugreifbar, um fehlerhafte Pointer zuerkennen.
In Windows 95 wird zusätzlich der Adressbereich von 4 KByte - 4 MByte von derNutzung durch 32 Bit Anwendungen ausgeklammert (Adressbereich für MS-DOSbzw 16 Bit Anwendungen).
Im oberen Bereich des virtuellen Adressraums wird meist der Betriebssystemcodeeingeblendet (z.B. bei Windows 95 im Bereich 1 GByte - 2 GByte; dadurchkönnen BS-Funktionen auch ohne Adressraumwechsel genutzt werden. BeiBSD Unix und Windows NT/2000 ist dieser Bereich vor jeglichem Zugriffdurch die Anwendung geschützt (oft wird sogar lesender Zugriff unterbunden).Bei Windows 95 besteht dieser Schutz nicht, d.h. Anwendungen können dasBetriebssystem zum Absturz bringen.
Windows 7 bzw. Windows 10 unterstützt 64 Bit Adressierung mit einem virtuellenAdressraum von 8 TB. Für die Größe des physikalischen Arbeitsspeichers geltenjedoch folgende Einschränkungen:
Windows 7 Professional bis 192 GB
Windows 7 Home Premium bis 16 GB
Windows 7 Home Basic bis 8 GB
Windows 10 Professional bis 512 GB
Windows 10 Home Basic bis 128 GB
Mac OS X bis 128 GB
Haldenverwaltung
Dynamisch erzeugte Daten, z.B. Listen und Objekte werden auf der Halde (heap)gespeichert. 1 Die Halde wird nicht nach dem Kellerprinzip verwaltet. Zellen desKellerspeichers werden mit Hilfe der Operation pop freigegeben. Kellerbereichewerden nach dem LIFO-Prinzip verwaltet. Datenobjekte der Halde werden beiBedarf erzeugt und gelöscht. Nicht mehr benötigte Datenobjekte werden entweder
1siehe Informatik II von Prof. Brügge.
145
Schlichter, TU München 5.2. EINFÜHRUNG
explizit durch einen Programmaufruf entfernt (z.B. durch Anweisung free(objref))oder implizit durch das System mit Hilfe der Speicherbereinigung (garbagecollection). Garbage collection ist eine Komponente des Laufzeitsystems, dasnicht referenzierte Objekte identifiziert, und deren Speicherplatz auf der Haldefreigibt.
• Belegung Beispiel C:
void malloc(size_t size) belegt dynamisch einen Speicherbereichund gibt einen Pointer auf diesen Speicherbereich zurück. malloc gehörtzur C Standard Bibliothek. size_t ist als unsigned int definiert. mallocinitialisiert den Speicherbereich nicht. Falls ein Fehler auftritt, wirdein Nullpointer zurückgegeben. Mit Hilfe der Funktion free wird derSpeicherbereich wieder freigegeben. malloc ist eine Fehlerquelle in C-Programmierung, da gelegentlich die Freigabe des belegten Speichersvergessen wird. In Java automatische Freigabe des belegten Speichersdurch den Garbage Collector.
• Der Speicherbereich einer Halde besteht aus zwei Klassen:
– Belegtbereiche: Speicherbereiche werden für Realisierungen von Datenob-jekten verwendet.
– Freibereiche: Speicherbereiche, die momentan nicht für Realisierungen vonDatenobjekten verwendet werden; d.h. sie sind frei. Belegt-/Freibereiche sindnicht konsekutiv im Arbeitsspeicher organisiert, sondern bestehen jeweils auseiner Menge von Teilbereichen.
• Buchführung des Speicherbereichs einer Halde mit Hilfe von Belegungs- undFreigabeoperationen.
• Verwaltung der FreibereicheSpeicherbereiche (belegt, frei) sind in Blöcken unterschiedlicher Längeorganisiert. Verwaltung freier Blöcke
– implizite Liste über Längen - verlinkt alle Blöckejeweils Feststellen, ob der Block belegt oder frei ist.extra Bit im selben Wort wie Blockgröße. Jeder Block spezifiziert imersten Wort die Blockgröße sowie in einem extra Bit Information darüber,ob der Block belegt oder frei ist.
146
Schlichter, TU München 5.2. EINFÜHRUNG
5 4 6 2
Implementierung: sehr einfach; Allozierung in linearer Zeit. Die Belegungund Freigabe ist sehr einfach, da bei Belegung nur nach einem Blockgeeigneter Größe gesucht und das Belegtbit gesetzt werden muss. BeiFreigabe muss nur das Belegtbit wieder freigegeben werden. Möglicherweisekann er mit einem vorhergehenden bzw. nachfolgenden freien Blockkombiniert werden.
– explizite Liste (Freiliste) über die freien BlöckeAllozierung: Durchsuchen der Freiliste nach geeignetem Block
5 4 6 2
Das Verfahren etwas aufwendiger als implizite Listen, da ein extra Pointernotwendig ist. Bei impliziten Listen ist kein extra Pointer notwendig, daaufgrund der Blockgröße der Beginn des jeweils nächsten Blocks leicht zubestimmen ist. Eine weitere Verfeinerung ist die Führung von getrenntenFreiliste für jede unterschiedliche Größenklasse. Damit wird die Suche beider Allozierung erleichtert.
• FreilisteDie Freibereiche der Halde werden mit Hilfe einer Liste (z.B. einfach verkettet)verwaltet.
public class freibereich {int size;freibereich next;<methodendefinitionen>
}Für jeden verfügbaren Freibereich wird jeweils die Größe in Bytes gespeichert.Man könnte auch eine doppelt verkettete Liste anlegen.
– Auswahl eines geeigneten Freibereichs
147
Schlichter, TU München 5.2. EINFÜHRUNG
Bei Erzeugung eines neuen Datenobjektes wird die Operation belege(intsize) ausgeführt. Der Parameter size spezifiziert hier die Größe des benötig-ten Speicherbereichs auf der Halde. Für die Auswahl eines geeigneten Frei-bereichs zur Erfüllung der gestellten Anforderungen existieren verschiedeneVerfahren.
∗ first-fit-Verfahrenbestimme von Beginn der Freiliste den ersten Speicherbereich, der dieAnforderung erfüllt. Der gefundene freie Speicherbereich wird aufgeteiltin den Belegtbereich und den nicht benötigten Bereich. Letzterer wirdwieder in die Freiliste eingetragen. Es kann passieren, dass am Beginnder Freiliste die Freibereiche immer kleiner werden, d.h. nachfolgendeAnforderungen müssen mehr Elemente in der Freiliste untersuchen.∗ next-fit-Verfahren
bestimme in der Freiliste den ersten Speicherbereich, der die Anforderungerfüllt. Die Suche wird dort fortgesetzt, wo die letzte Suche beendet wurde.∗ best-fit-Verfahren
bestimmt in der gesamten Freiliste den Speicherbereich, der am besten diegestellte Anforderung erfüllt, d.h. mit möglichst wenig Verschnitt. best-fit ist langsamer als first-fit und next-fit, da jeweils die gesamte Freilistedurchsucht werden muss. Überraschenderweise führt es im Durchschnittzu größerer Speicherverschwendung; das Zuteilungsverfahren hinterläßtmehr sehr kleine Speicherbereiche, die nicht mehr zugeteilt werdenkönnen.∗ worst-fit-Verfahren
bestimme in der Freiliste den größten freien Speicherbereich und teileihn in einen Belegtbereich (zur Erfüllung der Anforderung) und einenverbleibenden Freibereich auf. Mit Hilfe des worst-fit-Verfahrens soll dieProblematik des best-fit-Verfahrens mit seinen vielen kleinen, meist nichtmehr nutzbaren freien Speicherbereichen vermieden werden.
– FragmentierungProblematisch ist die Entstehung von vielen kleinen freien Rest-Freibereichen, die wegen ihrer kleinen Längen als Belegtbereiche ungeeignetsind. Zur Vermeidung dieser nutzlosen, kleinen Freibereiche ist es zweckmä-ßig, eine Minimallänge für Freibereiche festzulegen und bei Belegungsanfor-derungen entsprechend längere Belegtbereiche zu erzeugen. Auch wird mitHilfe des worst-fit-Verfahrens die Problematik etwas reduziert.
• Garbage CollectionJava sammelt belegten Speicher, der nicht mehr benötigt wird, auf. In C mussder Speicher explizit durch free freigegeben werden; deshalb oft sogenannte
148
Schlichter, TU München 5.2. EINFÜHRUNG
Memory-Leaks. Garbage Collection geht zurück auf die Lisp Systeme, die inden 1960’er Jahren von McCarthy am MIT entwickelt wurden.
automatische Rückgewinnung von nicht mehr benötigtem Speicherüblich in Spachen wie Java, Lisp, Perl, ....
– Woher kennt der Speichermanager nicht mehr benötigte Objekte?i.a. nicht bekanntallerdings können gewisse Blöcke nur dann benutzt werden, wennPointer zu Ihnen existieren.
– Annahmen über PointerSpeichermanager müssen Pointer von anderen Objekten unterscheidenkönnen. Und zwar von Objekten, die keine Pointer sind.Alle Pointer müssen auf den Blockanfang zeigen.
– Speicher als GraphAnnahme
jeder Block ist ein Knotenjeder Pointer ist eine KanteKantenausgangsknoten ist nicht auf der Halde (sondern im Keller) ⇒Knoten ist Wurzel
erreichbar
nicht
erreichbar
Wurzelknoten
Haldenknoten
Besttimmung erreichbarer Knoten. Ein Knoten (Block) ist erreichbar, wennes einen Pfad von einer Wurzel zum Knoten gibt. Nicht-erreichbare Knotensind Garbage.
∗ Mark and SweepAufsammeln mittels markieren und durchlaufen
Mark: an Wurzeln starten, Pfade durchlaufen und alle erreichbarenSpeicherblöcke markierenSweep: Scannen aller Blöcke; Freigabe nicht markierter Blöcke
– Zeitpunkt der Durchführung von Garbage Collectionwenn kein weiterer Platz mehr vorhanden ist, z.B. new gibt Fehler zurück
149
Schlichter, TU München 5.2. EINFÜHRUNG
automatisch im Hintergrund, wenn System nicht ausgelastet ist. Hierwird meist davon ausgegangen, dass der Prozentsatz des belegtenSpeichers einen bestimmten Schwellenwert überschreitet.
Animation Haldenverwaltungsiehe online Version
5.2.3 Fragmentierung
Unter dem Begriff Fragmentierung versteht man verschiedene Formen derZerstückelung des noch freien und nutzbaren Teils des Adressraums in kleineBereiche. Fragmentierung kann jedesmal dann entstehen, wenn eine neueSpeicherplatzanforderung aus der Menge noch freier Speicherbereiche mit einemeinzigen zusammenhängenden Bereich befriedigt werden muss. Unterscheidungzwischen externer und interner Fragmentierung.
• Externe FragmentierungEs wechseln sich benutzte und unbenutzte Speicherbereiche innerhalb desAdressraums ab. Speicheranforderungen werden jeweils genau erfüllt.
belegt belegt belegt
Anforderung
belegt belegt belegtbelegt
freie Speicherbereiche
Im Fall eines Anwendungsadressraums tritt dies beim dynamischen Daten-bereich (Halde) auf; Fragmentierung entsteht durch die unterschiedlichen
150
Schlichter, TU München 5.2. EINFÜHRUNG
Speicheranforderungs- und Freigabemuster. Durch zeitaufwendiges Zusam-menschieben der Belegtbereiche (Kompaktifizieren) entsteht aus vielen kleinenSpeicherresten ein großer Freibereich. Beim Kompaktifizieren müssen u.U. dieAdressen in den Programmen angepasst werden (z.B. Verweise auf Absolut-adressen).
• Interne FragmentierungDer Speicher ist in Bereiche fester Größe untergliedert und Speicheranforde-rungen werden nur in Vielfachen dieser festen Grundgröße befriedigt.
Anforderung
freier Speicherbereich
Der Verschnitt findet innerhalb dieser Bereiche fester Größe statt. Beispiels-weise kann Plattenspeicher nur blockweise belegt werden; die Blockgrößeschwankt zwischen 512 Byte und 4-8 Kbyte. Selbst für die Speicherung eineseinzigen Bytes muss ein ganzer Block belegt werden.
5.2.4 Forderungen an Adressraumrealisierung
Aus der Sicht der Anwendungsprogrammierung können für einen Adressraumeine Reihe wichtiger Forderungen an dessen Realisierung gestellt werden.Hier geht es um den Programmieradressraum für Prozesse, und nicht um denMaschinenadressraum (Arbeitsspeicher).
151
Schlichter, TU München 5.3. SPEICHERABBILDUNGEN
• Homogene und zusammenhängende Adressbereiche. Dies ermöglicht eineProgrammentwicklung ohne das ansonsten notwendige Wissen über Position,Typ und Größe der referenzierbaren Speichermodule und E/A-Controller.
• Größe des genutzten Adressraums unabhängig von der Kapazität desphysischen Adressraums (Arbeitsspeichers).
• Erkennen fehlerhafter Zugriffe. Beispielsweise Zugriffe, die aus demAdressraum herausführen
• Erkennen von Überschneidungen zwischen Halde und Keller sowie zwischenmehreren Laufzeitkellern.
• Schutz funktionstüchtiger Anwendungen gegenüber fehlerhaften Anwendun-gen. Hier geht es darum, dass die Adressbereiche der Anwendungen und auchdes Betriebssystems voneinander abgeschottet werden. Ist dieser Schutz nichtgewährleistet, können fehlerhafte Programme den Adressraum einer anderenAnwendung verändern und damit Folgefehler in dieser auslösen ⇒ nicht de-terministische Fehler. Fehler dieser Art sind schwer zu reproduzieren und ihreLokalisierung ist meist extrem schwierig und langwierig.
• Kontrollierbares und kontrolliertes Aufteilen der Speicherressourcen auf alleAnwendungen.
• Speicherökonomie, minimale Fragmentierung. Es sollten gängige Technikeneingesetzt werden, um die durch dynamische Anforderungen bedingte Spei-cherfragmentierung und den tatsächlichen Speicherbedarf jeder Anwendung zuminimieren, z.B. gemeinsame Nutzung von Funktionsbibliotheken durch meh-rere parallel laufende Anwendungen ⇒ Funktionsbibliothek muss nur einmalgeladen werden.
5.3 Speicherabbildungen
Dieser Abschnitt behandelt einige Mechanismen zur Abbildung von Programm-adressen auf Maschinenadressen des Arbeitsspeichers.
5.3.1 Direkte Adressierung
Bei der direkten Adressierung werden die Programmadressen direkt alsMaschinenadressen interpretiert. Es treten drei Probleme auf:
152
Schlichter, TU München 5.3. SPEICHERABBILDUNGEN
Verschiebbarkeit,Programmgröße,Speicherausnutzung.
Verschiebbarkeit
In einem Mehrprozesssystem sind i.d.R. mehrere Programme im Arbeitsspeicher.Bei direkter Adressierung werden die Programme beim Laden fixiert undmüssen dann bis zu ihrem Ende an derselben Stelle bleiben. Eine Verschiebungist nicht möglich, da der Benutzer mit Adressen rechnen kann und deshalbpositionsabhängige Adressen in seinen lokalen Variablen hat.
• ProblemExterne Fragmentierung des Arbeitsspeichers. Sei der Arbeitsspeicher zunächstlückenlos mit Programmen P1, P2, P3 gefüllt.
P1 P2 P3
Nach Beendigung des Programms P2 entsteht eine Lücke.
Neue Programme passen u.U. nicht exakt in die zurückgebliebene Lücke.Auf diese Weise entstehen immer mehr Lücken. Möglicherweise passenProgramme nicht mehr in den Arbeitsspeicher, weil keine ausreichend großeLücken vorhanden ist, obwohl insgesamt noch ausreichend Platz wäre. Diesist das Problem der externen Fragmentierung des Arbeitsspeichers. Da dieProgramme wegen der direkten Adressen nicht verschiebbar sind, ist eineSpeicherbereinigung erst möglich, nachdem alle angefangenen Programmebeendet sind.Ein verwandtes Problem tritt bei Programmverdrängungen auf. Das verdrängteProgramm muss zur weiteren Ausführung später wieder an dieselbe Stellegeladen werden, dies ist jedoch in der Regel nicht mehr möglich, da andereProgramme im benötigten Speicherbereich stehen können.
• ForderungIn Mehrprogramme/Mehrprozesssystemen müssen daher Programme ver-schiebbar sein.
Programmgröße
Programme können wesentlich größer als der verfügbare Arbeitsspeicher werden.Bei direkter Adressierung muss der Benutzer sein Programm selbst in Segmente
153
Schlichter, TU München 5.3. SPEICHERABBILDUNGEN
zerlegen und diese nach Bedarf selbst nachladen. Man spricht von dersogenannten Overlay-Technik (veraltet). Die Overlay-Technik ist aufwendig,schwierig und damit auch fehleranfällig. Da die Zerlegung statisch ist, kanndie Zerlegung des Programms nicht dynamisch an den konkret vorhandenenArbeitsspeicher angepasst werden und damit die jeweilige Maschine gutausnutzen.
• ForderungEs muss daher gefordert werden, dass die Programmgröße unabhängig von derrealen Arbeitsspeichergröße ist.
Speicherausnutzung
Programme bestehen aus Modulen, die nur zu bestimmten Zeiten verwendetwerden. Beispielsweise wird bei einer Matrizenmultiplikation nur auf die Module,die das Multiplikationsprogramm und auf die Module, die die Daten enthalten,zugegriffen. Es ist nun wünschenswert, von einem Programm nur den Ausschnittim Arbeitsspeicher zu halten, der momentan und in naher Zukunft benötigt wird.Damit lassen sich mehr Programme im Arbeitsspeicher unterbringen und parallelverarbeiten. Dies steigert den Datendurchsatz des Systems.
• ForderungArbeitsspeicher beinhaltet nur die momentan bzw. in naher Zukunft notwen-digen Ausschnitte des Programms. Nutzen der Lokalitätseigenschaft von Pro-grammen:
durch Datenstrukturen z.B. Arrays, oderProgrammstrukturen: Prozeduren, Schleifen.
5.3.2 Basisadressierung
Die Basisadressierung hat eine einfache Abbildungsvorschrift:Maschinenadresse = Basisadresse + Programmadresse
• Die Basisadresse ist programmspezifisch. Sie steht in einem Register desRechnerkerns und ist dem Programm, das im Benutzermodus abläuft, nichtzugänglich. Sie wird vom Betriebssystem festgelegt.
• Die Programmadressen aller Programme beginnen jeweils mit Null. Durch dieBasisadressierung wird das Problem der Verschiebbarkeit gelöst. Die anderenProbleme bestehen jedoch weiterhin. Deshalb wird die Basisadressierung inmodernen Betriebssystemen nicht mehr eingesetzt.
154
Schlichter, TU München 5.3. SPEICHERABBILDUNGEN
• SpeicherverwaltungsstrategienAufgabe: Finden eines zusammenhängenden Arbeitsspeicherbereichs, der großgenug ist, um das Programm zu speichern⇒ siehe Verfahren zur→Verwaltungder Halde (siehe Seite 147). Hier kommen die Strategien zum Einsatz, diebereits bei der Haldenverwaltung diskutiert wurden, insbesondere deren Vor-und Nachteile. Beispielsweise erfordert best-fit immer den Durchlauf durch diegesamte Freibereichsliste. Zusätzlich liefert diese Strategie mit der Zeit immerkleinere Fragmente⇒ externe Fragmentierung.
– first-fitDurchsuche die Liste der Freibereiche vom Anfang an und nimm den erstenpassenden Frei-Bereich: Spalte nicht benötigten Speicher ab und füge ihn alsfreien Bereich in die Freibereichsliste ein. Problem: am Anfang häufen sichkleine Reststücke, die bei jeder Suche neu durchsucht werden müssen.
– next-fitDurchsuche die Liste der Freibereiche nach first-fit, jedoch beginne die Suchedort, wo man bei der letzten Suche aufgehört hat. Problem von first-fit mitden kleinen Reststücken am Anfang wird vermieden.
– best-fitDurchsuche die Liste der Freibereiche vom Anfang an und nimm denpassenden Frei-Bereich, der die Speicheranforderungen des Programms ambesten erfüllt: Spalte nicht benötigten Speicher ab und füge ihn als freienBereich in die Freibereichsliste ein.
– worst-fitDurchsuche die Liste der Freibereiche vom Anfang an und nimm den Frei-Bereich, der die Speicheranforderungen des Programms am schlechtestenerfüllt: Spalte nicht benötigten Speicher ab und füge ihn als freien Bereich indie Freibereichsliste ein.
– Buddy-SystemeSpeicheranforderungen werden in Größen von Zweierpotenzen vergeben,d.h. eine Anforderung wird auf die nächste Zweierpotenz aufgerundet
Anforderung 280 Bytes⇒ Belegung von 512 Bytes = 29
In Linux wird dieses Verfahren in Kombination mit der Seitenadressierungverwendet. Zusammenhängende Kacheln des Arbeitsspeichers werdenmittels des Buddy-Verfahrens zugeordnet.
∗ am Anfang besteht der Arbeitsspeicher aus einem großen Stück. Abhängigvon der Größe des Arbeitsspeichers.
155
Schlichter, TU München 5.4. SEITENADRESSIERUNG
∗ Speicheranforderung von 2k: ist Speicherbereich dieser Größe vorhanden,dann Unterteilung eines Speicherbereichs der Größe 2k+1 in 2 Speicherbe-reiche der Größe 2k Bytes. Ihre Anfangsadressen sind gleich bis auf dask-te Bit; dies ist invertiert. Dies läßt sich ausnutzen, um in einem Schrittzu überprüfen, ob für ein freigewordenes Speicherstück das entsprechendePartnerstück existiert und frei ist.∗ Freigabe eines Speicherbereichs von 2k: falls auch entsprechendes
Partnerstück frei ist, dann Verschmelzung der beiden Speicherbereiche zueinem Speicherstück der Größe 2k+1.
5.4 Seitenadressierung
Die virtuelle Adressierung wurde Ende der 50er Jahre 2 eingeführt. Vieleweiterführende Arbeiten erfolgten dann später im Rahmen des Projektes MACund des Systems MULTICS (Vorgänger von UNIX) in den USA in den 60erJahren. Ziel ist
Virtualisierung des Speichers,Verstecken von realen Beschränkungen, wie Speichergröße,Speicher als sehr großes Feld gleichartiger Speicherzellen zu betrachten.
Die Seitenadressierung ("paging") ist die Grundform der virtuellen Adressierung.
5.4.1 Ansatz
Der Programmadressraum, der sogenannte virtuelle Adressraum eines Prozesseswird in aufeinanderfolgende Seiten (engl. page) gleicher Größe unterteilt.Man spricht deshalb von virtuellen Adressen des Prozesses, anstatt vonseinen Programmadressen. Gängige Größen für virtuelle Adressräume heutigerArchitekturen:
232 , also 32-Bit Adressen zum Ansprechen der Speicherzellen.Fortgeschrittene Architekturen: 264, also 64-Bit Adressen (z.B. Sun ULTRA-Sparc).
Die Seiten sind keine logische Aufteilung des Speichers. Denkaufgabe: was hatdas für Vor- und Nachteile?
• Der Maschinenadressraum, also der physische Adressraum des Arbeitsspei-chers, wird in Kacheln (engl. frame) unterteilt. Seiten und Kacheln sind i.d.R.2Fotheringham, J. : Dynamic storage allocation in the ATLAS computer including an automatic
use of backing store. CACM 4:10, 435-436, Oct 1961.
156
Schlichter, TU München 5.4. SEITENADRESSIERUNG
gleich groß. Es ist auch möglich, dass die Seitengröße ist ein Vielfaches der Ka-chelgröße ist. Im Folgenden wird von gleichen Größen ausgegangen. TypischeSeitengrößen sind 4 - 8 KByte.
• Eigenschaften der Seitenadressierung
– Die Seiten eines Prozesses können im Arbeitsspeicher oder auf demHintergrundspeicher (Platte) gespeichert sein.
– Die Kacheln nehmen die Seiten der Prozesse auf. Wichtig ist, dass sowohldie Seiten als auch die sie aufnehmenden Container, die Kacheln, eineeinheitliche Größe besitzen. Das erleichtert die Speicherverwaltungsaufgabeerheblich.
– Wenn während der Prozessausführung eine virtuelle Adresse des Prozess-adressraums verwendet wird, so muss die Seite, in der sich die Adresse be-findet, in einer Kachel des Arbeitsspeichers geladen (eingelagert) sein. Es isteine Abbildungsvorschrift notwendig, die die virtuelle Adresse auf die realeKacheladresse (Maschinenadresse) abbildet. Ein Problem ist:
woher weiss das BS welche Seite eines Prozesses sich wo imArbeitsspeicher befindet, d.h. welche Kachel welcher Seite zugeordnetist?
Antwort: Beschreibung der Seiten erforderlich; dazu Verwendung vonDeskriptoren, die in Tabellen verwaltet werden (Seiten-Kacheltabelle).
– Die Zuordnung, welche Seite in welcher Kachel gespeichert ist, und wo sichdie Seite auf dem Hintergrundspeicher befindet, erfolgt mittels der Seiten-Kacheltabelle, die die Seitendeskriptoren enthält. Die Zuordnung von Seitezu Kachel kann sich im Laufe eines Programmablaufes ändern.
– Befindet sich bei einer Befehlsausführung die erforderliche Seite nicht imArbeitsspeicher, so löst ein solcher Zugriff eine Unterbrechung aus ⇒Seitenfehler⇒ Einlagerung der Seite bei Bedarf ("Demand Paging").Der Seitenfehler ist eine synchrone Unterbrechung, die vom Betriebssystemzu behandeln ist, d.h. die geforderte Seite ist in den Arbeitsspeicher zu laden.Man spricht deshalb auch vom Demand Paging. Nach dem erfolgreichenLaden der Seite wird der Befehl, der zum Alarm führte, erneut ausgeführt.Der gesamte Vorgang heißt Seiteneinlagerung (engl. paging).
– Falls eine Seite eingelagert werden muss, aber gleichzeitig bereits alleKacheln des Arbeitsspeichers besetzt sind, so muss eine der eingelagertenSeiten aus dem Arbeitsspeicher verdrängt werden. Man spricht von
157
Schlichter, TU München 5.4. SEITENADRESSIERUNG
der Seitenauslagerung. Die Strategien, die man hierbei einsetzt, heißenSeitenersetzungsstrategien. Ziel dieser Strategien ist es, eine möglichstgünstige Seite auszuwählen, und diese auf den Hintergrundspeicherauszulagern. Günstig bedeutet hier, eine Seite, die entweder für denProzessablauf nicht mehr benötigt wird, oder die erst sehr viel später benötigtwird, als die anderen Seiten im Arbeitsspeicher.
• virtueller Speicher - ArbeitsspeicherDer Zusammenhang zwischen dem virtuellen Speicher, hier den virtuellenAdressräumen der Prozesse, und dem Arbeitsspeicher sowie Hintergrundspei-chermedien wird nachfolgend skizziert. Auf die einzelnen Bereiche gehen wirim Folgenden näher ein. Wir gehen hier vereinfachend davon aus, dass auch dieBlöcke als Einheiten des Hintergrundspeichers die Größe einer Seite besitzen.
Seite 1 von
P1
Seite 2 von
P1
.....
virt. Adressraum von P1
Seite 1 von
P2
Seite 2 von
P2
.....
virt. Adressraum von P2
...
...
...
...
...
...
...
...
Deskriptor
Seiten-Kachel
Tabelle
Kachel 1
Kachel 2
Kachel 3
Kachel 4
Kachel 5
...
Arbeitsspeicher
mit Kacheln
Hintergrundspeicher
mit Blöcken
Auslagern
Einlagern
• VorteileBei der Seitenadressierung werden durch eine flexible Speicherabbildung alleProbleme der → direkten Adressierung (siehe Seite 152) gelöst. D.h. dieProgramme können:
verschoben werden,größer als der Arbeitsspeicher sein,auch ausschnittsweise im Arbeitsspeicher sein.
– Zusätzliche positive Eigenschaften
158
Schlichter, TU München 5.4. SEITENADRESSIERUNG
∗ Es können gemeinsame Speicherbereiche zwischen Prozessen realisiertwerden. Programme können gemeinsame Speicherbereiche haben, bei-spielsweise bei gemeinsamen Daten nebenläufiger Prozesse. Auch Code-Bereiche können im Hinblick auf eine bessere Speicherausnutzung ge-meinsam sein, beispielsweise muss der Code eines Compilers nur einmalgeladen werden, auch wenn ihn mehrere Benutzer gleichzeitig verwen-den. Dies ist besonders interessant für ablaufinvarianten Code (reentrant),der während der Ausführung nicht verändert wird.∗ Es ist ein differenzierter Zugriffsschutz innerhalb eines Prozesses möglich.
Zugriffsrechte für einzelne Seiten können unterschiedlich vergebenwerden.Sie haben eine Seite, in der Programmcode, aber keine Variablengespeichert sind. Sie können auf dieser Seite nur lesen bzw. ausführenerlauben, dagegen kein Verändern. Ein Verändern würde ja bedeuten, dassder Programmcode im Ablauf modifiziert wird. Dies nutzen Angreifer, diesich in einem Wirtprogramm "einnisten".
5.4.2 Adressabbildung
Bei der Seitenadressierung erfolgt die Umsetzung der Programmadressen, also dieUmsetzung der virtuellen Adressen in Maschinenadressen durch eine Abbildungvon Seiten auf Kacheln. Eine virtuelle Adresse v ist gegeben durch v = (s, w),wobei s die Seitennummer und w das Offset in der Seite angibt. Die Adresse vwird abgebildet auf die reale Adresse p = (k, w), wobei k die Kachelnummerangibt, die die Seite enthält.
Seitentabellenregister
k
Seiten-Kacheltabelle
Längenregister
L
s w
s
virtuelle Adresse
k w
Adresse im Arbeitsspeicher
D.h. die virtuelle Adresse wird von der CPU nicht direkt auf den Speicherbus
159
Schlichter, TU München 5.4. SEITENADRESSIERUNG
gelegt, sondern an die MMU (Chip oder mehrere Chips) weitergeleitet. Die MMUberechnet die reale Adresse und legt sie auf den Bus. Falls s> L ist, kann mit Hilfedes Längenregisters sofort ein Adressierungsfehler entdeckt werden.
Beispiel für Adressrechnung
Gegeben sei ein 16-Bit virtueller Adressraum und eine Seitengröße von 4K. D.h.der Adressraum zerfällt in 16 Seiten; man benötigt 4 Bit, um die Seitennummernzu identifizieren und 12-Bit, um die 4096 Byte innerhalb einer Seite zuadressieren.
0v = 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0
s = 2
0100 1
0011 1
1102 1
0003 1
1004 1
0115 1
0006 0
0007 0
0008 0
1019 1
00010 0
11111 1
00012 0
00013 0
00014 0
00015 0
present/
absent Bit
1 1 0 0 0 0 0 0 0 0 0 0 1 0 0
Seiten-
Kacheltabelle
12 bit offset w
wird kopiert
p =
k = 6
Die Anzahl der Bits von s (Seitennummer) und k (Kachelnummer) können sichunterscheiden. Die Zahl der Bits von s hängt von der Größe des virtuellenAdressraums ab, während sich die Anzahl der Bits von k aus der Größe desMaschinenadressraums ergibt. Damit können s und k unterschiedliche lang sein.
160
Schlichter, TU München 5.4. SEITENADRESSIERUNG
Memory Management Unit
Die Adressrechnung wird von der Hardware, der MMU (Memory ManagementUnit), durchgeführt.
CPU MMUArbeits
speicher
virtuelle
Adressen
physische
Adressen
Speicherbus
Meist ist die MMU auf dem CPU-Chip integriert.
• Translation Lookaside BufferZur Adressumsetzung enthält die MMU die Tabelle Translation LookasideBuffer (TLB), die häufig auftretenden Seitennummern die Kachelnummerzuordnet. TLB umfasst wenige Einträge (z.B. 8, 16, oder 32) und kann alsCache interpretiert werden.
Bei jedem Zugriff auf eine virtuelle Adresse wird überprüft, ob sich diezugehörige Seite und damit die Kacheladresse im TLB befindet. TLB istals assoziativer Cache organisiert (vgl.TGI!), d.h. alle Einträge werdengleichzeitig auf Übereinstimmung mit dem Seitenanteil der referenziertenAdresse verglichen. Ist kein entsprechender Eintrag in der TLB (TLB-miss), erfolgt die Adressabbildung über den relevanten Deskriptor der Seiten-Kacheltabelle.
Ein Eintrag in der TLB enthält eine virtuelle und zugeordnete reale Adresse⇒ kein aufwändiges Page Table Lookup für TLB-Einträge erforderlich.Designziel bei der Verwaltung der TLB-Einträge ist eine gute Trefferrate (TLB-hit).
161
Schlichter, TU München 5.4. SEITENADRESSIERUNG
k
Seiten-Kacheltabelle
s w
s
virtuelle Adresse
k w
Adresse im
Arbeitsspeicher
KachelnrSeitennr
TLB
TLB miss
TLB hit
Ohne TLB sind für die Umrechnung 2 Zugriffe im Arbeitsspeicher notwendig:1. Zugriff auf Seiten-Kacheltabelle, 2. Zugriff auf Speicherstelle. Falls für dieSeite noch kein Eintrag in TLB vorhanden ist, wird zunächst der entsprechendeSeitendeskriptor in den TLB geladen.
ZugriffszeitSei
TLB Suche: 20 nsSpeicherzugriff: 100 ns
Bei einem TLB hit ergibt sich Zugriffszeit 120 ns und bei einem TLB misssind dies 220 ns. Im letzteren Fall ergibt sich dies aus der Summe: 20 ns (TLBSuche) + 100 ns (Zugriff auf Eintrag in Seiten-Kacheltabelle) + 100 ns (Zugriffauf Speicherzelle)
Bei einer TLB-Treffer Wahrscheinlichkeit von 80% ergibt sich als durchschnitt-liche effektive Speicherzugriffszeit
0,80 * 120 + 0,20 * 220 = 140 ns
Für einen Speicherzugriff ergibt sich damit eine 40% Verzögerung gegenüberder direkten Adressierung. Gegenüber der Seitenadressierung ohne TLB ergibtsich eine Verbesserung von 30%.
162
Schlichter, TU München 5.4. SEITENADRESSIERUNG
5.4.3 Seiten-Kacheltabelle
Die Adressabbildung erfolgt mittels der Seiten-Kacheltabelle (SKT). Wir benöti-gen Informationen über die zu verwaltenden Seiten. Dazu wird jede Seite einesProzesses durch einen Seitendeskriptor beschrieben. Die Seiten-Kacheltabelle isti.a. prozessspezifisch. Neben der Zuordnung Seite-Kachel enthält ein Seitende-skriptor noch weitere Informationen, wie z.B. die Zugriffsrechte und den Zustandder Seite.
Struktur eines Seitendeskriptor
Informationen in einem Seitendeskriptor:
• Zugriffsrechte (A)Angabe, ob der Prozess
- ausführend (x ∈ A),- lesend (r ∈ A),- schreibend (s ∈ A).
auf die Seite zugreifen darf. Diese Information wird vom Betriebssystemeingetragen und in der CPU vor dem Zugriff ausgewertet.
• Seite existent (e)Es müssen nicht alle Seiten existent sein. Beispielsweise sind oft dieSeiten zwischen Ende der Halde und Kellerende nicht existent. Generellbesteht die Vorstellung, dass in einem Adressraum mehrere Objekte (Datenoder Programmteile) sind, zwischen denen Lücken liegen können. Seitendes Adressraums, in denen keine Objekte sind, sind nicht existent. Wirdversucht, auf eine nicht existente Seite zuzugreifen, dann gibt es einenSpeicherschutzalarm.
• Seite geladen (v)Die Abbildung ist gültig (engl. valid). Die Seite ist also in den Arbeitsspeichergeladen, d.h. ihr ist eine Kachel zugeordnet. Es kann auf sie zugegriffen werden.Eine nicht geladene, aber existente Seite steht im Verdrängungsbereich (engl.swap area) auf dem Plattenspeicher. Soll auf eine existente, aber nicht geladeneSeite zugegriffen werden, dann löst die CPU einen Seitefehltalarm aus, d.h. einSeitenfehler tritt ein. Die Seite wird vom Hintergrundspeicher geladen, und dasProgramm an der Stelle fortgesetzt, die den Seitefehltalarm auslöste.
163
Schlichter, TU München 5.4. SEITENADRESSIERUNG
• Zugriffsbit (r)Das Zugriffsbit (engl. reference bit) dient zur Unterstützung der Seitenerset-zungsalgorithmen. Es wird von der CPU nach dem Laden der Seite gelöschtund bei einem Zugriff auf eine Seite von der CPU gesetzt. Nach einem gewis-sen Zeitintervall wird es wieder zurückgesetzt.
• Veränderungsbit (m)Die Seite wurde verändert (modifiziert). Dieses Bit dient ebenfalls zurUnterstützung der Seitenersetzungsalgorithmen. Es wird nach dem Ladender Seite von der CPU gelöscht und nach einem schreibenden Zugriff aufdie Seite gesetzt. Beispielsweise könnte eine Verdrängungsstrategie bevorzugtSeiten auslagern, die nicht modifiziert wurden, d.h. ein Übertragen der Seiteauf den Hintergrundspeicher ist nicht notwendig, da die Seite auf demHintergrundspeicher noch aktuell ist⇒ man spart sich den Datentransfer.
Probleme
Es gibt einige Probleme mit der Seitenadressierung, die sich auf die Speichereffi-zienz und die Performanz beziehen.
• Größe der Seiten-KacheltabelleDie Seiten-Kacheltabelle kann sehr groß werden, z.B. bei Seitengröße 4K(früher üblich!) ergeben sich für 32-bit Adressraum insgesamt 1 Million Seitenpro Prozess.
Lösung? Mehrstufige Tabellen: Seiten-Kacheltabelle ebenfalls in Seitenunterteilen, die ihrerseits in Tabellen gehalten werden. Technisch wird beieinem mehrstufigen Verfahren der Seitenanteil der virtuellen Adresse inAbhängigkeit von der Stufenzahl weiter unterteilt, z.B. s1, s2,...sn. In derRegel wird mit der Adressabbildung ab dem höchstwertigen Bit begonnen.Der Anteil s1 definiert den Index für die Seitentabelle erster Stufe, s2 denIndex für den Anteil zweiter Stufe, etc.
164
Schlichter, TU München 5.4. SEITENADRESSIERUNG
s1 w
virtuelle Adresse
s2
Deskriptor
Deskriptor k w
Beispielsweise kann ein 32-Bit Adressraum auf der ersten Stufe in 128 Seiten(27) mit je 32 MByte unterteilt werden. Ein Seitentabellen-Deskriptor verweistauf eine Seitentabelle, die die 32 MByte große Seite in weitere Seiten unterteilt,z.B. 256 KByte. Es muss nicht die gesamte Tabelle im Arbeitsspeicher gehaltenwerden. Das schrittweise Durchlaufen u. U. mehrstufiger Seiten-Kacheltabellennennt man Page-Table Lookup.
– Linux verwendet ein 3-stufiges Paging Verfahren 3
jede virtuelle Adresse ist in 4 Teile aufgeteilt.
• PerformanzSchnelle Umrechnung der virtuellen auf realen Adressen erforderlich, daBerechnung bei jedem Zugriff notwendig ist! Häufig verwendete Adressenwerden in einem Schnellzugriffspeicher (cache) der MMU gehalten, demTranslation Lookaside Buffer (TLB).
Varianten der SKT
Varianten für den Aufbau einer Seiten-Kacheltabelle.
• Prozess-spezifisch, Index-basiert (PI)Zugriff auf Deskriptor für Seite si über Index i.
3Tanenbaum01 S 770
165
Schlichter, TU München 5.4. SEITENADRESSIERUNG
• Prozess-spezifisch, assoziativ (PA)Hier wird die Seitennummer mit in den Seitendeskriptor aufgenommen. DieSKT ist prozessspezifisch. Es sind nur die geladenen Seiten aufgeführt.
• Global, assoziativ (GA)Es gibt nur eine SKT im System. Da die Seitennummer allein nicht eindeutigist, muss das Prozesskennzeichen (PID), d.h. der eindeutige Prozessname,ebenfalls in den Deskriptor aufgenommen werden. Es sind nur die geladenenSeiten aufgeführt. Die maximale Anzahl der Elemente dieser SKT ist dieAnzahl der Kacheln, falls gemeinsame Speicherbereiche der Prozesse nichtbetrachtet werden.
• Global, indiziert (GI)Enthält auch PID und es erfolgt eine Reihung gemäß der Kachelnummer;freie Kacheln werden durch einen speziellen Eintrag gekennzeichnet. Kacheln,denen keine Seite zugeordnet ist, erhalten einen speziellen Eintrag bei PID.Damit enthält die Tabelle so viele Elemente wie Kacheln im Arbeitsspeichervorhanden sind. Da die Angabe der Kachelnummern sich aus der Positionin der Tabelle ergibt, kann diese Angabe entfallen. Der Ansatz entsprichteiner invertierten Seitentabelle. Tabelle muss nach Seitennummer durchsuchtwerden (im schlechtesten Fall die gesamte Tabelle) ⇒ Verwendung vonHaschcodierung bei Tabellenzugriff (Hashwert auf Seitennummer).
5.4.4 Seitenfehlerbehandlung
Der Zugriff auf eine Seite, die nicht im Arbeitsspeicher ist, führt zu einemSeitenfehler.
load M
Prozess P1
Seiten-
Kacheltabelle
(1) Zugriff
(6) Befehl
erneuert
Seitenfehler-
behandlung des
BS
(2) page fault
Kachel 1
Kachel 2
Kachel 3
.....
(5) Aktuali-
sieren
Arbeitsspeicher
Hintergrundspeicher
mit Blöcken
(4)
Einlagern
(3) Seite auf Hintergrundspeicher
166
Schlichter, TU München 5.4. SEITENADRESSIERUNG
Ablauf der Seitenfehlerbehandlung
1. Beim Zugriff auf eine virtuelle Adresse (z.B. LOAD-Befehl) tritt einSeitenfehler auf.
2. Die Adressrechnungshardware löst einen Alarm aus, so dass die Unterbre-chungsbehandlung des BS aktiviert wird. Dieser wird beispielsweise in derMMU bei der Adressrechnung ausgelöst. Der Prozesszustand muss gerettetwerden, u.a. der Befehlszähler und die Registerbelegungen. Weiterhin muss derUnterbrechungsbehandlung die Adresse übergeben werden, die den Seitenfeh-ler auslöste.
3. Das BS stellt eine freie Kachel zur Verfügung, lokalisiert die Seite auf derPlatte und initiiert die Einlagerung der Seite (Lesen von Platte). Falls aktuellkeine Kachel frei ist, muss eine Seite auf den Hintergrundspeicher verdrängtwerden. Falls die Daten nicht auf der Festplatte vorhanden sind, wird einSpeicherschutzalarm ausgelöst.
4. Die Seite wird eingelagert.
5. Der Seitendeskriptor wird aktualisiert und verweist jetzt auf die belegte Kachel(im Beispiel k = 3).
6. Der unterbrochene Befehl wird erneut gestartet. Die Daten sind jetztzugreifbar. Dazu muss zunächst wieder der Prozesszustand geladen werden,d.h. Befehlszähler, Register etc. Anschließend wird der Befehl fortgeführt, alsob keine Unterbrechung stattgefunden hätte.
5.4.5 Seitenverwaltungsstrategien
Aufgabe der Arbeitsspeicherverwaltung: Laden der für die Ausführung derProzesse benötigten Seiten in die Kacheln. Es ergeben sich drei strategischeAufgaben:
Ladestrategie
Frage: welche Seite ist zu Laden?
• Lösungsansätze
– Einzelseitenanforderungsstrategie (on demand): eine Seite wird genau danngeladen, wenn auf sie zugegriffen wird und sie sich noch nicht imArbeitsspeicher befindet.
167
Schlichter, TU München 5.4. SEITENADRESSIERUNG
– Seiten-Prefetching: Seiten werden im Voraus geladen, um sie sofort beiBedarf verfügbar zu haben. Wann ist Prefetching sinnvoll und was benötigtdas BS? Beispielsweise am Anfang beim Laden des main-Programms.
∗ Windows XP kombiniert "Demand Paging" mit "Prefetching": bei einemSeitenfehler werden die gewünschte Seite sowie auch einige nachfolgendeSeiten (falls möglich) in den Arbeitsspeicher eingelagert.
Platzierungsstrategie
Frage: in welche Kachel ist eine Seite zu Laden?
• Lösung
– keine strategische Entscheidung erforderlich, da alle Kacheln gleichwertigsind und damit keine Auswahl getroffen werden muss. Vorteil der uniformenRealisierungskonzepte (Seite, Kachel).
Seitenverdrängungsstrategie
Frage: welche Seite ist aus dem Arbeitsspeicher zu entfernen, wenn für eine zuladende Seite keine freie Kachel mehr zur Verfügung steht? Im Idealfall bautein Verdrängungsverfahren auf der Referenzlokalität vieler Programme (Verbotvon Goto-Befehlen) und der sich ergebenden Lokalitätsmenge auf. Solangesich die Lokalitätsmenge jedes Prozesses im Arbeitsspeicher befindet, ist dieSeitenfehlerrate sehr gering. Auf der Grundlage der Working-Set-Theorie ergibtsich damit für ein Seitenverdrängungsverfahren die Aufgabe, bevorzugt solcheSeiten auszulagern, die nicht in der Lokalitätsmenge enthalten sind.
• FIFO StrategieFIFO (first-in first-out): Verdrängen der ältesten Seite, einfach zu implementie-ren. Das Verfahren berücksichtigt die Lokalitätsmenge nicht. So werden überlängere Zeit hinweg häufig referenzierte Seiten verdrängt (z.B. Seiten mit Kon-stanten und globalen Variablen, die am Anfang geladen und häufig referenziertwerden). Umgekehrt bleiben auch wenig referenzierte Seiten im Mittel genau-so lange im Arbeitsspeicher wie häufig referenzierte Seite. Vorsicht bzgl derFIFO-Anomalie, d.h. trotz Vergrössern des zur Verfügung stehenden Arbeits-speichers können u.U. mehr Seitenfehler (d.h. Seiteneinlagerungsoperationen)auftreten, als bei kleinerem Speicher. (Warum, woran könnte so etwas liegen?Antwort: FIFO beachtet nicht, wann die Seite zuletzt benutzt wurde. D.h. ei-ne häufig benutzte globale Variable, die zu einem frühen Zeitpunkt eingelagert
168
Schlichter, TU München 5.4. SEITENADRESSIERUNG
wurde, könnte z.B. dazu führen, dass diese Seite nach dem Entfernen gleichwieder eingelagert werden muss.)
– Belady’s AnomalieZuordnung von zusätzlichen Kacheln an einen Prozess reduziert nichtnotwendigerweise die Anzahl der Seitenfehler. Das Gegenteil ist möglich.Beispiel:
∗ Aufrufsequenz von benötigten Seitennummern: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3,4, 5∗ jeweils 3 Seiten im Arbeitsspeicher:
(1, 2, 3), (2, 3, 4), (3, 4, 1), (4, 1, 2), (1, 2, 5), (2, 5, 3), (5, 3, 4)⇒ 9Seitenfehler
∗ jeweils 4 Seiten im Arbeitsspeicher:(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 1), (4, 5, 1, 2), (5, 1, 2, 3), (1, 2, 3, 4),(2, 3, 4, 5)⇒ 10 Seitenfehler
• Second-ChanceVariante von FIFO, die vermeidet, dass ältere Seiten, obwohl sie häufig benutztwerden, ausgelagert werden. Neben dem Status "älteste Seite" wird auchZugriffsbit r betrachtet:
r = 1: Seite wird an das Ende der FIFO Liste gestellt; r wird auf 0 gesetzt.Die Seite wird so behandelt, als ob sie neu angekommen wäre.
r = 0: Seite wird ausgelagert; bei Modifikation (m-Bit gesetzt) wird Seitezurückgeschrieben.
– Clock-AlgorithmusEine Implementierungsart von Second-Chance ist der Clock-Algorithmus.
4 Die Seiten werden in einem Ring angeordnet. Ein Pointer zeigt auf dennächsten Kandidat für eine Auslagerung. Falls r=1 ist, wird das Zugriffsbitzurückgesetzt und der Pointer auf die nächste Seite im Ring gesetzt.
Oft in Kombination mit dem m-Bit (Modifikation).
4Tanenbaum01 S 238, Stallings S370
169
Schlichter, TU München 5.4. SEITENADRESSIERUNG
Seite 9
r=0
m=1Seite 94
r=0
m=0
Seite 95
r=1
m=0Seite 45
r=1
m=0
Seite 46
r=1
m=0
Seite 47
r=1
m=1
Seite 7
r=0
m=1
Verfahren
1. beginnend von der aktuellen Pointerposition suche die erste Seite mit(r=0, m=0); diese Seite wird ausgelagert. Die Zugriffsbits werden nichtverändert, d.h. zurückgesetzt.
2. Falls 1. Schritt fehlschlägt, suche nach der ersten Seite mit (r=0; m=1);diese Seite wird ausgelagert. Von untersuchten Seite wird das r-Bitzurückgesetzt. Die Zugriffsbits aller untersuchten Seiten werden auf 0zurückgesetzt.
3. Falls 2. Schritt fehlschlägt, starte von der ursprünglichen Pointerposition;wiederhole den 1., und falls notwendig, den 2. Schritt. Bei Beginn des 3.Schritts sind alle R-Bits der im Ring gespeicherten Seiten auf 0 gesetzt.Dieses Mal wird auf jeden Fall (im 1. Schritt oder spätestens im 2.Schritt) eine Seite für die Auslagerung identifiziert. Im Prinzip geht derAlgorithmus zyklisch durch die Menge der Seiten, um eine Seite, die nichtmodifiziert und in letzter Zeit nicht referenziert wurde.
• Weitere Strategien
– LIFO (last-in first-out): Verdrängen der jüngsten Seite, einfach zu implemen-tieren. Diese Strategie berücksichtigt Lokalitätseigenschaft von Programmen(häufig in Schleifen, Prozeduren⇒ Zugriff auf gleiche Seiten) nicht.
– LRU (Least recently used): Verdrängen der am längsten nicht genutzten Seite;wird am häufigsten realisiert, wobei LRU approximiert wird, da eine exakteRealisierung zu aufwendig ist. Eine exakte Realisierung ist durch spezielle
170
Schlichter, TU München 5.4. SEITENADRESSIERUNG
Hardware möglich, die jeder Seite ein Zeitfeld assoziiert und dieses beijedem Zugriff aktualisiert.
Frage: wie LRU-Verhalten approximierenAntwort: Nutzen eines Referenz-Bits (siehe r-Bit der Seitendeskriptor-Informationen) pro Seite, das durch Hardware bei einem Seitenzugriffgesetzt wird. Jeder Seite wird ein Zähler zugeordnet. Das BS inspiziertin regelmäßigen Abständen die Seiten, und inkrementiert den Zählerder Seiten mit nicht gesetztem Bit. Für jede referenzierte Seite werdendagegen Zähler und r-Bit gelöscht. Verdrängt wird immer die Seite mitdem höchsten Zählerstand, da diese am längsten nicht referenziert wurde.
– Working-Set ModellWorking-Set ist die Menge der Seiten, die ein Prozess zu einem bestimmtenZeitpunkt benutzt.
w(k,t) = Menge der Seiten, die zum Zeitpunkt t in den letzten kSpeicherzugriffen benutzt wurden. t ist hierbei als Position in derSeitenreferenzfolge zu interpretieren.die Zahl k kann dynamisch angepasst werden.
t kann hier als Position in der Seitenreferenzfolge interpretiert werden, undnicht als physikalische Zeit. Bei Windows XP wird für das Working Set einMinimum und Maximum spezifiziert; in der Regel ist das Minimum 35 unddas Maximum 345 Seiten.
∗ Verdrängungsstrategie: ersetze eine der Seiten, die nicht zum aktuellenWorking-Set gehören.∗ Verdrängung einer Seite notwendig, obwohl alle Seiten zu w(k,t) gehören:
verkleinere den Parameter kReduziere die Anzahl der Prozesse im Arbeitsspeicher ⇒ Auslagerneines Prozesses auf die Festplatte (Swapping).
∗ Working-Set kann nur näherungsweise über Zugriffsbits (r) und Verände-rungsbit (m) bestimmt werden.
– Optimale Strategie: Seite, auf die in Zukunft am längsten nicht zugegriffenwird. Die optimale Strategie ist unrealistisch, da das zukünftige Verhalteni.d.R. nicht bekannt ist. Leistungsdaten dieser Strategie, d.h. wievieleSeitenfehler treten bei gegebener Arbeitsspeichergröße und gegebenenZugriffscharakteristika von Prozessen auf, gibt Obergrenze für Erreichbaresan. Die Strategie ist gut für Vergleiche von Algorithmen, d.h. zurBestimmung der Güte eines Verfahrens.
171
Schlichter, TU München 5.4. SEITENADRESSIERUNG
Weitere offene Fragen
• Wahl einer vernünftigen SeitengrößeDie Wahl der Seitengröße steht unter widersprüchlichen Zielsetzungen; daherist ein Kompromiss erforderlich.
1. Je kleiner die Seite, desto rascher die Transfers zwischen ASP und Platte.2. Je kleiner die Seite, desto geringer der Verschnitt (interne Fragmentie-rung) durch nicht voll ausgenützte Seiten.3. Je größer die Seite, desto geringer der Overhead für Transport zwischenArbeitsspeicher und Platte pro Byte (Arm positionieren, Warten bis Spurunter Lese-Schreib-Kopf).4. Je größer die Seite, desto mehr Information kann zwischen Arbeitsspei-cher und Platte je Zeiteinheit transportiert werden.5. Je größer die Seite, desto seltener Transfers erforderlich.
– Beispiele für Seitengrößen: Intel 80386 4K, Pentium II 4K oder 4MB,UltraSPARC 8K, 64K, 512K oder 4MB. Tendenz: grössere Seiten. Warum?schnelle CPU und großer Arbeitsspeicher, Seitenfehler haben großenEinfluss auf Performanz des Rechensystems, deshalb möglichst wenige.
• SeitenflatternSeitenflattern (engl. thrashing) tritt auf, wenn im System zuviele Prozessesind, die nebenläufig voranschreiten wollen und Kacheln beanspruchen. Geradeverdrängte Seiten müssen zu schnell wieder eingelagert werden, das System istim schlimmsten Fall nur noch mit Ein- und Auslagern beschäftigt.
5.4.6 Linux - Virtuelle Adressierung
Das Speichermanagementsystem von Linux orientiert sich am Speichermanage-ment von anderen Unix Implementierungen. Linux hat jedoch einige spezielleCharakteristika. Die virtuelle Adressierung in Linux basiert auf mehrstufigen Sei-tentabellen
Seiten-Directory ("page directory"). Jeder aktive Prozess hat ein einzelnesSeiten-Directory, das jeweils im Arbeitsspeicher liegt. Einträge verweisen aufmittlere Seiten-Directories. Ein Seiten-Directory hat die Größe einer Seite.
mittleres Seiten-Directory ("page middle directory"). Es kann sich übermehrere Seiten erstrecken.
Seitentabelle ("page table").
172
Schlichter, TU München 5.4. SEITENADRESSIERUNG
Seiten Directory mittleres Directory Seitentabelle Offset
+
Register
Seiten-Directory+
mittleres Seiten-
Directory
+
Seitentabelle
+
Seite
Die Seitentabellenstruktur von Linux ist Plattform unabhängig; sie würdeursprünglich für die 64-bit Adresstruktur des Alpha Prozessors entwickelt. Fürdie 32-bit Pentium/x86 Architektur wird die 3-Stufen Struktur auf eine 2-StufenStruktur angepasst (x86 unterstützt nur zwei Stufen), in dem die Größe desmittleren Seiten Directories auf eins gesetzt wird.
• Seitenallokationaufeinanderfolgende Seiten werden auf zusammenhängende Kacheln abgebil-det. Auf diese Weise wird die Performanz beim Lesen und Schreiben von Seitenin bzw. aus dem Arbeitsspeicher erhöht.
Behandlung von Gruppen mit 1, 2, 4, 8, 16, oder 32 Seiten. Auf der x86-Architektur ist die Seitengröße 4 KBytes. Gruppen von Kacheln werdengemäß dem Buddy-System vergeben.
• SeitenverdrängungAnwendung eines modifizierten Clock-Algorithmus. Zugriffsbit r wird durcheinen 8-bit Zähler ersetzt.
bei jedem Zugriff wird der Zähler inkrementiert.Linux dekrementiert periodisch die Zähler aller Seiten im Arbeitsspeicher.
Linux scannt dazu periodisch durch alle Seiten, die im Arbeitsspeicher sind,und dekrementiert jeweils den Zähler. Auf eine Seite deren Zählerwert 0 ist,wurde seit einiger Zeit nicht mehr zugegriffen und sie wird als Kandidat fürdie Auslagerung betrachtet. Eine Seite, auf die in letzter Zeit öfters zugegriffenwurde, ist eher weniger eine Kandidat für die Auslagerung. Linux realisiert eineForm der LFU.
173
Schlichter, TU München 5.5. SEGMENT-SEITENADRESSIERUNG
5.5 Segment-Seitenadressierung
Unterteilung des Programmadressraums in logische Einheiten unterschiedlicherLänge, sogenannte Segmente. Ein Segment umfasst inhaltlich bzw. organisato-risch zusammengehörige Speicherbereiche, z.B. Daten, Code und Laufzeitkeller-Segment. Im Gegensatz dazu ist die Seiteneinteilung systembedingt und vomjeweiligen Programm unabhängig. Die Segmentunterteilung ist programmspezi-fisch.
• Jedes Segment besitzt eine maximale Größe. Die Länge der einzelnen Segmentekann unterschiedlich sein und sich dynamisch verändern.
• Jedes Segment wird durch einen Segment-Deskriptor beschrieben. DieSegmentdeskriptoren werden in einer Segmenttabelle verwaltet.
• Jedes Segment besteht aus Seiten, die jeweils beginnend mit Null fortlaufendnumeriert sind.
• Ein Zugriff auf ein nicht existentes Segment führt zum Speicherschutzalarm.
• Um in dieser Situation möglichst kompakte Speicherabbildungstabellen zuerhalten, wird die Seiten-Kacheltabelle aufgeteilt. ⇒ je Segment eineeigene Seiten-Kacheltabelle gehalten. Die (Maschinen-) Adressen der Seiten-Kacheltabellen werden in einer Segmenttabelle gehalten.
Segmenttabelle
s w
virtuelle Adresse k w
Adresse im
Arbeitsspeicher
0
sg
sg
+ k
Seiten-Kacheltabelle
+
Segmenttabellenregister
0
s
174
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
Bei der Adressierung der Tabellen muss natürlich jeder Index mit der Länge einesSeiten- bzw Segmentdeskriptors multipliziert werden. Falls ein Eintrag 4 Bytelang ist, ergibt sich damit z.B.
Adresse des Segmentdeskriptors =Wert Segmenttabellenregister + sg * 4.
Entsprechendes gilt auch für die Seiten-Kacheltabelle.
5.6 Speicherhierarchie / Caches
Einige fundamentale Eigenschaften von Hardware und Software
schnelle Speichertechnologien kosten mehr Geld pro Byte und haben kleinereKapazitäten.
Lücke zwischen CPU und Arbeitsspeichergeschwindigkeit wächst.
gut geschriebene Programme tendieren dazu, gute Lokalität zu habenzeitliche Lokalität: kürzlich referenzierte Objekte werden in naherZukunft wieder referenziert.räumliche Lokalität: Objekte mit beieinander liegenden Adressen,tendieren dazu, ungefähr zur gleichen Zeit referenziert zu werden.
Der Lokalitätseffekt wurde bereits beim Working-Set bzgl. der Verdrängung vonSeiten berücksichtigt.
5.6.1 Speicherhierarchie - Beispiel
175
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
Register
On-chip L1
cache
Off-chip L2
cache
Arbeitsspeicher
lokaler Hintergrundspeicher
(Festplatte)
entfernter Hintergrundspeicher
(entferntes Filesystem)
L0
L1
L2
L3
L4
L5
kleiner
schneller
teuerer
größer
langsamer
billiger
CPU Register enthält Wort geholt vom
Cache Speicher
enthält Cache Zeilen geholt vom
L2 cache
enthält Cache Zeilen geholt vom
Arbeitsspeicher
enthält Blöcke geholt vom
Hintergrundspeicher
enthält Dateien geholt von
entfernten Fileservern
5.6.2 Cache Speicher
Cache: Eine kleine, schnelle Speichereinheit, die als Bereitstellungsraum für eineTeilmenge der Daten von einer größeren, langsameren Einheit dient.
• Fundamentale Idee hinter der Speicherhierarchie:
für jedes k agiert die schnellere, kleinere Einheit auf Schicht k als Cachefür die größere, langsamere Einheit auf Schicht k+1
• Warum funktionieren Speicherhierarchien
Programme tendieren dazu auf Daten der Schicht k häufiger zuzugreifen,als auf Daten der Schicht k+1. Dies ist bedingt durch das Lokalitätsprinzip.
deshalb okay, wenn Speicher auf Schicht k+1 langsamer und preiswerterist.
5.6.3 Caching in der Speicherhierarchie
kleinere, schnellere, teuere Einheiten auf Schicht k cachen Daten von größeren,langsameren, preiswerteren Einheiten der Schicht k + 1.
176
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
4 9 10 3Schicht k
4
9 10
30 1 2
5 6 7
8 11
12 13 14 15
Schicht
k+1
Daten werden
blockweise kopiert
Teilmenge der Blöcke
der Schicht k+1
Einheiten der Schicht
k+1 sind in Blöcke
partitioniert
Programm braucht Objekt d in Block b
• Cache-Treffer (hit): Programm findet b im Cache der Schicht k, z.B. in Block10
• Cache-Fehler (miss): b ist nicht auf Schicht k; Cache muss b von Schicht k+1holen (z.B. Block 8).
wenn Schicht k Cache voll, muss ein Block entfernt werden, z.B. nach LRU.Dies ist vergleichbar mit der Verdrängung von Seiten.
– Typen von Cache ProblemenEs können unterschiedliche Arten von Problemen unterschieden werden:
∗ kalter Cache: der Cache ist leer∗ Kapazitätsfehler: resultieren daraus, dass die Summe der aktiven Cache
Blöcke größer ist als der Cache∗ Konfliktfehler
Caches limitieren meist Platzierungsmöglichkeiten der Blöcke derSchicht k+1 auf eine 1-elementige Teilmenge der Blöcke der Schichtk, d.h. die Blöcke von k+1 können nur an bestimmten Stellen im Cacheplatziert werden (nicht so bei der Seitenadressierung),z.B. Block i muss auf Block i mod 4 platziert werdenKonfliktfehler entstehen, wenn der Cache groß genug ist, aber mehrereDatenobjekte auf denselben Block der Schicht k abgebildet werden.z.B. Zugriff auf Blöcke 0, 8, 0,8, 0, 8, ... jedesmal ein Fehler
177
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
• Beispiele aus der Cache HierarchieCaches werden auf unterschiedlichen Ebenen in modernen Rechensystemengenutzt.
Cache Typ was wird geca-ched
wo wird geca-ched
kontrolliert
Register 4 Byte Wort CPU Register CompilerTLB Address Transla-
tionOn-Chip TLB Hardware
L1 Cache 32 Byte Block On-Chip L1 HardwareL2 Cache 32 Byte Block Off-Chip L2 Hardwarevirtual memory 4 KB page Arbeitsspeicher Hardware + BSbuffer cache Teile von Datei-
enArbeitsspeicher BS
network buffercache
Teile von Datei-en
lokale Platte NFS client
Browser cache Web Seiten lokale Platte Web BrowserWeb cache Web Seiten entfernte Server
PlatteWeb Proxy Ser-ver
TLB ist der Translation Lookaside Buffer zur Beschleunigung der Abbildungvon virtuellen Addressen auf Maschinenadressen.
5.6.4 Realisierung von Caches
Obwohl je nach der Ebene der Cache Hierarchie unterschiedliche Varianten derUmsetzung existieren, folgen diese doch gemeinsamen allgemeinen Prinzipien.
• Allgemeine Cache OrganisationAngenommen, das Rechensystem hat Arbeitsspeicheradressen mit m bits⇒M= 2m eindeutige Adressen.
Cache ist ein Array von Mengen (S = Anzahl von Mengen).
jede Menge enthält eine oder mehrere Reihen (E = Anzahl von Reihen proMenge).
jede Reihe enthält einen Datenblock (B ist Blockgröße pro Reihe).
Cachegröße = B * E * S Bytes. Die Blockgröße ändert sich je nach Ebene inder Speicherhierarchie. Je weiter oben in der Hierarchie, desto kleiner sind dieBlöcke.
178
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
valid tag 0 B-11
valid 0 B-11
set 0
1-gültig Bit
pro Reihe
t tagbits
pro Reihe
tag
E Reihen
pro Menge
valid tag 0 B-11
valid 0 B-11
set 1
tag
valid tag 0 B-11
valid 0 B-11
set s-1
tag
S
Mengen
B = 2b Bytes pro
Cache Block
• Adressierung von CachesDie Cache Organisation bedingt eine Strukturierung der Speicheradresse
das Wort an Adresse A ist im Cache, falls die Tagbits einer der gültigenReihen der Menge "set Index" den Tag "tag" besitzen
der Wortinhalt beginnt am Offset "block offset" Bytes vom Blockanfang
179
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
valid tag 0 B-11
valid 0 B-11
set 0
tag
valid tag 0 B-11
valid 0 B-11
set 1
tag
valid tag 0 B-11
valid 0 B-11
set s-1
tag
t bits s bits b bitsAdresse A
tag set Index block offset
Angenommen, wir haben ein System mit CPU, Registern, L1 Cache undArbeitsspeicher. Die CPU führt einen Befehle aus, der auf das Speicherwortw zugreift. w wird vom L1 Cache angefordert. Falls w im L1 Cache vorhandenist (Cache Hit), wird w unmittelbar an CPU ausgeliefert. Ansonsten haben wireinen Cache Miss und die CPU wartet, bis der L1 Cache den Block, der dasSpeicherwort w beinhaltet, vom Arbeitsspeicher angefordert und ausgeliefertbekommen hat. Der Block mit w wird im L1 Cache gespeichert und w wird andie CPU ausgeliefert. Damit ergibt sich die Folge CPU⇒ L1 Cache⇒ ASP.
• Direct-Mapped CacheEinfachste Art des Caches mit genau einer Reihe pro Menge; Zugriff erfolgt inder Reihenfolge
Mengenselektion: Benutzung der "set Index" bits zum Bestimmen derrelevanten Menge.
Reihenabgleich: Finden der gültigen Reihe in der selektierten Menge mitdem richtigen Tag. Da pro Menge nur eine Reihe vorhanden ist, müssennur die Tagbits der vorhandenen Reihe mit den Tagbits der Adresseauf Übereinstimmung verglichen werden. Es ist keine Durchsuchung derausgewählte Menge notwendig. Weiterhin muss das "Valid" Bit gesetztsein, um anzuzeigen, dass die Reihe gültig ist.
180
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
Wortselektion: Benutzung des block offsets zum Bestimmen des relevantenWortes.
set 0
1set 1 0110
set s-1
w0 w2w1 w3
0 1 2 3 5 6 7
0110 00001 100
tag set Index block offset
= ?
3
1
2
Falls Mengenselektion und Reihenabgleich erfolgreich sind und das Gültigbitgesetzt ist, befindet sich das gewünschte Wort im Cache. Mit Hilfe vonBlockoffset wird das erste Byte des gewünschten Wortes im Cache angesteuert.
• Mengen Assoziativer CacheMehr als eine Reihe pro Menge, d.h. E > 1;
Mengenselektion: identisch zu direct-mapped Cache.
Reihenabgleich: Vergleich der Tags für jede gültige Reihe in derselektierten Menge. Es werden nur die Reihen mit gesetztem Valid Bitanalysiert.
Wortselektion: identisch zu direct-mapped Cache.
set 0
1
set 1
0110
set s-1
w0 w2w1 w3
0 1 2 3 5 6 7
0110 00001 100
tag set Index block offset
= ?
3
1
2
1 1001
Falls Mengenselektion und Reihenabgleich erfolgreich sind und das Gültigbitgesetzt ist, befindet sich das gewünschte Wort im Cache. Mit Hilfe vonBlockoffset wird das erste Byte des gewünschten Wortes im Cache angesteuert.
181
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
Daneben gibt es noch einen voll assoziativen Cache (fully assoziative), dernur aus einer Menge besteht, die alle Cache Reihen aufnimmt. In diesemFall entfällt die Mengenselektion und es werden nur gültige Reihen auf ihreÜbereinstimmung mit den Tagbits überprüft. Voll assoziative Caches sind nurfür sehr kleine Caches geeignet, z.B. Translation Lookaside Buffer (TLB) imvirtuellen Speicher, der Einträge in der Seitenkacheltabelle cached.
5.6.5 Cache freundlicher Code
Die Performanz eines Caches wird anhand der auftretenden Cache Misses undCache Hits gemessen. Die Fehlerrate ist der Bruchteil der Speicherzugriffe, dienicht durch den Cache erfüllt werden können, und somit zu einem Nachladeneines neuen Blocks in den Cache erfordern.
Fehlerrate = #Cache Misses / # Speicherzugriffe
Neben der Cache Größe und der Blockgröße in den Reihen kann diePerformanz eines Caches durch Cache freundliche Programmierung beeinflusstwerden. Beispielsweise bei einer Matrixmultiplikation kann durch eine günstigeZugriffsreihenfolge auf die Elemente die Fehlerrate niedrig gehalten werden.
Beispiel: Summe einer Matrix
Betrachten wir 4-Byte Worte. Weiterhin umfasse der Cache nur eine Menge mitgenau einer Reihe.
Ein Cacheblock der Reihe umfasse vier 4-Byte Worte.pro Matrixelement (vom Typ int) ist ein Wort (d.h. 4 Bytes) notwendig.die Matrix a[M, N] sei zeilenweise im Speicher abgelegt und passt nichtvollständig in den Cache. D.h. zunächst alle Elemente der ersten Zeile,dann die der zweiten Zeile usw. Neben der Summenbildung könnte auchdie Multiplikation zweier Matrizen und die Speicherung der Ergebnisse ineiner dritten Matrix eindrucksvoll die unterschiedlichen Fehlerraten je nachder Anordnung der Laufschleifen demonstrieren.
• Zeilenweises Aufsummierenint i, j, sum = 0;for (i = 0; i < M; i++)
for (j = 0; j < N; j++) sum += a[i][j]return sumFehlerrate der inneren Schleife = 1/4 = 25%. Ausgangspunkt ist ein leererCache. Der Zugriff a[0, 0] führt zum Laden eine Blocks mit den ersten 4
182
Schlichter, TU München 5.6. SPEICHERHIERARCHIE / CACHES
Matrixelementen der 0-ten Zeile in den Cache. Die nachfolgenden Zugriffe aufa[0, 1], a[0, 2] und a[0, 3] können durch den Cache befriedigt werden. Erst derZugriff auf a[0, 4] führt einem Laden eines neuen Blocks in den Cache.
• Spaltenweises Aufsummierenint i, j, sum = 0;for (j = 0; j < N; j++)
for (i = 0; i < M; i++) sum += a[i][j]return sumFehlerrate der inneren Schleife = 100%. Beim Zugriff von a[0, 0] werden dieersten 4 Elemente der ersten Zeile in den Cache geholt. Als nächstes Element inder inneren Schleife wird a[1, 0] benötigt, was jedoch nicht im Cache ist. JederZugriff auf eine Matrixelement in der inneren Schleife führt zu einem CacheMiss.
183
Kapitel 6
Prozesskommunikation
Disjunkte Prozesse, d.h. Prozesse, die völlig isoliert voneinander ablaufen, stelleneher die Ausnahme dar. Häufig finden Wechselwirkungen zwischen den Prozessenstatt ⇒ Prozesse interagieren. Die Unterstützung der Prozessinteraktion stellteinen unverzichtbaren Dienst dar. Betrachtet man diese Prozesswechselwirkungen
1 genauer, dann lassen sich 2 grundlegende Interaktionsmuster unterscheiden:Konkurrenz und Kooperation. Eine Konkurrenzsituation liegt vor, wenn sichProzesse gleichzeitig um ein exklusiv benutzbares Betriebsmittel bewerben⇒ Prozesssynchronisation. Bei Prozesskooperation geht es darum, dass diebeteiligten Prozesse gezielt Informationen untereinander austauschen.
6.1 Fragestellungen
Dieser Abschnitt beschäftigt sich mit den Mechanismen von Rechensystemenzum Austausch von Informationen zwischen Prozessen.
• Kommunikationsarten.
• nachrichtenbasierte Kommunikation, insbesondere Client-Server-Modell. Diespeicherbasierte Kommunikation, d.h. über gemeinsame Speicherbereiche,wurde bereits im Zusammenhang mit→ Synchronisation (siehe Seite 81) undSemaphoren behandelt.
• Netzwerkprogrammierung auf der Basis von Ports und Sockets.
1[nehmer2001 S32]
184
Schlichter, TU München 6.2. EINFÜHRUNG
6.2 Einführung
Prozessinteraktion kann Rechner-lokal und Rechner-übergreifend stattfinden.Prozesse können auf vielfältige Weise Informationen austauschen.
6.2.1 Kommunikationsarten
Prozesskommunikation
breitbandig schmalbandig
Ereignisse
Alarme
Signale
implizitexplizit
asnychron
explizit
snychron
1 : 1
n : 1
1 : m
n : m
1 : 1
1 : m
n : m
Ströme
RPC
RMI
Die Bandbreite des Kommunikationskanals bestimmt die Datenrate, in der Datenzwischen Prozessen ausgetauscht werden können. Breit- bzw. schmalbandigbezieht sich hier auf die Menge der ausgetauschten Information und nichtauf die Bandbreite des darunterliegenden Kommunikationsnetzes. n:1 wird beiexplizit synchroner Kommunikation nicht separat aufgeführt; es ist im Grunde einSpezialfall von n:m. .
Ströme wurden asynchron realisiert. Während bei der Art n:m (bzw. 1:1, 1:n,n:1) die einzelne Nachricht im Vordergrund steht, geht es bei Ströme umdie Übermittlung eines Daten-/Zeichenstroms. Der Sender kann in mehrerenOperationen Zeichen auf den Strom legen (jeweils eine Menge an Zeichen,die unterschiedlich sein kann). Diese Grenzen sind für den Empfängernicht mehr ersichtlich; er erhält nur eine Sequenz an Zeichen. Strömewerden typischerweise als asynchroner Nachrichtenaustausch auf Ebene derNetzprotokolle realisiert
185
Schlichter, TU München 6.2. EINFÜHRUNG
Schmalbandige Kanäle
Schmalbandige Kanäle werden im Betriebssystem zum Melden von Ereignissenoder für die Synchronisation unterstützt. Übertragung von wenigen Bits anInformation, z.B. Setzen von Flags
• Dienste des Betriebssystems
Melden von Ereignissen,Warten auf Ereignisse,Ereignisverwaltung.
Unterbrechungsereignisse und deren Verwaltung in einem Betriebssystemwurden bereits eingeführt.
• Beim Ablauf von Prozessen können Alarme entstehen (z.B. arithmetische Alar-me). Da das BS keine genauen Kenntnisse über den internen Berechnungszu-stand eines Prozesses besitzt, kann man mit den allgemeinen Standardalarmbe-handlungen des BS einen Prozess höchstens abbrechen. Es ist somit sinnvoll,die Alarmbehandlung dem Prozess selber zu überlassen.
• Die Alarme werden über Namen identifiziert, die im BS vereinbart sind. DasBS stellt Dienste zur Zustellung von Alarmen zur Verfügung. Bemerkung:schmalbandige Informationskanäle sind für den Bereich der Datensicherheitproblematisch, da sie schwierig zu beherrschen sind. Über diese Kanäle könnensich Angreifer Informationen über das System beschaffen und ausnutzen.Beispiel: Einloggen unter Solaris 7.0 liefert bereits nach Eingabe der KennungInformationen, dass diese Kennung korrekt ist. Lässt sich für einen Passwort-Cracking-Angriff ausnutzen.
Im folgenden werden wir uns vertiefend mit breitbandigen Kommunikations-formen beschäftigen, und zwar nicht nur im lokalen Bereich, sondern auch imverteilten Bereich.
Implizite Kommunikation
Implizite Kommunikation ist eine breitbandige Kommunikationsform. DieKommunikation erfolgt über einen gemeinsamen Speicher (Dateien, Register,Datenstrukturen). Ein Beispiel dafür sind Pipes in Unix.
• Die Kommunikation findet ohne direkte Unterstützung und ohne Kenntnis desBS statt.
• Vorteil: einfach und schnell (kein Kopieren zwischen Adressräumen).
186
Schlichter, TU München 6.2. EINFÜHRUNG
• Nachteil:
a) gemeinsame Bereiche sind nicht immer vorhanden: z.B. in physischverteilten, vernetzten Systemen gibt es i.d.R. keinen gemeinsamenSpeicher. Eine Ausnahme bilden sogenannte DSM (Distributed SharedMemory) Realisierungen.b) gegebenenfalls aufwendiges busy waiting⇒Mischform: Ereigniszustel-lung, d.h. schmalbandige Kommunikation, die das Vorhandensein von Da-ten signalisiert.
• Implizite KommunikationsformenVerschiedene Formen der impliziten Kommunikation
1:1 ein Puffer pro Sender/Empfänger-Paarn:1 n Sender senden Nachrichten an einen Empfänger, z.B.
Sender: Prozesse senden DruckaufträgeEmpfänger: Drucker-Server
1:m Mitteilung an alle Prozesse (Broadcast, Multicast);
Broadcast: z.B. Erfragen, wo ein spezieller Dienst angeboten wird;Shutdown Message an alle Rechner.
Multicast: z.B. Nachricht an Gruppe gleichartiger Server. Broadcast undMulticast ist in lokalen Netzen mit busartigen Medien (z.B. Ethernet)sehr einfach zu realisieren; dort hören alle angeschlossenen Rechner dasMedium ab.
n:m n Erzeuger schreiben in Puffer und m Verbraucher lesen aus Puffer.
n:m Kommunikationsform ist beispielsweise sinnvoll, wenn eine Mengegleichartiger Dienste zur Verfügung steht, und ein Auftrag von einembeliebigen dieser Dienstanbieter erledigt werden kann.
187
Schlichter, TU München 6.2. EINFÜHRUNG
prozess-
spezifischer
oder
zentraler
Puffer
S1
E1
1:1 Kommunikation
Si i-ter SenderprozessEi i-ter Empfängerprozess
prozess-
spezifischer
oder
zentraler
Puffer
S1
E1
n:1 Kommunikation
Sn
Briefkasten
(mail box)
S1
n:m Kommunikation
Sn
E1 Em
Explizite Kommunikation
Diese Kommunikationsart wird realisiert durch den Austausch von Nachrichten("message passing") ⇒ nachrichtenbasierte Kommunikation. Die Nachrichten-kommunikation ist immer dann die geeignete Kommunikationsform, wenn diebeteiligten Prozesse in disjunkten Adressräumen liegen, und damit keine Mög-lichkeit haben, auf einen gemeinsamen Speicher zuzugreifen.
• Betriebssystem enthält einen Nachrichtendienst ND (das Kommunikationssy-stem), der den Austausch der Nachrichten zwischen Prozessen realisiert. NDunterstützt 2 Systemdienste:
send (E: process, m: message)receive (S: process, m: message)
Mittels send wird eine Nachricht m für den Empfänger E an denNachrichtendienst ND übergeben. Mit receive entnimmt ein Empfänger E dieNachricht m, die vom Sender S gesandt wurde, von ND. Der Absender wirdgewöhnlich in der Nachricht m codiert.
• prinzipieller AblaufDer Nachrichtendienst ND ist meist Teil des Betriebssystemkerns.
188
Schlichter, TU München 6.2. EINFÜHRUNG
Sende
prozess S
Nachrichten
dienst ND
Empfänger
prozess E
Nachricht m Nachricht m
send receive
Falls die Prozesse auf unterschiedlichen Rechnern sind, sind die Nachrichten-dienste der beteiligten Betriebssysteme involviert. In diesem Fall findet eineKommunikation zwischen den beiden Nachrichtendiensten statt.
• Aufbau einer NachrichtEine Nachricht besteht aus 2 grundlegenden Komponenten:
Nachrichtenkopf: Verkehrsinformation, z.B. Sender- undEmpfängeridentifikationNachrichteninhalt: Nutzlast (payload)
• explizite Kommunikation ist besonders geeignet in verteilten, vernetzten Syste-men. Die nachfolgenden Abschnitte werden sich mit der nachrichtenbasiertenKommunikation, insbesondere in verteilten Systemen beschäftigen.
6.2.2 Verteilte Systeme
Bisher haben wir uns mit systemnahen Konzepten von zentralen Systemenbeschäftigt. Seit Ende der 80er Jahre haben jedoch verteilte Systeme rapide anBedeutung gewonnen. Die Verteilung bezieht sich sowohl auf die Verteilungvon Hardwarekomponenten (Rechner, Peripherie), als auch auf die Verteilungvon Daten und Verarbeitung. Im letzteren Fall spricht man von einer verteiltenAnwendung, d.h. eine Anwendung besteht aus mehreren kooperierendenTeilkomponenten, die auf verschiedenen Rechnern ausgeführt werden.
• Ansätze zur Kopplung von Recheneinheiten
Vielfach CPU-
Systeme
Multiprozessoren Multicomputer verteiltes System
eng gekoppelt lose gekoppelt
189
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Multiprozessor Multicomputer verteiltes SystemKonfiguration nur CPU CPU, Ar-
beitsspeicher,Netzschnittstelle
kompletterRechner
Peripherie gemeinsam gemeinsam, au-ßer Festplatte
getrennt
Ort gemeinsamesGehäuse
gemeinsamerRaum
weltweit verteilt
Kommunikation gemeinsamerArbeitsspeicher
direkte Verbin-dung
Netzwerk
Betriebssystem ein gemeinsamesBS
getrennt, jedochgleicher Typ
getrennt, viel-fach unterschied-lich
Verwaltung eine Organisati-on
eine Organisati-on
viele Organisa-tionen
Die Einteilung in Multicomputer oder verteiltes System hängt etwas von derverwendeten Betrachtungsweise ab.
6.3 Nachrichtenbasierte Kommunikation
Bei nachrichtenbasierter Prozessinteraktion tauschen Prozesse gezielt Informatio-nen durch Verschicken und Empfangen von Nachrichten aus; ein Kommunikati-onssystem unterstützt an der Schnittstelle wenigstens die Funktionen send undreceive. Nachrichtenkommunikation ist die natürliche Form der Prozessinterak-tion in Rechnernetzen. Prozesse, die auf verschiedenen Rechnerknoten platziertsind, müssen ein physisches Übertragungssystem benutzen, um miteinander inKontakt zu treten.
6.3.1 Elementare Kommunikationsmodelle
Klassifikationsschema für die Nachrichtenkommunikation anhand von 2 Dimen-sionen:
generelles Muster der Nachrichtenkommunikation.
zeitliche Kopplung der beteiligten Prozesse.
190
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Klassifikationsschema
• Elementare Kommunikationsmuster sind Meldung ("signal") und Auftrag("request").
Meldung: Einweg Nachricht vom Sender zum Empfänger (unidirektional).Die entsprechende Nachrichtentransaktion beginnt mit dem Versendender Nachricht und endet mit der Übergabe an den Empfänger. Zu einerMeldung gehört nicht die anschließende Verarbeitung der Nachricht durchden Empfänger.
Auftrag: Zweiweg Nachricht zwischen Sender und Empfänger (bidirektio-nal). Sie beginnt mit dem Versenden eines Auftrags an den Empfänger undendet mit der Übergabe einer Erfolgsbestätigung über den durchgeführ-ten Auftrag an den Sender. "Dazwischen liegt die Auftragsbearbeitung aufEmpfängerseite, die weitere Nachrichten zur Übertragung der Eingabepara-meter bzw. zur Rückübertragung des Resultates auslösen kann. Im einfach-sten Fall genügen für einen Auftrag 2 Nachrichten: die Auftragsnachrichtund die Resultatnachricht, die gleichzeitig als Quittung dient. AusbleibendeQuittungen können mittels Timeouts erkannt werden; sie sind gleichbedeu-tend mit negativen Quittungen, die auf Senderseite als nicht durchgeführterAuftrag interpretiert wird."
• Synchronität definiert den Kopplungsgrad zwischen Prozessen bei derDurchführung einer Nachrichtentransaktion:
asynchron: Entkopplung des Senders und Empfängers. "Dies bedeutet,dass ein Sender Nachrichtentransaktionen in schnellerer Folge für einenEmpfänger erzeugen kann, als dieser in der Lage ist, sie zu bearbeiten.Asynchrone Nachrichtenübertragung erfordert deshalb die Pufferung vonNachrichten auf dem Übertragungswege zwischen Sender und Empfänger.Parallelarbeit ist möglich."
synchron: beide Prozesse werden zur Nachrichtenübertragungsynchronisiert.
191
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Es ist auch möglich das Merkmal Synchronität nicht auf die Nachrichtentrans-aktion, sondern getrennt auf Sender und Empfänger anzuwenden. Damit las-sen sich asynchrone und synchrone Formen des Nachrichtenversands und -empfangs beliebig kombinieren.
Meldung
• Asynchrone MeldungSender wird lediglich bis zur Ablieferung der Meldung an das Nachrichtensy-stem (Kommunikationssystem) blockiert.
Sender S Nachrichtendienst ND Empfänger E
Zeit
send
receive
Meldung
– Nachrichtendienst des Betriebssystems puffert Nachricht;Sender S kann seine Ausführung fortsetzen, sobald Nachricht N in denNachrichtenpuffer des ND eingetragen ist.S wartet nicht, bis E die Nachricht empfangen hat.
– Empfänger E zeigt durch receive an, dass er am Empfang der Nachricht Ninteressiert ist.
Empfänger wird blockiert, bis Sender Nachricht bereit stellt.
• Synchrone MeldungSender und Empfänger von Meldungen sind zeitlich gekoppelt.
192
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Sender S Nachrichtendienst ND Empfänger E
Zeit
send
receive
Meldung
Quittung
Über die Ablieferung der Nachricht wird der Sender durch eine Quittungsnach-richt informiert, die zur Aufhebung der Blockade des Senders führt.
– Rendezvous-Technik: Sender und Empfänger stellen vor Austausch dereigentlichen Meldung die Sende- und Empfangsbereitschaft her. In diesemFall braucht die Nachricht nirgends gepuffert werden, sondern sie kann direktvom Adressraum des Senders in den Adressraum des Empfängers übertragenwerden. Das Erreichen des Rendezvous-Punktes definiert den Zeitpunkt, zudem Sender- und Empfängerseite wechselseitiges Einverständnis über dasVorliegen der Sende- und Empfangsbereitschaft erklärt haben.
Auftrag
• Synchroner AuftragBearbeitung der Nachricht durch Empfänger und Senden der Resultatnachrichtsind Teil der Nachrichtentransaktion.
193
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Sender S Nachrichtendienst ND Empfänger E
Zeit
send receiveAuftrag
Resultat
Auftrags
bearbeitung
reply
Synchrone Aufträge schränken die Parallelarbeit zwischen Sender und Emp-fänger noch stärker ein als synchrone Meldungen, da die zeitliche Kopplungauch die Bearbeitung der Nachricht umfasst. Diese Kommunikationsform wirdgerade im Zusammenhang mit dem Client-Server Modell sehr oft verwendet.Das RPC-Konzept ("Remote Procedure Call") ist eine sprachbasierte Varianteder synchronen, auftragsorientierten Kommunikation.
• Asynchroner AuftragAuftrag und Resultat werden als Paar unabhängiger Meldungen verschickt.
194
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Sender S Nachrichtendienst ND Empfänger E
Zeit
send receiveAuftrag
Resultat
Auftrags
bearbeitung
replyreceive
result
Zwischen send und receive result kann der Sender u.U. noch weitereAufträge versenden (an den gleichen oder andere Empfänger).
Vorteile/Nachteile asynchrones Senden
• Vorteile asynchrones Senden
– nützlich für Realzeitanwendungen. Speziell in Situationen, bei denensendender Prozess nicht blockiert werden darf.
– ermöglicht parallele Abarbeitung durch Sender und Empfänger.
– anwendbar zum Signalisieren von Ereignissen.
• Nachteile asynchrones Senden
– Verwaltung des Nachrichtenpuffers durch BS erforderlich. Überlauf desPuffers, Zugriffsprobleme, Absturz von Prozessen.
– Benachrichtigung des Senders S im Fehlerfall und Behandlung von Fehlernist problematisch. Warum: Sender hat weitergearbeitet, gegebenenfallsbereits terminiert; Nachricht kann u.U. nicht mehr wiederholt werden. EinZurücksetzen der Prozesse kann zum Dominoeffekt führen, da Empfängervon Nachrichten selbst wieder zum Sender geworden sein können.
195
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
– Entwurf und Nachweis der Korrektheit des Systems ist schwierig. Auftretenvon Fehlern abhängig von Pufferinhalten und dem Zeitverhalten desverteilten Systems (Last des Kommunikationssystems).
6.3.2 Erzeuger-Verbraucher Problem
Auf der Basis der nachrichtenbasierten Kommunikation wird das Erzeuger-Verbraucher Problem mit Hilfe von send und receive Operationen realisiert.
Erzeuger S:while (true) {
produziere Dateneinheit;send (E, Dateneinheit);
}
Verbraucher E:while (true) {
receive (S, Dateneinheit);verbrauche Dateneinheit;
}Es existiert kein gemeinsamer Speicherbereich, der bzgl. der Zugriffe vonErzeuger und Verbraucher synchroniert werden muss. Die Synchronisation vonErzeuger und Verbraucher erfolgt durch das Kommunikationssystem selbst. Essind keine Semaphore notwendig.
6.3.3 Modellierung durch ein Petrinetz
Petri-Netze dienen häufig zur Modellierung von Kommunikationsabläufen,sogenannten Kommunikationsprotokollen. Sie ermöglichen die Analyse derProtokolle, z.B. Erkennung von Verklemmungen. Modellierung einer synchronenKommunikation:
196
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Prozess 1
Sendebereit
send
message
receive
messagebuffer full
Prozess 2wait
for
ack.message
received
buffer full
receive
ack.send
ack.
ack. received ack. sent
Problem: unendliches Warten
Dies trifft auf, wenn das Acknowledgement nicht gesendet wird oder verlorengeht. Pragmatische Lösung mit Hilfe von Timeouts
• Sender bzw. Empfänger warten nur eine festgelegte Zeit, Sender: falls keinAcknowledgement (Quittung) eintrifft, z.B. erneutes Senden.
• Probleme dabei? u.a. Duplikate müssen vom Empfänger erkannt werden;gesendete Nachrichten kommen zu spät an, sind veraltet etc. Gleiche Problemeauch in Rechnernetzen: dafür gibt es Protokolle, die die Abläufe genau regeln.Sequenznummern können als Nachrichtenidentifikatoren dienen.
6.3.4 Ports
Bisher wurde davon ausgegangen, dass ein Prozess eine Nachricht mittelsreceive in seinen Adressraum entgegennehmen kann. Dazu wurde jedemProzess ein eigener Nachrichtenpuffer für neu eingetroffene, jedoch noch nichtabgelieferte Nachrichten zugeordnet. Bisher bestand zwischen Sender undEmpfänger eine feste Beziehung, die über Prozessidentifikatoren (z.B. Namenoder Nummer) hergestellt wurde. Nachteile
197
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Prozessnummern ändern sich mit jedem Neustart.Prozessnamen sind nicht eindeutig, z.B. falls Programm mehrmals gestartetwurde.
⇒ Deshalb Senden von Nachrichten an Ports. Sie stellen Endpunkte einerKommunikation dar. Sie können bei Bedarf dynamisch eingerichtet und gelöschtwerden. Dazu existieren folgende Funktionen:
portID = createPort();deletePort(portID);send(E.portID, message);receive(portID, message);Mittels createPort wird ein neuer Kommunikationsendpunkt eingerichtet undmit dem Adressraum des Prozesses (z.B. Empfänger E) verbunden. AndereProzesse, z.B. Sender S, kann nun Nachrichten an den Port des Empfängerssenden. Die receive Operation benötigt nun den Parameter portID zurSelektion des Ports. Ports sind eine logische Abstraktion der Adressräume; sierepräsentieren keine physischen Ports (z.B. serieller oder paralleler Anschluss).
Der Port agiert hier wie eine Warteschlange für den Empfänger E; dieAuslieferung der Nachricht kann willkürlich, festgelegt durch die Reihenfolgedes Eintreffens der Nachrichten, oder festgelegt durch die Nachrichtenprioritätenerfolgen.
• ein Port ist mit dem Adressraum des zugehörigen Prozesses verbunden.
• der Empfängerprozess kann sender-spezifische Ports einrichten. Jedem Portkann ein eigener Thread zugeordnet werden, der die Nachrichten an diesenPort bearbeitet. Im Ruhezustand ist kein Port eingerichtet, d.h. der Empfängerkann nur über den fest mit seinem Adressraum assoziierten Nachrichtenpufferangesprochen werden.
• ein Rechner mit einer IP-Adresse unterstützt mehrere tausend Ports. Für dasTCP-Protokoll sind es 65 535 unterstützte Ports.
• der Name des Ports ist für einen Rechner eindeutig. Ein Betriebssystemverwaltet eine bestimmte Anzahl von Ports, die es entweder fest oderdynamisch verschiedenen Protokollen bzw. deren zugehörigen Applikationenzuordnen kann.
• die Portnummern 1 - 1023 sind fest reserviert für bestimmte Protokolle (bzw.deren Applikationen).
• Übersicht: fest zugeordnete Ports
198
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
Protokoll Port BeschreibungFTP 21 Kommandos für Dateitransfer (get, put)Telnet 23 interaktive Terminal-Sitzung mit entfern-
tem RechnerSMTP 25 Senden von Email zwischen Rechnerntime 37 Time-Server liefert aktuelle Zeitfinger 79 liefert Informationen über einen BenutzerHTTP 80 Protokoll des World Wide WebPOP3 110 Zugang zu Email durch einen sporadisch
verbundenen ClientRMI 1099 Zugang zum Registrieren von entfernten
Java Objekten.Offene Ports sind ein Sicherheitsrisiko, da darüber von außen Angriffe gestartetwerden können. Deshalb gehen Betriebssystemhersteller den Weg, dass nurdiejenigen Ports aktiviert sind, die für den aktuellen Betrieb notwendig sind.Nutzer müssen Ports meist manuell aktivieren. Bemerkung: breitbandige,verbindungsorientierte Kommunikation kann auch für Angriffe in vernetztenSystemen ausgenutzt werden. Ein Beispiel aus der Vergangenheit: Angriffeauf Yahoo und amazon.com. Aufbau einer Vielzahl Port-Verbindungen,Übertragung großer Datenmengen (1 GB) führte zum Lahmlegen des Dienstes("Denial of Service").
6.3.5 Kanäle
Bisher wurde von einer verbindungslosen Kommunikation ausgegangen, d.h. eineNachricht kann an einen Port geschickt werden. Bei einer verbindungsorientiertenKommunikation muss zuerst eine logische Verbindung zwischen den Kommuni-kationspartner eingerichtet werden⇒ Kanal ("socket").
• Einrichtung eines Kanals zwischen Ports, d.h. Verknüpfen zweier Ports.
• bidirektionale Übertragung über Kanäle. Ports sind nicht mehr nur Empfangs-stellen für Nachrichten, sondern sie dienen auch als Quellen. Damit sind kom-plexere Auftragsbeziehungen zwischen den Kommunikationspartnern möglich.Beispielsweise müssen nicht alle benötigten Daten in der Auftragsnachrichtmitgeschickt werden, sondern sie können bei Bedarf vom beauftragten Prozessangefordert werden.
• Die Sende- bzw. Empfangsoperation bezieht sich auf die lokale PortID;
199
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
send(local portID, message);receive(local portID, message);
• TCP/IP unterstützt verbindungsorientierte Kommunikation.
6.3.6 Ströme
Ströme (engl. streams) sind eine Abstraktion von Kanälen. Sie verdecken dietatsächlichen Nachrichtengrenzen. Ein Sender schickt mittels send-OperationenNachrichten an den Empfänger. Die Nachrichten werden jedoch logisch zueinem Bytestrom vereinigt, dem man auf Empfangsseite die Nachrichtengrenzennicht mehr entnehmen kann. Der Empfänger kann den Bytestrom in Portionenverarbeiten, ohne sich an den ursprünglichen Nachrichtengrenzen zu orientieren.
Sender
Empfänger
Strom
1 Byte
send (120 Bytes)
send (74 Bytes)
send (233 Bytes)
receive (50 Bytes)
receive (377 Bytes)
• BS-Dienste: Verbindungsauf- und -abbau, schreiben in Strom, lesen aus Strom.
• Dienste für Dateizugriffe oder Zugriffe auf Geräte: spezielle Ausprägung derstromorientierten Kommunikation.
• I/O in Java basiert auf Ströme.
Klasse java.io.OutputStream zum Schreiben von DatenKlasse java.io.InputStream zum Lesen von Daten
Spezialisierungen z.B. durch FileOutputStream, BufferedOutputStream oderFileInputStream.
6.3.7 Pipes
Realisierung von Strömen über Pipe-Konzept (z.B. in Unix, Windows); Stromzwischen 2 Kommunikationspartnern
unidirektional
200
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
FIFO-artiger Datentransfer mit Operationen: open pipe, read, write. DieOperationen werden über Systemaufrufe realisiert.
gepuffert und zuverlässig.
Pipes können als Dateien ohne Plattenbeteiligung betrachtet werden.
Prozess 1 Prozess 2
Schreiben Lesen
Ordnung der Zeichen bleibt erhalten (Zeichenstrom)Blockieren bei voller Pipe (write) und leerer Pipe (read)
• Beispiele für Unix Pipes
ls -l | headgrep "name" datei.txt | sort | morecat datei.txt | awk ’{print $1}’ | more
• Prinzipieller AufbauDer pipe-Systemaufruf erzeugt ein i-node Objekt sowie 2 File-Objekte. Damitkönnen Prozesse mit read() und write() Systemaufrufen darauf zugreifen. DerAufbau orientiert sich an Linux.
struct pipe_inode_info {wait_queue_head_t wait; /* Warteschlange blockierterProzesse, die auf Pipe zugreifen wollen */char *base; /* Adresse des Kernel Buffers */unsigned int len; /* Anzahl geschriebener, aber noch nichtgelesener Bytes */unsigned int start; /* Leseposition im Buffer */unsigned int readers; /* Anzahl lesender Prozesse */unsigned int writers; /* Anzahl schreibender Prozesse */unsigned int waiting_writers;unsigned int r_counter; /* Anzahl der Prozesse, die aufneue Zeichen in der Pipe warten */unsigned int w_counter; /* Anzahl der Prozesse, dieZeichen in die Pipe schreiben möchten */
}Zugriffe auf Pipe müssen intern über Semaphore geregelt werden. "JederSchreib-/Lesevorgang bzgl. der Pipe beantragt zunächst den Zugang über einSemaphore."
201
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
• Beispielnutzung einer PipeDie Pipe wird im Vaterprozess angelegt, der anschließend 2 Kindprozessestartet, die über eine Pipe kommunizieren.
Systemaufruf dup() ermöglicht Umlenkung von Standard-Ein/-Ausgabeauf Pipe
main (int argc, char *argv[]) {int fhandle[2]; int rc;pipe(fhandle); /* erzeugt Pipe*/rc = fork();if (rc ==0) {
close(0); /* Schließen Standard Eingabe */dup(fhandle[0]); /* Umlenken von fhandle[0] aufStandard Eingabe */close(fhandle[0]); /* Schließen der nicht mehrbenötigten fhandle[0] */
/* der nun gestartete Prozess liest bei Zugriff aufStandard Eingabe aus der Pipe */
rc = execl("kind1", "Kind 1", "\0");} else {
rc = fork(); /* Vaterprozess */if (rc == 0) {
close(1); /* Schließen Standard Ausgabe */dup(fhandle[1]); /* Umlenken von fhandle[1] aufStandard Ausgabe */close(fhandle[1]); /* Schließen der nicht mehrbenötigten fhandle[1] */
/* der nun gestartete Prozess schreibt beiZugriff auf Standard Ausgabe in die Pipe;zwischen den Kindern ist dadurch eineunidirektionale Kommunikation mittels Pipeserzeugt worden */
rc = execl("kind2", "Kind 2", "\0");}sleep(1);exit(0);
}sleep(1) vor exit(0)? Damit wird sichergestellt, dass die Kinderprozesse vorTerminierung des Vaterprozesses aktiv werden können.
– KinderprozesseKind 1 liest aus der Pipe, während Kind 2 in die Pipe schreibt.
202
Schlichter, TU München 6.3. NACHRICHTENBASIERTE KOMMUNIKATION
/* Kind 1 */main (int argc, char *argv[]) {
char buffer[100];read(0, buffer, 28); /* Prozess liest von Pipe */write(1, buffer, 28); /* schreibt auf Standard Aus */exit(0);
}/* Kind 2 */main (int argc, char *argv[]) {
write(1, "Dies erscheint in der Queue\n", 28);exit(0);
}Das Lesen der pipe erfolgt durch read(fhandle[0], block, anzahl). Istdie Pipe beim read-Aufruf leer, so wird der Prozess blockiert.
• Named PipesProblem: nur Prozesse, die über fork() eng miteinander verwandt sind, könnenim Beispielprogramm kommunizieren.
Einführung von Named Pipes, die mittels mknod erzeugt werden.
ermöglicht die Kommunikation zwischen Prozessen, die nicht miteinanderverwandt sind.
main (int argc, char *argv[]) {int rc;mknod("myfifo", 0600, S_IFIFO);/* 0600 spezifiziert dieZugriffsrechte.*/if (rc == 0) {
int fd;fd = open("myfifo", O_WRONLY);write(fd, "Satz 1\n", 7);close(fd);exit(0)
} else {int fd;char block[20];fd = open("myfifo", O_RDONLY);rc = read(fd, block, 7);write(1, ":", 1);if (rc > 0) { write(1, block, rc); }else printf("Fehler: %d\n", rc);close(fd);exit(0)
}}
203
Schlichter, TU München 6.4. CLIENT-SERVER-MODELL
6.4 Client-Server-Modell
Client-Server Modell basiert i.a. auf der Kommunikationsklasse der synchronenAufträge. Server stellen Dienste zur Verfügung, die von vorher unbekanntenClients in Anspruch genommen werden können. Der Client ruft die Operationeines Servers auf; nach Ausführung der Operation wird das Ergebnis an Clientübergeben. Während der Ausführung der Operation wird Ablauf des Client meistunterbrochen. Eine leere Antwort ist möglich, falls die Operation kein Ergebnisliefert (z.B. Eintrag einer Informationseinheit in eine Datenbank).
• Client-Server Architektur
Client C Server S
Zeit
Auftrag
Resultat
Ausführung
blockiert
• Definitionen
– Definition: ClientEin Client ist eine Anwendung, die auf einer Clientmaschine läuft und i.a.einen Auftrag initiiert, und die den geforderten Dienst von einem Servererhält.
Clients sind meist a-priori nicht bekannt. Clients sind oft Benutzerprozesse,die dynamisch erzeugt und gelöscht werden.
– Definition: ServerEin Server ist ein Subsystem, das auf einer Servermaschine läuft und einenbestimmten Dienst für a-priori unbekannte Clients zur Verfügung stellt. Esexistiert eine einfache n:1 Auftragsbeziehung zwischen den Clients undeinem Server.
204
Schlichter, TU München 6.4. CLIENT-SERVER-MODELL
– Server sind dedizierte Prozesse, die kontinuierlich folgende Schleifeabarbeiten.
while (true) {receive (empfangsport, auftrag);führe Auftrag aus und erzeuge Antwortnachricht;bestimme sendeport für Antwortnachricht;send (sendeport, resultat);
}Der Empfangsport ist server-lokal; der Sendeport ist lokal beim Client.Ein Server kann intern aus einer Menge von Threads aufgebaut sein. EinThread, der sogenannte Listener wartet auf Aufträge. Er verteilt eintreffendeAufträge an sogenannte Worker-Threads, die die Bearbeitung eines Auftragsübernehmen. Die Ergebnisse werden direkt vom Worker-Thread an denClient weitergeleitet.
– Client und Server kommunizieren über Nachrichten, wobei beide Systemeauf unterschiedlichen Rechnern ablaufen können und über ein Netzmiteinander verbunden sind.
• Beispiele für Dienste (Services), die mittels Server realisiert werden:Dateidienst, Zeitdienst, Namensdienst.
• Multi-Tierein System kann sowohl Client als auch Server sein.
Client
Server
Client
Server
– Beispiel
205
Schlichter, TU München 6.4. CLIENT-SERVER-MODELL
HTTP cgiWeb
Browser
(Applets)
Web
Server
Anwendungs
Server
Daten
bank
SQL
• Peer-to-Peer ComputingEs findet keine Unterscheidung zwischen Client und Server statt
⇒ Systeme übernehmen beide Rollen, d.h. sie sind sowohl Client als auchServer (Peers).
Damit soll der Server-Flaschenhals eliminiert werden.
– Teilnahme an einem P2P-System erfordert explizites Beitreten. Bevor einKnoten an einem P2P-System teilnehmen kann, muss er dem Netzwerkder Peers beitreten. Erst anschließend kann dieser Knoten seine Dienstebereitstellen, bzw. Dienste anderer Knoten in Anspruch nehmen.
– Feststellung, welche Dienste im P2P-Systeme verfügbar sindein Knoten registriert seine Dienste bei einem zentrale Directory-Service. Ein Knoten, der einen speziellen Dienst in Anspruch nehmenwill, durchsucht zunächst den Directory-Service. Die nachfolgendeKommunikation erfolgt direkt zwischen Client und Dienstprovider.es existiert ein Discovery-Protokoll, mit Hilfe dessen ein Client-Knoteneine Liste möglicher Dienste im P2P-System erstellen kann. Dazu schicktder Client-Knoten mittels Broadcast eine Anfrage an alle anderen Knotendes P2P-Systems, um herauszufinden, welche Dienste die jeweiligenKnoten anbieten. Vorteil dieses Ansatzes ist, dass es keine zentrale Stellegibt.
– Beispielsysteme sind Napster und Gnutella. Napster kann der erstenKategorie zugeordnet werden; Gnutella der zweiten Kategorie.
– P2P-Systeme wurde in der Vergangenheit häufig im Zusammenhang mitMusik-Tauschbörsen eingesetzt⇒ rechtliche Probleme.
206
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
6.5 Netzwerkprogrammierung
Bedingt durch rasche Verbreitung des Internet hat auch das Interesse an Netz-Anwendungen sehr zugenommen. Netz-Anwendungen sind verteilte Anwendun-gen, die jeweils aus mehreren Teilkomponenten bestehen und die im Netz verteiltauf verschiedenen Rechensystemen ausgeführt werden. Teilkomponenten sindhier nicht einzelne Objekte, sondern komplexe Verarbeitungseinheiten (z.B. einModul bestehend aus einer Menge von Objekten). Eine verteilte Anwendung isteine Anwendung A, dessen Funktionalität in eine Menge von kooperierenden Teil-komponenten A1, .., An, n ∈ IN, n > 1 zerlegt ist;
Jede Teilkomponente umfasst Daten (interner Zustand) und Operationen, dieauf den internen Zustand angewendet werden.
Teilkomponenten Ai sind autonome Prozesse, die auf verschiedenen Rechen-systemen ausgeführt werden können. Mehrere Teilkomponenten können dem-selben Rechensystem zugeordnet werden.
Teilkomponenten Ai tauschen über das Netz untereinander Informationen aus.
Die Teilkomponenten können z.B. auf der Basis des Client-Server Modells reali-siert werden. Beispiele von verteilten Anwendungen sind Softwaresysteme fürverteilte Geldautomaten oder Flugbuchungssysteme. Netzwerkprogrammierungist ein Hilfsmittel zur Implementierung verteilter Anwendungen.
6.5.1 Einführung
In Berkeley Unix wurde das Konzept von Sockets eingeführt, um dieNetzwerkprogrammierung zu erleichtern. Sie erlauben jede Netzverbindungals einen Strom von Bytes zu betrachten, die gelesen bzw. geschriebenwerden können. Ein Socket definiert einen einfachen, bidirektionalen →Kommunikationskanal (siehe Seite 199) zwischen 2 Rechensystemen, mit Hilfedessen 2 Prozesse über ein Netz miteinander kommunizieren können.
207
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
Client Server
Output Strom
Input Strom
Socket Verbindung
Socket Grundlagen
Sockets abstrahieren von den technischen Details eines Netzes, z.B. Übertra-gungsmedium, 2 Paketgröße, Paketwiederholung bei Fehlern, Netzadressen. An-fänglich standen Sockets nur in Unix Umgebungen zur Verfügung. In der Zwi-schenzeit werden sie auch von Windows, dem MacOs und von Java unterstützt.
• Ein Socket kombiniert 2 Ströme, einen Input- und einen Output-Strom.
• Ein Socket unterstützt die folgenden Basisoperationen:
richte Verbindung zu entferntem Rechner ein ("connect").sende Daten.empfange Daten.schließe Verbindung.assoziiere Socket mit einem Port.warte auf eintreffende Daten ("listen").akzeptiere Verbindungswünsche von entfernten Rechnern (bzgl. assoziier-tem Port).
Die ersten 4 Operationen sind sowohl für den Client als auch den Serverrelevant (siehe Java’s Socket Class), während die letzten 3 Operationen nurfür einen Server von Bedeutung sind (siehe Java ServerSocket Class). DieEndpunkte einer Socket werden durch Ports repräsentiert.
6.5.2 Server Protokoll
Ein Server kommuniziert mit einer Menge von Clients, die a priori nicht bekanntsind. Ein Server benötigt eine Komponente (z.B. ein → Verteiler-Thread (siehe
2optisch/elektrisch/Funk, LAN/WAN/WLAN.
208
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
Seite 77)), die auf eintreffende Verbindungswünsche reagiert. Diese Komponentewird auch Listener genannt. Der Hauptunterschied zwischen Client und Serverbzgl. der Socket-Verbindung liegt darin, dass ein Server die Assoziierung miteinem Port vornimmt und Verbindungswünsche akzeptiert.
• Informeller Ablauf aus Serversicht
1. Erzeugen eines SocketServer und Binden an einen bestimmten Port. Ein Portentspricht einer FIFO Warteschlange. Sie sammelt die Verbindungswünscheder Clients. Die maximale Länge ist abhängig vom Betriebssystem, z.B. 50.Falls die Warteschlange voll ist, werden keine weiteren Verbindungswünscheakzeptiert.
2. Warten auf Verbindungswünsche von Clients. Falls der Client bzgl. einerSocketverbindung autorisiert ist, akzeptiert der Server den Verbindungs-wunsch. Der Server wird blockiert, bis die accept-Methode des Servers dieVerbindung zwischen Client und Server eingerichtet hat. Die beiden Strömeder Socketverbindung werden eingerichtet.
3. Austausch von Daten zwischen Client und Server entsprechend einemwohldefinierten Protokoll (z.B. HTTP).
4. Schließen einer Verbindung (durch Server, durch Client oder durch beide);weiter bei Schritt 2.
• ProgrammstückSocket socket; //reference to socketServerSocket port; //the port the server listens totry {
port = new ServerSocket(10001, ...);socket = port.accept(); //wait for client call// communicate with clientsocket.close();
}catch (IOException e) {e.printStackTrace();}
• Für das Abhören des Ports kann ein eigener Verteiler-Thread spezifiziertwerden; die Bearbeitung übernehmen sogenannte Worker-Threads. Der UnixFTP Server hat früher für jede Verbindung einen eigenen Prozess erzeugt, waseinen großen Overhead verursacht⇒ FTP Server konnte deshalb oft nicht mehrals 400 offene Verbindungen unterstützen, falls noch vernünftige Antwortzeitenerwartet werden.
209
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
6.5.3 Client Protokoll
Der Client initiiert eine Socket-Verbindung durch Senden eines Verbindungswun-sches an den Port des Servers.
Informeller Ablauf aus Clientsicht
1. Erzeugen einer Socket Verbindung. Dazu muss die Adresse des Servers (z.B.Internet-Adresse) und der Port, auf dem der Server wartet, angegeben werden.
2. Austausch von Daten zwischen Client und Server über die Duplex-Verbindungentsprechend einem wohldefinierten Protokoll (z.B. HTTP).
3. Schließen einer Verbindung (durch Server, durch Client oder durch beide).
Programmstück
Socket connection; //reference to sockettry {
connection = new Socket("www11.in.tum.de", 10001);........ // communicate with clientconnection.close();
}catch (IOException e) {e.printStackTrace();}
6.5.4 Bidirektionale Stromverbindung
Sockets bestehen aus 2 Strömen für die Duplexverbindung zwischen Clientund Server. Diese beiden Ströme werden automatisch beim Einrichten einerSocket-Verbindung erzeugt. Durch die Verwendung von Strömen kann dieselbeProgrammiermethode verwendet wie bei I/O, Dateizugriff, etc.
• Schreiben auf Socketvoid writeToSocket(Socket sock, String str) throwsIOException {
oStream = sock.getOutputStream();for (int k = 0; k < str.length(); k++)
oStream.write(str.charAt(k));}
210
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
• Lesen von SocketString readFromSocket(Socket sock) throws IOException {
iStream = sock.getInputStream();String str = "";char c;while ( (c = (char) iStream.read()) != ’\n’)
str = str + c;return str;
}Man beachte, dass ein Byte und Char nicht direkt verglichen werden können.Deshalb muss das Byte in ein Char konvertiert werden. Vom Strom wird jeweilsbis zum nächsten Zeilenende gelesen. Die gelesene Zeile wird als Ergebniszurückgegeben.
6.5.5 Java Socket Class
Java unterstützt die beiden grundlegenden Klassen:
java.net.Socket zur Realisierung der Client-Seite einer Socket.
java.net.ServerSocket zur Realisierung der Server-Seite einer Socket.
Client-Seite einer Socket
• Constructorpublic Socket(String host, int port)
throws UnknownHostException, IOExceptionDer Parameter host ist ein Rechnername, z.B. www11.in.tum.de. Falls derDomain Name Server den Parameter host nicht auflösen kann, wird dieException UnknownHostException ausgelöst. Falls die Socket aus einemanderen Grund nicht geöffnet werden kann, wird IOException ausgelöst, z.B.der entfernte Host akzeptiert keine Verbindungen. Es gibt noch eine Reiheanderer Konstruktoren, z.B.
public Socket(InetAddress host, int port) throws IOException
Das Objekt der Klasse InetAddress umfasst den Rechnernamen und seine IP-Adresse, d.h. eine Auflösung durch den Domain Name Server ist nicht mehrnotwendig.
211
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
• Information über eine Socket
public InetAddress getInetAddress();liefert als Ergebnis den Namen und IP-Adresse des entfernten Rechners, zudem die Socket-Verbindung existiert.
public int getPort();liefert als Ergebnis die Nummer des Ports, mit dem die Socket-Verbindungam entfernten Rechner assoziiert ist.
public int getLocalPort();liefert als Ergebnis die Nummer des Ports, mit dem die Socket-Verbindungam lokalen Rechner assoziiert ist.
• Ein-/Ausgabe
public InputStream getInputStream() throws IOException;liefert den InputStream, von dem Daten gelesen werden können. Erunterstützt die Methode read zum Lesen der Daten. InputStream ist einBasis-Strom, der mit Hilfe von SubClassing spezialisiert werden kann.
public OutputStream getOutputStream() throws IOException;liefert den OutputStream, in dem Daten geschrieben werden können. Erunterstützt die Methode write zum Schreiben der Daten. OutputStream istein Basis-Strom, der mit Hilfe von SubClassing spezialisiert werden kann.
Die beiden Methoden stehen natürlich auch auf Server-Seite einer Socket-Verbindung zur Verfügung.
Server-Seite einer Socket
• Constructorpublic ServerSocket(int port)
throws IOException, BindExceptionerzeugt eine Socket auf Server-Seite und assoziiert sie mit dem Port. Fallsdie Socket nicht an den angegebenen Port gebunden werden kann, wirdBindException ausgelöst. Es existieren noch weitere Konstruktoren, z.B.
public ServerSocket(int port, int queueLength)throws IOException, BindException
212
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
Die Länge der mit dem Port verbundenen Warteschlange wird durch denParameter queueLength angegeben.
• Einrichten/Schließen einer Verbindung
public Socket accept() throws IOExceptiondiese Methode blockiert und wartet auf Verbindungswünsche von Clients.
public void close() throws IOException
• Ein-/Ausgabe
public InputStream getInputStream() throws IOException;liefert den InputStream, von dem Daten gelesen werden können.
public OutputStream getOutputStream() throws IOException;liefert den OutputStream, in dem Daten geschrieben werden können.
6.5.6 Beispiel - Generische Client/Server Klassen
Das Beispiel zeigt eine allgemeine Client/Server-Anwendung, wobei derAusgangspunkt eine generische ClientServer Klasse ist, aus der konkrete Servicesabgeleitet werden können.
• ClientServer Klasseimport java.io.*;import java.net.*;
213
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
public class ClientServer extends Thread {protected InputStream iStream;protected OutputStream oStream;protected String readFromSocket(Socket sock) throwsIOException {
iStream = sock.getInputStream();String str = "";char c;while ( (c = (char) iStream.read()) != ’\n’)
str = str + c;return str;
}protected void writeToSocket(Socket sock, String str)throws IOException {
oStream = sock.getOutputStream();if (str.charAt(str.length() - 1) != ’\n’) str = str +’\n’;for (int k = 0; k < str.length(); k++)
oStream.write(str.charAt(k));}
}
• EchoServer KlasseDer EchoServer sendet den String einer Client Anfrage wieder zurück.
import java.io.*;import java.net.*;
214
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
public class EchoServer extends ClientServer {private ServerSocket port;private Socket socket;public EchoServer (int portNum, int nBackLog) {
try { port = new ServerSocket(portNum, nBackLog);} catch (IOException e) { e.printStackTrace(); }
}public void run() {
try {System.out.println("Echo server at "
+ InetAddress.getLocalHost() + " waiting forconnections ");while (true) {
socket = port.accept();System.out.println("Accepted a connection from" + socket.getInetAddress() );provideService(socket);socket.close();System.out.println("Closed the connection\n");
}} catch (IOException e) { e.printStackTrace(); }
}protected void provideService (Socket socket) {
String str = "";try {
writeToSocket(socket, "Hello, how may I help you?\n");do {
str = readFromSocket(socket);if (str.toLowerCase().equals("goodby"))
writeToSocket(socket, "Goodbye\"n);else
writeToSocket(socket, "You said ’" + str +"’\n");
} while (!str.toLowerCase().equals("goodbye") );} catch (IOException e) { e.printStackTrace(); }
}public static void main (String args[]) {
EchoServer server = new EchoServer(10001, 3);server.start();
}}
• EchoClient Klasse
215
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
import java.io.*;import java.net.*;
216
Schlichter, TU München 6.5. NETZWERKPROGRAMMIERUNG
public class EchoClient extends ClientServer {protected Socket socket;public EchoClient (String url, int port) {
try { port = new Socket(url, port);System.out.println("Client: connected to " + url +":" + port);
} catch (IOException e) { e.printStackTrace();System.exit(1); }
}public void run() {
try {requestService(socket);socket.close();System.out.println("Client: connection closed");
} catch (IOException e) {System.out.println(e.getMessage());e.printStackTrace(); }
}protected void requestService (Socket socket) throwsIOException {
String servStr = readFromSocket(socket);System.out.println("Server: " + servStr);System.out.println("Client: type a line or ’goodbye’ toquit");if (servStr.substring(0, 5).equals("Hello")) {
String userStr ="";do {
userStr = readFromKeyboard();writeToSocket(socket, userStr + "\n");servStr = readFromSocket(socket);System.out.println("Server: " + servStr);
} while (!userStr.toLowerCase().equals("goodbye"));}
}protected String readFromKeyboard() throws IOException {
BufferedReader input = new BufferedReader(newInputStreamReader(System.in));System.out.print("Input: ");String line = input.readLine();return line;
}public static void main (String args[]) {
EchoClient client = new EchoClient("www11.in.tum.de",10001);client.start();
}} 217
Kapitel 7
Dateisysteme
Dateisysteme 1 dienen der dauerhaften Speicherung von Programmen undDaten. Zum Einsatz kommen magnetische und optische Medien, die imGegensatz zum Arbeitsspeicher auch nach dem Ausschalten der Rechenanlageden Datenerhalt sicherstellen. Beispiele von externen Speichermedien sindFestplatten, Magnetbänder, CD-ROM (wiederbeschreibbar), USB-Sticks undDVDs. Der schlechten Zugriffszeit externer Speichersysteme (im Vergleich zumArbeitsspeicher) steht eine vergleichsweise hohe Kapazität und ein sehr gutesPreis-Leistungsverhältnis gegenüber. Zentrale Aufgabe des Dateisystems ist esdie besonderen Eigenschaften externer Speichermedien optimal umzusetzen undApplikationen einen effizienten Zugriff auf die persistent gespeicherten Daten zuermöglichen. Es gelten folgende grundlegende Forderungen
a) Speicherung großer Informationsmengen (Video)b) kein Datenverlust auch bei Prozess- / Systemabsturzc) nebenläufiger Zugriff durch mehrere Prozesse
Neben Dateisystemen gibt es Datenbanksysteme, die aus einer Menge vonDaten und den zugehörigen Programmen zum Zugriff auf die Daten sowie zurKontrolle der Konsistenz bestehen. Der Zugriff auf die Daten erfolgt immer überOperationen des Datenbanksystems (z.B. auf der Basis von SQL), und nicht direktdurch die einzelnen Applikationen.
7.1 Fragestellungen
Dieser Abschnitt beschäftigt sich mit den Mechanismen eines Rechensystems zurdauerhaften (persistenten) Speicherung von Programmen und Daten:
1[nehmer2001, S 253]
218
Schlichter, TU München 7.2. CHARAKTERISTIKA VON DATEISYSTEMEN
• Charakteristika von Dateisystemen.
• Schichtenmodell eines Dateisystems.
7.2 Charakteristika von Dateisystemen
Jedes Dateisystem unterstützt 2 grundlegende Abstraktionen:
Datei: Behälter für die persistente Speicherung jeglicher Information.Information können Daten, der Code ausführbarer Programme, aber auchkontinuierliche Daten wie Videoströme sein. Das Dateisystem bietetbesondere Zugriffsfunktionen an, die der Zugriffscharakteristik externerSpeicher Rechnung tragen.
Verzeichnisse: spezielle Dateien zur Strukturierung externer Speichermedien.
• blockorientierter Datentransfer zwischen externem Speicher und Arbeitsspei-cher. Aufgrund der hohen Zugriffszeiten bei externen Speichermedien ist einkleines Lese- und Schreibgranulat nicht sinnvoll. Daher bilden sogenannteBlöcke die kleinste Übertragungseinheit.
Typische Blockgrößen: 512 Byte - 4 KByte.
Der Zugriff auf das 1. Byte eines Blocks auf der Festplatte hängt von derPositioniergeschwindigkeit ab (im Mittel mehrere Millisekunden), während dieZugriffszeit auf die restlichen Bytes von der Umdrehungsgeschwindigkeit derPlatte abhängt. Zu große Blöcke resultieren in wachsender Information, dievom Prozess primär nicht angefordert wurde.
• Charakteristika der Dateinutzung (empirisch ermittelt):
a) Dateien sind meist klein (wenige KBytes).b) Dateien werden häufiger gelesen, seltener geschrieben und noch seltenergelöscht.c) vornehmlich sequentieller Zugriff.d) Dateien werden selten von mehreren Programmen oder Personengleichzeitig benutzt.
Datei-Zugriffsoperation werden oft gemäß dieser Charakteristika optimiert. FürMultimedia verändert sich die Nutzungscharakteristik.
219
Schlichter, TU München 7.3. DATEIEN
große Dateien (mehrere GByte).gleichmäßige Zugriffsgeschwindigkeit (um Ruckeln zu vermeiden).notwendige Übertragungsbandbreite. Zum Beispiel ist bei einer unkompri-mierten Videoaufzeichnung im Format 1024*768 bei 3 Byte pro Pixel und50 Bildern pro Sekunde eine Übertragungskapazität von 112,5MByte proSekunde notwendig (Datei hat bereits nach einer Minute eine Größe von6,5 GByte).
7.3 Dateien
Dateien bilden in einem Dateisystem die Behälter für die dauerhafte Speicherungbeliebiger Information. Dabei nutzen nicht nur Benutzerprogramme, sondern auchdie Systemsoftware greift in vielen Fällen auf Dateien zurück. Beispielsweisewird auch die Auslagerung von Seiten des virtuellen Adressraums über das Datei-system auf einer sogenannten Auslagerungsdatei (swap Datei) vorgenommen.
• in den meisten Systemen wird eine Datei als eine Folge von Bytes aufgefasst.Eine Datei beginnt mit dem Byte 0 und endet in Abhängigkeit von ihrer Längen mit dem Byte n-1.
• Dateinamenin manchen Dateisystemen haben Dateinamen die Form "name.extension".
Beispiele für extension: .c, .java, .html, .gif, .pdf, .tex,.doc, .zip, ....
In einigen Betriebssystemen werden die Datei-Extension sematisch interpretiertund veranlassen ein bestimmtes Verhalten, z.B. ein Doppel-Click auf eine".doc"-Datei startet unter Windows die Anwendung Microsoft Word. InUnix sind Datei-Extensions nur Konventionen. Das Mac Betriebssystem nutztkeine Extensions, um Applikationen zu triggern; dort wird eine zusätzlicheRessource-Datei genutzt.
• DateiaufbauDie interne Struktur einer Datei hängt von der jeweiligen Nutzung undZielsetzung ab, z.B. ASCII Datei besteht aus Zeilen, die mit CR, LFabgeschlossen sind. MS-DOS verwendet eine Kombination von CR und LF.Beispiel einer Archivdatei
220
Schlichter, TU München 7.3. DATEIEN
Header
Objekt Modul
Header
Objekt Modul
Header
Objekt Modul
Modulname
Datum
Owner
Zugriffsrechte
Länge
• OperationenDateisysteme unterstützen die folgenden grundlegenden Systemaufrufe:
openÖffnen einer Datei; Ergebnis ist ein Dateideskriptor, über den innachfolgenden Systemaufrufen auf die Datei zugegriffen werden kann.
Aufruf nach Posix-Standard
int open (const char *filename,int flags,mode_t mode)
flags spezifiziert die Zugriffsart, z.B. lesend, schreibend, erzeugend,anhängend (append); mode spezifiziert die Zugriffsrechte für neu erzeugteDateien. In Windows NT/2000 wird der Systembefehl CreateFile zum Öffneneiner Datei bzw. zum Erzeugen einer neuen Datei verwendet. Analog zu openwird als Ergebnis ein Dateideskriptor zurückgegeben (Datentyp Handle). DieAnzahl der Dateideskriptoren ist beschränkt.
closeSchließen einer Datei; Aufrufparameter ist ein Dateideskriptor. BeiTerminierung des Prozesses werden alle offenen Dateien automatischgeschlossen.
221
Schlichter, TU München 7.3. DATEIEN
int read (int fd, char *puffer, int max)int write (int fd, char *puffer, int n)max gibt die Anzahl der Bytes an, die ohne Pufferüberlauf gelesen werdenkönnen; read liefert als Ergebnis die Anzahl der erfolgreich gelesenen Bytes.Daneben gibt es noch weitere Operationen, z.B. Positionieren des Dateizeigersauf eine bestimmte Position in der Datei (lseek oder SetFilePointer beiWin32).
– DateipufferZugriffe auf Dateien erfolgen über einen Dateideskriptor und einenDateipuffer.
Dateizeiger
Puffer
Pufferposition
Ortsinformation
Externer Speicher Datei
Datei
Deskriptor
Dateipuffer
Die für den lesenden und schreibenden Zugriff notwendigen Informationenwerden in einer eigenen Datenstruktur (Dateipuffer) gespeichert, diejedem geöffneten Dateideskriptor zugeordnet wird. Diese Datenstrukturenthält neben der Ortsinformation, die Aufschluss über den physischenAufenthaltsort der Datei auf einem externen Speichermedien gibt, einenPuffer zur Zwischenspeicherung von Daten. Der Puffer beinhaltet eine Kopieeines bestimmten Dateiausschnitts. Die Position dieser Kopie innerhalb derDatei speichert der Zeiger Pufferposition. Der Dateizeiger spezifiziert dieaktuelle Lese-/Schreibposition.
222
Schlichter, TU München 7.4. MEMORY-MAPPED DATEIEN
7.4 Memory-Mapped Dateien
Eine Datei oder Teile davon werden in den virtuellen Adressraum eines Prozesseseingeblendet. Das Dateisystem bestimmt einen hinreichend großen Bereich imvirtuellen Adressraum für den Dateiausschnitt, z.B. zwischen Laufzeitkeller undHalde. Für diesen Teilbereich müssen entsprechende Seitentabellendeskriptoreninitialisiert werden. Nutzung von "Prefetching", um bereits im Voraus Dateiblöckein Seiten zu laden.
virtueller Speicher des
Prozesses A
1
2
3
4
physischer
Arbeitsspeicher
1
2
3
4
Festplatte
1 2 3
4
• Lese- und Schreiboperationen, sowohl sequentiell als auch wahlfrei, erfolgenüber virtuelle Adressen. Es werden keine File read/write Operationen mehrausgeführt.
• Einblendung immer nur Vielfacher ganzer Blöcke einer Datei.
• veränderte Blöcke werden meist aus Effizienzgründen zu einem späterenZeitpunkt zurückgeschrieben. Auf jeden Fall werden die veränderten Blöckebeim Schließen der Datei auf den externen Speicher zurückgeschrieben.
• gemeinsame Nutzung einer Datei durch mehrere Prozesse möglich. Diegemeinsame Datei wird jeweils in die Adressräume der beteiligten Prozessegeladen. Im physischen Arbeitsspeicher befindet sich die Datei mit ihrenDateiblöcken nur einmal. Die Änderung der Datei durch einen Prozess ist somitauch für die anderen Prozesse sichtbar.
• Beispiel
– Beispiel der Win32-Programmierschnittstelle:
223
Schlichter, TU München 7.5. VERZEICHNISSE
Handle fh, fmh;fh = CreateFile(filename, generic_read, .....);len = GetFileSize(fh, ...);fmh = CreateFileMapping(fh, Page_readonly, ...);addr = MapViewOfFile(fmh, File_map_read, ...);sprintf(addr, "Information für memory-mapped Datei");fh ist der Datei-Handle auf die geöffnete Datei. Mit Hilfe vonMapViewOfFile wird eine Sicht auf die Datei im virtuellen Adressraum er-stellt. Der Rückgabewert addr speichert die Anfangsadresse der Datei imvirtuellen Adressraum. In der Regel wählt das Dateisystem den virtuellenAdressbereich aus.
– Beispiel Unix SolarisSystemaufruf mmap() spezifiziert eine Datei als memory-mapped Datei;Datei wird in den virtuellen Adressraum des Prozesses geladen.bei Aufruf des Datei-Systemaufrufs open; Datei wird als memory-mapped Datei in den Betriebssystembereich des virtuellen Adressraumsgeladen. read/write-Systemaufrufe werden auf dieser memory-mapped Dateiausgeführt. Unabhängig davon wie eine Datei geöffnet wird, behandeltSolaris jede Datei als memory-mapped Datei.
7.5 Verzeichnisse
Verzeichnisse (engl. directories) erlauben eine hierarchische Strukturierung desexternen Speichers.
• baumartige Verzeichnisstruktur mit links zwischen Unterbäumen.
• Pfadnamen zur Spezifikation von Dateien und Verzeichnissen. Der vollständigeund eindeutige Namen einer Datei oder eines Verzeichnisses entsteht durch eineAneinanderreihung aller Verzeichnisnamen beginnend beim Wurzelverzeich-nis; Unterscheidung zwischen absoluten und relativen Dateinamen.
• typische Operationen: create, delete, opendir, closedir, readdir, rename, link,unlink.
• Mögliche Realisierung von Verzeichnissen
als lineare Liste von Dateinamen. Sehr leicht zu realisieren, jedochOperationen wie die Erzeugung einer neuen Datei sind aufwändig, da diegesamte lineare Liste des Verzeichnisses zunächst durchsucht werden muss,um festzustellen, ob es einen Namenskonflikt gibt. Die Suche nach einerDatei erfordert linearen Aufwand.
224
Schlichter, TU München 7.6. SCHICHTENMODELL
als Hashtabelle für die Dateinamen. auftretende Hash-Kollisionen müssenbehandelt werden. Falls sich die Anzahl der Dateien im Verzeichnis erhöht,muss möglicherweise die Hashtabelle erweitert werden.
7.6 Schichtenmodell
Ein Dateisystem kann logisch in 3 Schichten unterteilt werden, die zunehmendhöhere Abstraktionen für die Speicherung persistenter Daten anbieten.
Datenträgerorganisation
Blockorientiertes Dateisystem
Dateiverwaltung
7.6.1 Datenträgerorganisation
Unterteilung des gesamten Datenträgers in Blöcke, die von 0 an aufsteigenddurchnummeriert sind. Das auf MS-DOS aufbauende Dateisystem FAT (Windows95) verwendet lediglich maximal 16 Bit für eine Blocknummer. Bei einer ur-sprünglichen Blockgröße von 512 Byte können damit externe Speicher mit biszu 32 MByte Speicherkapazität angesprochen werden. Zusammenfassung vonBlöcken zu Clustern (32 KByte), um bis zu 2 GByte große Datenträger zu ad-dressieren; Cluster sind die kleinste Zuteilungseinheit⇒ interne Fragmentierung.
• Verwaltung freier und defekter Blöcke.
Block 0
0
Block 1 Block 2 Block 3 Block 4 Block 5
0 0 1 0 0 0 0Defekte
Blöcke
0 1 1 0 0 1 0 0Freie
Blöcke
225
Schlichter, TU München 7.6. SCHICHTENMODELL
Eine gängige Realisierung der Listen für freie und defekte Blöcke besteht inzusammenhängenden Bitvektoren, die auf dem Datenträger selbst gespeichertwerden. Diese Realisierung erlaubt den gleichzeitigen Test von 16, 32 oder 64Bitpositionen mit Hilfe von Logikoperatoren des Prozessors.
• Blockstruktur
Super-
blockFreie Blöcke
Defekte
BlöckeBlock 0 Block 1 Block n
Der Superblock verwaltet alle essentiellen Informationen über den Datenträge-raufbau, z.B. eine Magic Nummer für den Typ des Dateisystems, Anzahl derBlöcke. Aus Sicherheitsgründen wird der Superblock mehrfach, verteilt überden gesamten Datenträger, repliziert.
7.6.2 Blockorientiertes Dateisystem
Aufteilung des vorhandenen Speicherplatzes eines logisch durchnummeriertenDatenträgers auf mehrere Dateien.
• Dateien besitzen interne Namen.
• keine hierarchische Verzeichnisstruktur. Es existieren keine hierarchischenVerzeichnisstrukturen, d.h. alle Dateien sind in einer flachen Strukturunmittelbar über den internen Dateinamen ansprechbar.
• jede Datei besteht aus einer Menge von Blöcken, die relativ zum Dateianfangnummeriert sind. Die Blöcke können entweder zusammenhängend oder verteiltüber den Datenträger zugeteilt werden. Im ersten Fall kann dies zu externerFragmentierung führen. Die interne Fragmentierung hängt von der Blockgrößeab. Dateien werden immer in Vielfachen von Blöcken belegt.
• wesentliche Operationen:
Erzeugen und Löschen von DateienÖffnen und Schließen von DateienLesen und Schreiben von Blöcken
226
Schlichter, TU München 7.6. SCHICHTENMODELL
7.6.3 Dateiverwaltung
Bereitstellung von Dateien und Verzeichnissen; Dateien werden über Namenidentifiziert. Unix verwendet Dateideskriptoren (sogenannte i-nodes), die allerelevanten Dateiattribute einschließlich einer Indexstruktur für die Lokalisierungder einzelnen Dateiblöcke enthalten. Die Position der ersten 10 Blöcke (beieinigen Implementierungen auch 12 Blöcke) einer Datei werden direkt imDeskriptor gespeichert.
Schutzbits
Link Count
I-Node
uid
gid
Größe
Adressen der
ersten 10 Blöcke
(manchmal auch 12 Blöcke)
einfach indirekt
zweifach indirekt
dreifach indirekt
Jeder Datei, auch jedem Verzeichnis ist genau ein i-node zugeordnet. i-nodeNummern werden sequentiell vergeben. Sie sind in einem speziellen Block, demSuperblock, auf der Festplatte zusammengefasst. i-node Nummer werden nachder Löschung der zugehörigen Datei wiederverwendet.
• Windows NTFSGrundeinheit ist ein volume, das nur aus einer Sorte Daten besteht:
Dateien, die durchnummeriert sind.
jede Datei hat eine 64-Bit Nummer, bestehend aus 48 Bit Dateinummer und16 Bit Sequenznummer. Die Sequenznummer wird nach jedem Löschender zur Dateinummer gehörenden Datei inkrementiert, so dass manzwischen der Referenz zu einer gelöschten Datei und einer aktuellen Dateiunterscheiden kann.
Jedes volume hat eine zentrale Tabelle, die Master File Table (MFT), in der alleDateien verzeichnet sind.
227
Schlichter, TU München 7.6. SCHICHTENMODELL
7.6.4 Virtuelles Dateisystem
Moderne Betriebssysteme unterstützen neben dem lokale Dateisystem auchentfernte Dateisysteme.
Integration auf Nutzerebene mittels eines virtuellen Dateisystems (VFS). Aufdiese Weise wird ermöglicht, dass der Nutzer zwischen den verschiedenenDateisystemtypen nahtlos navigieren kann.bekannter Vertreter: Network File System (NFS). NFS ist ein von Sunentwickeltes Protokoll zum Zugriff auf entfernte Dateien. Der Nutzer kannauf entfernte Dateien zugreifen wie auf lokale gespeicherte Dateien, d.h. esist kein FTP notwendig. Als Kommunikation wird ein RPC verwendet.
Dateisystem
Schnittstelle
Schnittstelle virtuelles
Dateisystem
Lokales
Dateisystem
entferntes
Dateisystem
• die oberste Schicht stellt die allgemeinen Zugriffsoperationen wie open, read,write und close bereit.
• die VFS Schicht ermöglicht die eindeutige Repräsentation einer Dateiüber Netzwerkgrenzen hinweg. Die VFS Schicht trennt die generischenZugriffsoperationen von den aktuellen Implementierungen. Dateien werden mitHilfe eines Deskriptors, dem vnode, netzwerkweit eindeutig charakterisiert.Für das lokale Dateisystem werden vnodes auf den entsprechenden inodeabgebildet. Falls der vnode auf eine entfernte Datei verweist, wird eineZugriffsoperation auf entsprechende Kommunikationsnachrichten (z.B. durchden NFS-Client auf der Basis des NFS Protokolls) abgebildet.
228
Kapitel 8
Ein-/Ausgabe
Eine der Hauptaufgaben eines Betriebssystems ist es, alle Ein-/Ausgabegeräteeines Rechensystems zu überwachen und steuern.
8.1 Klassifikation von E/A-Geräten
Unterscheidung zwischen
blockorientierten Geräten: speichert Information in Blöcken fester Größe(z.B. Festplatte). Die Information zwischen BS und Gerät werden immer inganzen Blöcken transferiert, und nicht einzelne Bytes.
zeichenorientierten Geräten: erzeugt und akzeptiert Zeichenströme, ohne aufBlockstruktur zu achten (z.B. Maus, Tastatur, Netzwerkkarte). Nicht alleGeräte passen in dieses Schema. Uhren besitzen weder Blockorientierungnoch erzeugen sie Zeichenströme; sie lösen in wohdefinierten ZeitintervallenUnterbrechungen aus.
Eine andere Unterteilung bezieht sich auf Geräte mit
wahlfreiem Zugriff: Zugriff über Adressinformation (z.B. Festplatte).
seriellem Datentransfer: Zugriff ohne Adressinformation (z.B. Magnetband).
• Ziele für E/A-Software im Betriebssystem
Geräteunabhängigkeit. Es sollte möglich sein, Programmen zu schreiben,die mit Dateien auf einer Festplatte, CD-/DVD-Laufwerk und USB-Stickarbeiten, ohne dass zuvor das Programm für den jeweiligen Gerätetypgeändert werden muss.
229
Schlichter, TU München 8.2. SCHICHTEN EINES E/A-SYSTEMS
einheitliches Benennungsschema für die Geräte. Der Name sollte aus einerZeichenkette oder Nummer bestehen, und nicht von der Art des Gerätesabhängen.
8.2 Schichten eines E/A-Systems
Ein E/A-System eines BS ist typischerweise in mehrere Schichten unterteilt:
Benutzerprozess
geräteunabhängige BS-Software
Gerätetreiber
Unterbrechungsroutinen
Controller
Gerät
Betriebssystem
Hardware
Benutzer Modus
System Modus
• Unterbrechungsroutinen: Handhabung der Rückmeldungen vom Geräte-Controller, z.B. nach Beendigung eines Druckauftrags. Die Rückmeldung er-zeugt eine Unterbrechung, die von der zugehörigen Unterbrechungsroutine be-handelt wird. Der gerade laufende Prozess wird unterbrochen und sein Zustandwird gerettet. Der Prozess, der auf die Rückmeldung des E/A-Gerätes wartet,wird entblockiert.
• Gerätetreiber: Ausführung der geräteabhängigen Steuersoftware; zuständig füralle Geräte eines Gerätetyps. Der Code der Gerätetreiber wird vom Herstellerdes Geräts programmiert und mit dem Gerät zusammen ausgeliefert. I.a. sindfür jedes Betriebssystem eigene Treiber notwendig. Der Gerätetreiber greiftüber die Controller auf die Geräte zu.
• Geräteunabhängige Software: belegen eines Geräts, puffern von Information.
• Ablauf einer E/A-Anforderung
230
Schlichter, TU München 8.2. SCHICHTEN EINES E/A-SYSTEMS
E/A Request
(read)
Kann
Request erledigt
werden
Systemaufruf
Send Request zu
Gerätetreiber
Blockiere Prozess, falls
notwendig
BS-Kern
Geräteunabhängige
BS Software
Reserviere Puffer,
Sende Kommandos an
Controller
Gerätetreiber
Steuere Gerät, führe
Datentransfer durch,
unterbreche bei E/A Ende
Controller
Kommandos
GerätecontrollerE/A Ende,
Erzeuge Unterbrechung
Speichere Daten in Puffer des
Gerätetreibers, signalisiere
die Blockierung des Treibers
aufzuheben
Bestimme E/A Request,
signalisiere E/A-Ende an
BS-Kern
Unterbrechung
Übertrage Daten in Prozess-
Adressraum, melde
Ergebniscode (Erfolg oder
Fehlercode)
BS-Kern
Geräteunabhängige
BS Software
E/A Ende, Daten
verfügbarBenutzerprozess
nein
ja
1. Der Benutzerprozess initiiert den blockierenden Systemaufruf read miteinem Dateideskriptor als Parameter.
2. Der BS-Kern überprüft die Korrektheit der Parameter. Falls die gewünschtenDaten bereits im Cache des BS vorhanden sind, werden die Daten umgehendausgeliefert.
3. Andernfalls muss eine physische E/A durchgeführt werden. Der Prozess ausder rechnend-Liste entfernt und zur Liste "wartend-auf-EA" hinzugefügt. DerBS-Kern sendet einen Request an den Gerätetreiber.
4. Der Gerätetreiber reserviert einen Pufferspeicher für die zu empfangendenDaten, disponiert die E/A und sendet die entsprechenden Kommandos anden Gerätecontroller (Besetzen der Kontrollregister).
5. Der Gerätecontroller betreibt das Gerät und führt den Datentransfer durch.
231
Schlichter, TU München 8.3. GERÄTEVERWALTUNG
6. Der Gerätetreiber entweder pollt den Controller bzgl. des Zustandes derRequestdurchführung. Falls der E/A-Request über einen DMA-Controllererfolgt, wird gewartet bis bei E/A-Ende durch den DMA-Controller eineUnterbrechung generiert wird.
7. Die Unterbrechungsbehandlung speichert die Unterbrechungsdaten undsignalisiert, die Blockierung des Gerätetreibers aufzuheben.
8. Der Gerätetreiber identifiziert den E/A-Request, der beendet wurde,bestimmt den Request Status und meldet die Beendigung an den BS-Kern.
9. Der BS-Kern transferriert die Daten und den Returncode in den Adressraumdes Benutzerprozesses, hebt die Blockierung des Prozesses auf und reiht ihnin die Liste der rechenwilligen Prozesse ein.
10. Wenn der Scheduler dem Prozess die CPU zuordnet, wird der Prozess mitder Beendigung des Systemaufrufs fortgesetzt.
8.3 Geräteverwaltung
Eine Hauptaufgabe des BS ist die einheitliche Darstellung der unterschiedlichenE/A-Geräte und Treiber.
Zuordnung von logischen Kanälen zu physischen Geräten.
Anwendung
create()
open()
close()
read()
write()
ioctl()
E/A-System
xxcreate()
xxopen()
xxclose()
xxread()
xxwrite()
xxioctl()
xxTreiber
Controller
Gerät
Logischer
Kanal
create open close read write ioctl
xxcreate xxopen xxclose xxread xxwrite xxioctl
0
1
2
logische
Kanalnummer Treibertabelle
8.3.1 Gerätetreiber
Treiber sind gerätetyp-spezifisch und sie schaffen die Verbindung zwischenAnwenderprozessen und den Geräten bzw. deren Controller. Gelegentlich können
232
Schlichter, TU München 8.3. GERÄTEVERWALTUNG
dieselben Treiber für verschiedene Varianten von Geräteklassen eingesetztwerden. Damit der Treiber Zugriff auf die Hardware und auf die Register desControllers haben kann, muss es ein Teil des BS-Kerns sein. Treiber machen keineSystemaufrufe, jedoch dürfen sie auf bestimmte BS-Dienste zugreifen.
Prozessor mit
Programmausführung
(BS mit Treiber,
Anwendung)
Kontroller
System
Register
Kommunikation über
Bussystem
Befehle, Daten
Zustände, Signale, Daten
GerätSignale, Daten
Aufgaben eines Treibers
Treiber bedienen die Hardware zur Gerätesteuerung (Controller), um
Gerätezustände abzufragenBefehle an das Gerät zu übermitteln,Daten von/zum Gerät zu übermitteln.
Aufgaben eines Treibers sind
• definiert das Gerät gegenüber dem BS.
• definiert die gerätespezifische Datenbasis.
• initialisiert den Controller und das Gerät beim Systemstart.
• wandelt allgemeine E/A-Anforderungen in gerätespezifische Befehle um.
• aktiviert das Gerät.
• antwortet auf Hardwaresignale des Geräts bzw. des Controllers.
• meldet Geräte- und Controllerfehler.
• empfängt/sendet Daten und Zustandsinformation vom/zum Gerät.
• verarbeitet mehrere E/A-Anforderungen gleichzeitig oder überlappt (Multi-threading).
• puffert Daten bei Ein- und Ausgabe.
233
Schlichter, TU München 8.3. GERÄTEVERWALTUNG
8.3.2 Geräteunabhängige E/A
Die Realisierung abstrakter Geräte und die Definition einer generischenGerätearchitektur ist charakteristisch für viele Betriebssysteme. Ein Aspekt ist dieBereitstellung einer einheitlichen Schnittstelle zwischen Gerätetreiber und demRest des BS.
⇒ vereinfacht die Programmierung und Einbindung neuer Treiber-Software.Treiber unterstützen zwar vom Gerätetyp unterschiedliche Funktionen undSignale, jedoch eine speziell auf einen Treiber zugeschnittene Schnittstellewürde den Programmieraufwand und damit die Fehleranfälligkeit erhöhen.
Namensgebung von E/A-Geräten
Nutzung von symbolischen Namen für Geräte.
geräteunabhängiger Teil des BS bildet symbolische Namen auf die entspre-chenden Treiber ab.
• Einbettung der E/A in Unixin Unix erfolgt der Zugriff auf praktisch jedes E/A-Gerät über Funktionen desDateisystems. Vor dem eigentlichen Zugriff auf ein Gerät muss dieses analogzu einer Datei geöffnet werden.
– in vielen Unix Systemen werden alle Geräte unter dem Teilbaum /devverwaltet.
– der Dateiname charakterisiert den jeweiligen Typ des E/A-Geräts.
/dev/ttya: physische serielle Schnittstelle
/dev/ptty01 ...: abstrakte serielle Schnittstellen
/dev/fd0 ...: Diskettenstationen
/dev/sd0 ...: Festplatten (sd steht für SCSI Disk)
/dev/le0 ...: Netzkarten– /dev/sd0 spezifiziert genau einen I-Node einer Spezialdatei. I-Node enthält:
Hauptgerätenummer (major device number): Festlegung desGerätetreibers.
234
Schlichter, TU München 8.3. GERÄTEVERWALTUNG
Nebengerätenummer (minor device number): Parameter an Treiber zurFestlegung des konkreten Geräts, von dem gelesen, bzw. auf dasgeschrieben wird.
Alle Geräte besitzen eine Haupt- und eine Nebengerätenummer; alle Treiberwerden durch die Hauptgerätenummer ausgewählt.
Standardisierte E/A-Funktionen
Die E/A-Programmierschnittstelle wird meist als Teil einer Systembibliothek(z.B. in C/C++) bereitgestellt. Typische generische E/A-Funktionen sind:
• open(): eröffnet einen logischen Kanal zu einem Gerät und liefert einenIdentifikationswert (Deskriptor, Handle) für die anschließende Nutzung. BeimDateisystem wird anstelle des Geräts eine einzelne Datei angesprochen.
• close(): ein vorher geöffneter Kanal wird geschlossen. Die zugehörigeSystemdatenstruktur wird freigegeben.
• read(): liest eine Anzahl von Byte (als Bytestrom) vom Gerät ein.
• write(): gibt eine Anzahl von Byte an das Gerät aus.
• ioctl(): dient dazu, die Betriebsart des Geräts zu ändern. Bei einer seriellenSchnittstelle kann dies z.B. die Übertragungsrate sein.
Wie bereits erwähnt, werden diese generischen Funktionen durch das Betriebssy-stem auf Funktionen des relevanten Treibers abgebildet.
Pufferung
Eine direkte Durchreichung der Ein-/Ausgabedaten zwischen dem Benutzerpro-zess und dem Gerät ist zwar möglich, jedoch erlaubt die Zwischenpufferung derDaten eine Entkopplung der Abläufe des Benutzerprozesses und des Gerätes
235
Schlichter, TU München 8.3. GERÄTEVERWALTUNG
Prozess
Gerät
Prozess
Gerät
Prozess
Gerät
Prozess
Gerät
ohne einfach doppelt zirkulär
BS
Falls keine Pufferung erfolgt, muss sichergestellt werden, dass der von der E/Abetroffene Teil des virtuellen Adressraums des Prozesses nicht ausgelagert wird,ansonsten kann es passieren, dass das Gerät die E/A nicht ausführen kann, da derbenutzerseitige Puffer gerade auf die Festplatte ausgelagert wurde.
• einfach: auf Puffer wird wechselseitig über BS von Benutzerprozess und Gerätzugegriffen. Bei der Eingabe füllt das Gerät zunächst den Puffer, anschließendliest der Prozess die Daten. Während der Bearbeitung des Datenblocks durchden Benutzerprozess kann das Gerät bereits den nächsten Datenblock in denPuffer transferieren. Beim Schreiben können die Daten schnell in den Puffertransferiert werden, womit der Benutzerprozess nach kurzer Zeit weiterarbeitenkann.
• doppelt: Benutzerprozess und Gerät können parallel arbeiten. Während derBenutzerprozess den ersten Puffer leert, kann das Gerät bereits den 2. Pufferbefüllen.
• zirkulär: Koordination der Zugriffe von Benutzerprozess und Gerät, um ge-genseitiges Überschreiben zu vermeiden. Dies ist insbesondere problematisch,wenn eine Komponente sehr viel schneller Daten in den Puffer schreibt, als siedie andere Komponenten daraus lesen kann.
• Wiederholte PufferungPufferung ist ein weitverbreitete Technik; jedoch bei häufiger Pufferung istmehrfaches Kopieren der Daten notwendig, darunter leidet die Geschwindigkeitdes Gesamtsystems. Falls das Schichtenreferenzmodell der Rechnernetze
236
Schlichter, TU München 8.3. GERÄTEVERWALTUNG
betrachtet wird, kann es sein, dass noch zusätzliche Pufferungen mitphysikalischem Kopieren zwischen den Schichten erfolgt.
ProzessBenutzer
Adressraum
BS-Kern
Adressraum
Netzwerk
Controller
Spooling
Spooling ermöglicht die einfache Verwendung exklusiv nutzbarer Geräte imMehrprogrammbetrieb, z.B. Drucker. Prozesse greifen nicht direkt auf das Gerätzu, sondern geben den Auftrag an den Spoolerdämon; nur der Spoolerdämoninteragiert direkt mit dem Gerät über den Gerätetreiber.
P1
Benutzerprozesse
Pn
Systemprozess
Spooler
Dämon
Spooling
Verzeichnis
E/A-System
Treiber
Funktionsaufrufe
für Gerät
Controller
Gerät
Aufträge der Benutzerprozesse werden im Spooling Verzeichnis gespeichert,bevor sie der Spoolerdämon dann ausführt. Die Koordination der Zugriffe auf dieexklusive Ressource über Semaphore ist deshalb nicht notwendig.
237
Schlichter, TU München 8.4. RAID
8.4 RAID
Erhöhung der Plattenkapazität durch Zusammenschluss von mehreren kleinenFestplatten zu einer großen virtuellen Platte. Dadurch ergeben sich eine höhereGeschwindigkeit und eine bessere Zuverlässigkeit.
⇒ RAID = redundant array of inexpensive disks. Früher waren RAIDSvor allem aus billigen Festplatten zusammengesetzt, um auf diese Weisekostengünstige Platten zu erhalten. Heute stehen die höhere Zuverlässigkeitund die hohen Transferraten im Vordergrund; deshalb wird für das "I" statt"inexpensive" oft "independet" verwendet.
Für das BS sieht RAID wie eine einzelne Festplatte aus.
keine Änderung an Anwendungssoftware notwendig, um ein RAID-Systemnutzen zu können.
• üblicher Plattencontroller wird durch einen RAID Controller ersetzt.
• Daten werden über die Platten verteilt, was eine parallele Verarbeitungermöglicht.
• höhere Zuverlässigkeit durch Redundanz.
• Unterscheidung zwischen unterschiedlichen Varianten
RAID Level 0 bis RAID Level 6. Diese Unterscheidung ist nicht alseine Hierarchie von Varianten zu sehen. Alle 6 Formen sind relativunterschiedlich.
• RAID Level 0Der gesamte Speicherbereich der virtuellen Festplatte wird in gleich großeAbschnitte ("strips"), z.B. 1 Block oder 1 Sektor. Die Strips werden nach demRound-Robin Strategie auf die physischen Platten verteilt;
Datenpuffer umfasst mehr als einen Strip⇒Verteilung auf mehrere Platten.In diesem Fall zerlegt der RAID Controller den Schreibbefehl in einzelneKommandos, einen für jede betroffene Platte. Die Befehle für jeden Plattewerden dann parallel ausgeführt. Damit haben wir parallele Ein-/Ausgabe,ohne dass die Anwendungssoftware etwas davon mitbekommt.
238
Schlichter, TU München 8.4. RAID
Strip 0
Strip 4
Strip 8
Strip 1
Strip 5
Strip 9
Strip 2
Strip 6
Strip 10
Strip 3
Strip 7
Strip 11
RAID Level 0 arbeitet am besten mit großen Anfragen, d.h. Anfrage,die mehrere Strips umfassen. Es arbeitet eher schlecht für Abfragen, diejeweils nur einen Strip betreffen. Die Zuverlässigkeit ist abhängig von denZuverlässigkeiten der einzelnen Festplatten; es gibt keine Redundanz; RAID 0bietet eine schlechtere Zuverlässigkeit als eine einzelne große teuere Festplatte.
• RAID Level 1Es werden alle Platten verdoppelt. Im Beispiel existieren 2 Hauptplatten und 2Backup-Platten.
Bei einem Schreibvorgang wird jeder Strip doppelt geschrieben.
Bei einem Lesevorgang können beide Platten genutzt werden.
Sehr gute Ausfallsicherheit.
Während die Schreibgeschwindigkeit nicht besser gegenüber einer einzelnenPlatte ist, erhöht sich die Lesegeschwindigkeit durch die parallele Nutzung vonHaupt- und Backup-Platten.
Strip 0
Strip 2
Strip 4
Strip 1
Strip 3
Strip 5
Strip 0
Strip 2
Strip 4
Strip 1
Strip 3
Strip 5
Spiegelplatten
• RAID Level 2Striping erfolgt auf Bitebene mit zusätzlichen Parity-Platten. Beispielsweisewird jedes Byte in 4-Bit Stücke unterteilt, zusätzlich wird ein 3-Bit HammingCode generiert. Dadurch lassen sich Bitfehler nicht nur erkennen, sondern auchkorrigieren.
Alle Platten arbeiten synchron.
239
Schlichter, TU München 8.5. DISK SCHEDULING
Sehr gute Ausfallsicherheit, mit weniger Platten als bei RAID Level 1.
Bit 0 Bit 1 P0 P1Bit 2 Bit 3 P2
Paritybits
Thinking Machines unterstützt 32 Bit Datenworte und fügt 6 Parity Bitshinzu, um ein 38 Bit Hamming Wort zu erhalten. Diese werden dann auf38 synchron laufende Festplatten verteilt. Die Hamming-Prüfsumme wird vomRAID-Controller errechnet bzw. bei gelesenen Daten überprüft.
• Die restlichen Varianten RAID Level 3 - 6 können im Tanenbaum nachgelesenwerden. Kombinationen von RAID Level sind möglich, z.B. RAID 0+1. Hierdie Festplatten werden gespiegelt. Jeweils auf den Hauptplatten und denSpiegelplatten werden die Daten durch Stripes gespeichert. Dadurch ergibtsich sowohl ein Performanz- als auch ein Zuverlässigkeitsgewinn. Es gibt auchRAID 1+0: in diesem Fall werden die Platten paarweise verdoppelt, d.h. jedesStrip wird auf einer Hauptplatte und der zugehörigen Spiegelplatte gespeichert.
8.5 Disk Scheduling
Zugriffszeit für Transfer von Daten von/zu Festplatte setzt sich zusammen aus
Suchzeit des Lese-/Schreibkopfes. Dies ist die Zeit, bis der Arm über dementsprechenden Zylinder steht, der den gewünschten Sektor enthält (seektime).
Rotationsverzögerung. Dies ist die Zeit, bis sich der entsprechende Sektorunter den Kopf dreht (rotational latency).
Dauer der Datenübertragung. Die Transferzeit wird durch die benötigteRotationszeit bestimmt, um die geforderte Anzahl an Byte auszulesen. DieDisk-Bandbreite ist die Gesamtzahl der übertragenen Bytes geteilt durch dieZeit zwischen der Initiierung des Requests bis zur Beendigung.
Bei den meisten Platten dominiert die Suchzeit gegenüber den anderen Zeiten,weshalb die Reduzierung der Suchzeit die Systemgeschwindigkeit erheblichverbessern kann. Viele Plattentreiber verwalten eine Tabelle, die über dieZylindernummer indiziert wird und in der alle noch auszuführenden Anfragen
240
Schlichter, TU München 8.5. DISK SCHEDULING
für jeden Zylinder in einer verketteten Liste abgespeichert sind. Falls die Listeder offenen E/A-Requests jeweils nur einen Auftrag enthält, verhalten sich alleAlgorithmen wie FCFS.
• FCFS SchedulingDie E/A-Requests werden in der Reihenfolge ihres Eintreffens abgearbeitet(First Come-First Served). Angenommen die E/A-Requests betreffen Blöckeder Zylinder
98, 183, 37, 122, 14, 124, 65, 67. "Der Arm stehe zu Beginn beim Zylinder53."
0 20014 9837 53 65 67 122 124 183
Problem dieses Verfahrens ist, dass der Arm je nach E/A-Request sehr vielbewegt werden muss, so dass viel Suchzeit notwendig ist. Für dieses Beispielsind insgesamt 640 Zylinderbewegungen notwendig.
• SSTF SchedulingBeim SSTF-Verfahren (Shortest Seek Time First) wird als nächstes derE/A-Request bearbeitet, der am nächsten zur aktuellen Position ist. DieAusgangsliste
98, 183, 37, 122, 14, 124, 65, 67 wird umsortiert zur Bearbeitungsreihen-folge
65, 67, 37, 14, 98, 122, 124, 183. Der Arm stehe zu Beginn beim Zylinder53.
241
Schlichter, TU München 8.5. DISK SCHEDULING
0 14 9837 53 65 67 122 124 183
Dieses Verfahren ist vergleichbar mit der Strategie Shortest-Job-First bei derRechnerkernvergabe. In dem Beispiel sind nur mehr 236 Zylinderbewegungennotwendig.
Es kann jedoch zum Verhungern von E/A-Requestes kommen, wenn neue E/A-Aufträge eintreffen, deren Zylinderpositionen näher an den gerade aktuellenPositionen liegt. Angenommen die Abarbeitungsfolge enthält die Reihenfolge14 und anschließend 183. Während der Bearbeitung von 14 trifft ein neuerAuftrag, der näher bei 14 liegt, dann wird dieser zunächst behandelt.Währenddessen trifft wieder ein Auftrag, der näher bei 14 liegt, dann wirddieser wieder der 183 vorgezogen. Der Algorithmus bewegt sich also von 14weg und wieder zurück, ohne jedoch bis zu 183 zu gelangen⇒ vergleichbaresProblem bei Aufzügen in Hochhäusern.
• SCAN SchedulingDer SCAN-Algorithmus bearbeitet die E/A Requests zunächst in eine Richtungbis zum Plattenende, und anschließend zurück zum anderen Plattenende. DieAusgangsliste
98, 183, 37, 122, 14, 124, 65, 67 wird umsortiert zur Bearbeitungsreihen-folge
37, 14, 65, 67, 98, 122, 124, 183. Der Arm stehe zu Beginn beim Zylinder53 und es wird angenommen, dass er sich in Richtung Zylinder 0 bewegt.
0 14 9837 53 65 67 122 124 183
242
Schlichter, TU München 8.6. MULTIMEDIA SYSTEMS
Dieses Verfahren wird gelegentlich auch Aufzugalgorithmus genannt. Esreduziert die Anzahl der Zylinderbewegungen auf 208. Trifft ein neuer E/A-Request ein, der sich auf dem aktuellen Weg des Arms befindet, wird er anentsprechender Stelle bearbeitet. Andernfalls muss die Bearbeitung warten, bissich der Arm das Plattenende erreicht hat und sich nun in die andere Richtungzurückbewegt.
8.6 Multimedia Systems
Multimedia umfasst eine Vielzahl, heute populärer Applikationen
Audio und Video Clips (z.B. MP3 und MPEG Dateien).
Live Webcasts. Beispielsweise werden oft Großereignisse, wie z.B. dieEröffnungsfeier zu den Olympischen Spielen in Peking, als Live Stream überdas Internet übertragen.
Mögliche Endgeräte für den Empfang von Multimedia Daten
Desktop PCs oder mobile Endgeräte, wie PDAs, Smartphones.
8.6.1 Zustellung von Mediendaten
Multimedia Daten können in einem normalen Dateisystem gespeichert werden.Für die Auslieferung gelten jedoch spezielle Zeitbedingungen, z.B.
Auslieferung von Videodaten gemäß einer Rate von 24 - 30 Frames/Sekunde.Nur auf diese Weise kann sichergestellt werden, dass das menschliche Augeden Filmablauf als gleichmäßig und normal sieht. Langsamere Frameratenwerden vom Menschen als abgehackt interpretiert.
Unterscheidung zwischen
• lokales Playback. Die Mediendaten werden vom Server herunter geladen undim lokalen Dateisystem gespeichert. Von dort werden sie dann abgespielt, z.B.Laden und Abspielen eines Films oder MP3-Datei auf dem Laptop.
• StreamingZustellung der Mediendaten von einem Server über ein Netzwerk zum Client.Der Client beinhaltet die Abspielsoftware. Er kann ein PC oder ein mobilesEndgerät sein. Unterscheidung zwischen
– progressives Download. Der Client beginnt mit dem Abspielen derMediendaten bereits während der Download noch im Gange ist. Das
243
Schlichter, TU München 8.6. MULTIMEDIA SYSTEMS
Abspielen beginnt, nachdem ein gewisser Anteil der Daten empfangenwurde. Die Mediendaten werden in einer Datei auf dem Client gespeichert.
– Real-time Streaming. Die Mediendaten werden über das Netzwerk demClient zugestellt, ohne sie jedoch auf dem Client zu speichern.
Live Streaming. Die Mediendaten werden von einer Veranstaltungaufgenommen und sofort an die Empfänger weitergegeben. Ein Vor- oderZurückspulen wie bei einer Aufzeichnung ist nicht möglich.On-Demand Streaming. Zustellung von Aufzeichnungen. RandomZugriff möglich.
Beispiele von Streaming Produkten: RealPlayer, Apple Quicktime, WindowsMedia Player. Diese Produkte umfassen sowohl den client Mediaplayer zumAbspielen als auch eine Serverkomponent zum Streamen der Mediendaten.
8.6.2 Eigenschaften von Multimedia Systemen
Multimedia Daten können sehr groß sein. Z.B. sind für die Speicherung eines100 Minuten MPEG-1 Videos ca 1,125 GByte notwendig. 100 Minuten HDTVerfordern ca 15 GByte.
deshalb Komprimierung der Daten
⇒ ausreichende Rechenleistung für die Dekompression und Anzeige derMediendaten unter Einhaltung der Zeitbedingungen. Dies erfordert, dass denProzessen, die die Mediendaten dekomprimieren und anzeigen, ausreichendeCPU-Zyklen zugeordnet werden. Beispielweise können hierbei die CPU-Zuteilungsstrategien "Earliest Deadline First (EDF)" und "Rate MonotonicScheduling".
Disk Scheduling
Für den Zugriff auf Mediendaten gelten die beiden Randbedingungen
Zeitbedingungen und hohe Datenrate. Da Festplatten relativ niedrige Übertra-gungsraten und hohe Latenzzeiten haben, sind Zugriffsverfahren bei mehrerenausstehenden Aufträgen notwendig, die einerseits die Zeitbedingungen erfül-len und andererseits hohe Datenraten ermöglichen.
Kombination von SCAN Scheduling mit EDF ("Earliest-Deadline-First"). EDFsortiert die ausstehenden Auträge gemäß der Zeitpunkte, wann sie abgeschlossensein müssen (Deadline).
• Aufträge werden entsprechend ihrer Deadline geordnet (EDF).
244
Schlichter, TU München 8.6. MULTIMEDIA SYSTEMS
• Aufträge mit derselben Deadline werden entsprechend SCAN Reihenfolgeabgearbeitet.
• Aufträge mit ähnlichen Deadlines können entsprechend der SCAN Reihenfolgeumsortiert werden, solange die Zeitbedingungen noch eingehalten werden.
• Einteilung der Aufträge in Zeitbereiche (z.B. 100 ms)
Auftrag Deadline Zylinder
A 150 25
B 201 112
C 399 95
D 94 31
E 295 185
F 78 85
G 165 150
H 125 101
I 300 85
J 210 90
0
199
100 F
D
Zeit
A
H
G
E
B
J
I
C
Zur ersten Gruppe (0-100ms) gehören die Aufträge D und F, zur zweitenGruppe (101-200ms) die Aufträge A, G und H, zur 3. Gruppe (201-300ms)die Aufträge B, E und J sowie zur letzten Gruppe (301-400ms) die Aufträge Cund I.
245
Kapitel 9
Sicherheit in Rechensystemen
In Rechensystemen, die mehreren Benutzern zugänglich sind, ist eine Kontrolledes Zugriffs auf das Rechensystem selbst, dessen Dienstleistungen und Datenbe-stände erforderlich.
9.1 Fragestellungen
Dieser Abschnitt behandelt die Sicherheitsproblematik in zentralen Rechensyste-men. Dazu werden verschiedene Schutzmechanismen auf Betriebssystemebenevorgestellt.
• Zugriffsschutz in Rechensystemen.
• Schutzmatrix, insbesondere Zugriffskontrolllisten und Capability-Listen.
• Mobiler Code.
Die verschiedenen Aspekte der Sicherheit in Rechensystemen werden nureinführend, und nicht erschöpfend behandelt. Für eine detaillierte Behandlung derSicherheitsproblematik sei der Leser auf entsprechende Lehrveranstaltungen oderdie Literatur verwiesen.
9.2 Motivation
Was versteht man unter Sicherheit im Bezug auf Rechensysteme?
246
Schlichter, TU München 9.2. MOTIVATION
Jemand: Unterscheidung von Personen und Gruppen von Personen
davon abhalten: durch technische und organisatorische Maßnahmen
einige: Begrenzung durch unser Vorstellungsvermögen
unerwünschte Dinge zu tun:1) nicht autorisiert Daten lesen (Geheimhaltung, Vertraulichkeit),2) nicht autorisiert Daten schreiben (Integrität),3) unter "falscher Flagge" arbeiten (Authentizität),4) nicht autorisiert Ressourcen verbrauchen (Verfügbarkeit),usw.
zu tun.
• Unterscheidung zwischen Angriffen von
innen. "Der Angreifer ist in das Rechensystem bereits eingeloggt und ver-schafft sich illegalen Zugriff auf Ressourcen oder Berechtigungen, z.B.Systemadministrator-Rechte. Mögliche Angriffstechniken sind TrojanischePferde, Login-Attrappen, die Nutzung von Hintertüren in einem Software-system ("trap door"), Phishing zum Abgreifen von Passwörtern oder dieAusnutzung eines künstlich herbeigeführten Pufferüberlaufs."
außen. "Durch die Vernetzung von Rechnern finden verstärkt auch Angriffevon entfernten Rechnern über ein Rechnernetz (z.B. das Internet) statt.Beispiele für mögliche Angriffstechniken sind sogenannte "war-dialer"(Ausprobieren von Telefonnummern und Passwörtern) oder die Verbreitungvon Viren."
• Beispiel: Login-AttrappeNutzung von Login-Attrappen in Rechnerumgebungen, wo Rechner vonmehreren Benutzern verwendet werden, um geschützte Benutzerpasswörter zuerfassen (z.B. in Informatikhalle der Informatik-Fakultät).
– Angreifer startet ein Benutzerprogramm, das am Bildschirm einen Login-Screen simuliert. Der Angreifer gibt, ohne sich auszuloggen den Rechner
247
Schlichter, TU München 9.2. MOTIVATION
frei. Da am Bildschirm der Login-Screen angezeigt wird, ist ein nachfolgen-der Benutzer der Meinung, dass der Rechner verfügbar ist (es sitzt ja niemanddavor und der vorhergehende Benutzer habe durch Ausloggen seine Sitzungbeendet, da der wohlbekannte Login-Screen angezeigt wird).
– Der ahnungslose Benutzer tippt Benutzername und sein privates Passwort.Angreiferprogramm speichert Benutzername und Passwort in einerDatei.Angreiferprogramm terminiert das aktuelle Shell-Programm ("kill"Systemaufruf) ⇒ Login-Sitzung des Angreifers wird beendet undregulärer Login-Screen wird angezeigt.
Der ahnungslose Benutzer nimmt an, dass er sich beim ersten Eintippenseines Namens oder seines Passwortes vertippt hat und gibt die beiden Datenerneut ein. Der Angreifer kann auf diese Weise die Passwörter der anderenBenutzer erfassen.
– Abhilfe: Login-Sequenz wird durch Tastensequenz gestartet, die von einemBenutzerprogramm nicht erfasst werden kann, z.B. CTRL-ALT-DEL beiWindows 2000. Falls ein Benutzer diese Tastensequenz eingibt, wird deraktuelle Benutzer automatisch ausgeloggt und das Login-Programm durchdas Betriebssystem gestartet. Es gibt keinen Weg, um dieses Verhalten desBetriebssystems zu umgehen.
• Beispiel: VirusEin Virus ist ein Programm, dessen Code an ein anderes Programm anfügt istund sich auf diese Weise reproduziert. 1 Zusätzlich kann ein Virus noch andereFunktionen aufrufen, z.B. Löschen von Dateien, Senden von Nachrichten etc.Oft ist die Reproduktion des Virus und die Ausführung der Virusfunktion zeitlichgetrennt, d.h. die Virusfunktion wird erst nach Eintreten eines bestimmtenDatums getriggert. Dadurch wird erreicht, dass sich ein Virus relativ unbemerktausbreiten kann (z.B. über das Internet), ohne dass die Benutzer bereitsfrühzeitig merken, dass ihr Rechner mit dem Virus infiziert ist.
Virus schläft bis infiziertes Programm ausgeführt wird.
Start des infizierten Programms führt zur Virusreproduktion.
Ausführung der Virusfunktion ist u.U. mit einem zeitlichen Datumversehen.
mögliche Virustypen sind
1[Tanenbaum2001, S 617]
248
Schlichter, TU München 9.2. MOTIVATION
– Boot Sector Virus. BIOS liest beim Start des Rechners den Master BootRecord (MBR) und führt ihn aus. Ein Boot Sector Virus trägt sich im MBRein und wird damit bei Rechnerstart jeweils ausgeführt. Der ursprünglicheMBR Inhalt wird oft auf einen anderen Platz der Festplatte kopiert undvon Virus automatisch aufgerufen, um den Rechnerstart zu ermöglichen.Nach dem Start speichert sich der Virus oft im Speicherbereich desUnterbrechungsvektors, um nach jedem Systemaufruf wieder die Kontrollezu erhalten.
– Macro Virus. Programme wie Word oder Excel erlauben dem Benutzerdas Schreiben von Macroprogrammen (Visual Basic). Beispielsweise kannein Angreifer für ein Word-Dokument ein Macro schreiben, das mit derOpen File Funktion verbunden ist. Integriert in das Macro ist der Virusdes Angreifers. Da Macros i.a. alle Systemfunktionen des Betriebssystemsaufrufen dürfen, hat der Virus Zugriff auf die volle Funktionalität. DieVerbreitung erfolgt durch Versenden des Dokuments, z.B. als EmailAttachment. Öffnen des Dokuments führt zur Ausführung des Macros unddamit des Virus.
– Ausführbares Programm als Virus. Das Virusprogramm sucht nach seinemAufruf nach geeigneten ausführbaren Programmen (z.B. "exe Dateien") imgesamten Dateiverzeichnis und infiziert diese mit dem Virus; beispielsweisedurch Überschreiben des Binärprogramms mit dem Virusprogramm. DieLänge der Datei wird dadurch verändert (kann genutzt werden durchAntivirenprogramme, um den Virus zu erkennen).
– Verbreitung von VirenFrüher diente der Austausch von Datenträgern (z.B. Floppy Disk), jetzt dasInternet
als Attachment zu EmailsLesen des Adressbuchs und automatische Generierung von Emailsmit Virus Attachment an alle Adressbucheinträge (z.B. von MicrosoftOutlook). Dabei wird oft das Subject-Feld so besetzt, dass der Empfängerdas Gefühl hat, er empfange eine persönliche Email von einemBekannten.
• Beispiel: PufferüberlaufDurch einen künstlich herbeigeführten Pufferüberlauf kann ein Angreifer dieAusführung seines eigenen Programms veranlassen und oft auch noch dieSystemadministrator-Berechtigung (root) erlangen. 2
2[Tanenbaum2001, S 610]
249
Schlichter, TU München 9.2. MOTIVATION
– HintergrundDie meisten C-Compiler und Laufzeitsysteme überprüfen nicht die Einhal-tung der Feldgrenzen. Da viele aktuelle Betriebssysteme auf der Basis von Crealisiert wurden, ist diese Problematik von großer Bedeutung.
int i;char c[256];i = 12000;c[i] = 0;
Die Codesequenz ist zwar falsch. Das Laufzeitsystem führt jedoch keineÜberprüfung durch; der Fehler bleibt unentdeckt. In den meisten Fällenführt dieser Fehler über kurz oder lang jedoch zu einem Programmabsturz(oft ein Nullpointer). Ein Angreifer kann diese Eigenschaft nutzen, umTeile des Laufzeitkellers zu überschreiben. Ein Beispiel wäre, das Feldc für die Speicherung des Pfadnamen einer Datei vorzusehen. Da dasBetriebssystem nur maximal 256 Zeichen pro Pfadenamen unterstützt, istfür den Programmierer die Länge von c ausreichend. Ein Angreifer kann nuneinen Datei-Pfadnamen angeben, der erheblich länger als 256 ist.
∗ String Library in CImplementierung der Unix Funktion gets (get string from stdin)
keine Möglichkeit zur Spezifikation der Anzahl der zu lesendenZeichen
char *gets(char *dest) {int c = getc();char *p = dest;while (c != EOF && c != ’\n’) {
*p++ = c; c = getc();}*p = ’\0’;return dest;
}◦ ähnliche Probleme auch bei anderen Unix Funktionen
strcpy: kopiert einen String beliebiger Längescanf, fscanf, sscanf: mit %s Konvertierungsspezifikation.
wobei scanf("...", liste der Variablen) gilt.◦ Angreifbarer Buffer Codevoid echo() {
char buf[4]; /* sehr klein */gets(buf);puts(buf);
}
250
Schlichter, TU München 9.2. MOTIVATION
int main() {printf("Type a string:");echo();return 0;
}unix> bufdemo
Type a string: 123123
unix> bufdemoType a string: 12345Segmentation Fault
Keller von main
Rückkehradresse
[3] [2] [1] [0]
Keller von echo
buf
Information
für UP Aufruf
– Veränderung der Rücksprungadresse
Programm
Variable
Hauptprogramm
Keller
Ablauf
Hauptprogramm
SP
Programm
Variable
Hauptprogramm
Rückkehradresse
nach Aufruf der
Prozedur A
SP
lokale Variable
von A
CFeld C
Programm
Variable
Hauptprogramm
Rückkehradresse
nach Pufferüberlauf
lokale Variable
von A
CFeld C
SP
Durch sorgfältiges Analysieren und Berechnen des Speicherlayouts kannder Angreifer bei Pufferüberlauf die Rückspungadresse der aufgerufenenProzedur überschreiben. Der Angreifer überschreibt den Laufzeitkeller von
251
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
A einschließlich des Feldes C und der Rücksprungadresse. Die neueRücksprungadresse zeigt an den Anfang des Puffers c, an deren Stelledas vom Angreifer gewünschte ausführbare Programm steht. Der Angreiferüberschreibt als nicht nur die Rücksprungadresse, sondern trägt auch seinAngriffsprogramm in den Keller des Hostprogramms ein. Beispielsweisebeinhaltet die Zuweisung an das Feld c nicht den Dateinamen, sondern einenausführbaren binären Programmcode."Anstelle des auf 255 Zeichen beschränkten Dateinamen wird in Feld cein längerer Programmcode eingetragen, der auch die Rücksprungadresseüberschreibt."∗ Falls das attackierte Programm mit root-Berechtigung (setuid root in
Unix) abläuft, läuft das aufgerufene Programm im Puffer auch mit root-Berechtigung.
Angreifer kann seiner aufrufenden Shell root-Berechtigung verleihen.Dadurch erwirbt der Angreifer Superuser Rechte für seine eigenenProgramme und hat damit Zugang auf das gesamte Betriebssystem.
– GegenmaßnahmenUnterscheidung
sichere Programmierung. Durch sorgfältige Programmierung, bei der ins-besondere alle Eingabewerte geprüft und Bereichsgrenzen kontrolliert,kann man verhindern, Ziel von Buffer Overflow Angriffen zu werden.Maßnahmen zur Übersetzungszeit. Ein StackGuard Tool fügt einspezielles Kontrollzeichen direkt hinter die Rücksprungadresse auf demStack ein. Zusätzlich wird automatisch Code hinzugefügt, der vor demRücksprung überprüft, ob das Kontrollzeichen verändert wurde.Maßnahmen zur Laufzeit. Das Java Laufzeitsystem überprüft zurLaufzeit die Einhaltung der Bereichsgrenzen automatisch.
9.3 Schutzmechanismen
Schutz von gespeicherter Information vor Diebstahl, unerwünschter Manipulationund Verletzung der Vertraulichkeit ist ein zentrales Anliegen in allen Mehrbenut-zersystemen. 3 Der Schutz sollte jedoch so organisiert werden, dass dadurch dergewollte Austausch sowie die gemeinsame Nutzung von Programmen und Datenzwischen den beteiligten Nutzern nicht unnötig eingeschränkt werden. Die Forde-rung ist ein flexibles Schutzkonzept, das an die Anwendungsumgebung angepasstwerden kann.
3[Nehmer2001, S 293]
252
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
9.3.1 Anforderungen
Für einen Schutzmechanismus gelten die folgenden Anforderungen
• alle Objekte eines Systems müssen eindeutig und fälschungssicher identifiziertwerden. Insbesondere muss auch der Aufrufer eines Dienstes eindeutigund fälschungssicher identifiziert werden. Dies ist gerade für Client-ServerBeziehungen von großer Bedeutung, z.B. die eindeutige Identifizierung desClient bei Ecommerce Anwendungen.
• externer Benutzer eines Systems muss eindeutig und fälschungssicher identifi-ziert werden ⇒ Authentifizierung. Die Zuordnung zu einem Benutzerprozessmuss fälschungssicher sein.
• Zugriff auf Objekte sollte nur über zugehörige Objektverwaltung geschehen.
• Zugriff auf Objekte nur, wenn Zugreifer die nötige Rechte hat.
• Rechte müssen fälschungssicher gespeichert werden; Weitergabe von Rechtendarf nur kontrolliert erfolgen.
• Prinzip der minimalen Rechte. Jedem Programm oder Benutzer sollen für dieObjekte nur die Rechte eingeräumt werden, die für die momentane Arbeitzwingend erforderlich sind. Beispielsweise werden unnötige Ports geschlossen.
• grundlegenden Schutzmechanismen sollen ohne großen Aufwand überprüftwerden können. Dies bedeutet, dass am besten ein einheitliches Schutzkonzeptfür alle zu schützenden Objekte verwendet wird, und dass die Implementierungzentral in einem möglichst kleinen Baustein, einem Schutzkern im Betriebssy-stem, erfolgt.
9.3.2 Ebenen des Zugriffschutzes
Man unterscheidet die folgenden Ebenen des Zugriffsschutzes. 4
Maschinenschutz: Kontrolle des physischen Zugangs zum Rechensystem."Beim direkten Zugang erfolgt die Kontrolle typisch durch organisatorischeund bauliche Maßnahmen (siehe LRZ, wo Zugang über die Brücke ermöglichtwird.). Bei Zugang zu einem Rechner über ein Kommunikationsnetz sindspezielle Hardware- und Software-Schutzeinrichtungen vorzusehen, z.B.Benutzer meldet seinen Zugangswunsch an und Rechner ruft auf einer vorherdefinierten Nummer zurück (unter der der Benutzer erreichbar ist)."
4[Siegert1991, S 155]
253
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
Zugangskontrolle: Kontrolle des logischen Zugangs zum Rechensystem, d.h.Ausführung von Aufträgen im Rechensystem. Hier spielt die Authentifizie-rung des Benutzers eine wichtige Rolle, z.B. Passwörter oder biometrischeEigenschaften, um den Benutzer eindeutig zu identifizieren. Im Rechensy-stem sind Verfahren notwendig, um die Korrektheit der angegebenen Identitätzu überprüfen (z.B. Passwort-Datei).
Berechtigungskontrolle: Kontrolle des Benutzerzugriffs auf einzelne Daten-bestände und die Ausführung einzelner Dienste.
Systemschutz: Gewährleistung der Integrität der Schutzmechanismen. Hiermuss sichergestellt werden, dass die Schutzmechanismen in Hardware undSoftware durch Angreifer nicht modifiziert werden können, um ein Umgehenund Aushebeln des Schutzes durchzuführen.
9.3.3 Schutzmatrix
Das Konzept der Schutzmatrix wurde von B. Lampson eingeführt. Es verknüpftSchutzdomänen mit den zu schützenden Objekten.
• SchutzdomänenDefinition: Eine Schutzdomäne ist eine Menge von (Objekt, Rechte) Paaren.
"Jedes Paar spezifiziert ein Objekt und eine Menge von Operationen, die aufdiesem Objekt ausgeführt werden dürfen. Meist entspricht eine Schutzdomäneeinem Benutzer, d.h. sie gibt an, was dieser Benutzer tun darf. Negative Rechte,d.h. das was er nicht tun darf, werden nicht explizit angegeben."
Datei1[R]
Datei2[RW]
R = read, W = write, X = execute
Printer1[W]
Datei3[RW]
Datei1[RWX]
Datei4[R]
Floppy1[R]
Domäne 1 Domäne 2
254
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
Das Beispiel zeigt mehrere Objekte mit Ihren Rechten und ihre Zuordnungzu den Domänen. Gleiche Objekte (im Beispiel Datei1) können mitunterschiedlichen Rechten unterschiedlichen Domänen zugeordnet werden.
– Verknüpfung eines Prozesses mit einer Schutzdomäne. "Dadurch wird derHandlungsspielraum des Prozesses bei seiner Ausführung eingeschränkt.Die Zuordnung einer Schutzdomäne zu jedem Prozess geschieht in einerallen Zugriffsversuchen vorangeschalteten Authentisierung. Insbesonderewird die hinter einem Prozess stehende Identität geprüft, z.B. die Identitätdes Benutzers oder die eines Servers."
– zu jedem Zeitpunkt wird ein Prozess in einer Schutzdomäne ausgeführt.Ein Prozess kann während seiner Ausführung die Schutzdomäne wechseln.Dadurch können Prozesse während ihres Lebenszyklus auf unterschiedlicheObjekte mit unterschiedlichen Rechten zugreifen.
Beispiel Unix: bei Ausführung eines Systemaufrufs wechselt der Prozessvom Benutzermodus in den Systemmodus ("kernel mode")⇒ entsprichteinem Wechsel der Schutzdomäne. Im Systemmodus kann der Prozessauf die geschützten Ressourcen des Systems zugreifen.
– Das Paar (Prozess P, Schutzdomäne D) wird als Subjekt bezeichnet."Subjekte sind im Kontext einer Schutzdomäne agierende Prozesse."
Der Zugriffswunsch eines Subjektes S auf ein Objekt o ist definiert als(D, o, a), wobei D die Schutzdomäne und a die Zugriffsart ist.
– Matrix-DatenstrukturKonzeptuell verwendet ein Betriebssystem eine Matrix-Datenstruktur, umdie Zuordnung Objekt-Schutzdomäne zu verfolgen.
read
read write
execute
Datei1
read write
Datei2
read write
read write
Datei3
read
Datei4
write
write
Printer1
read
Floppy1
Objekt
Domäne
1
2
Jedes Matrixelement spezifiziert die Zugriffsarten, die in einer Schutzdomäneauf das zugehörige Objekt erlaubt sind. Der Domänenwechsel selbst kann mitHilfe des Matrixmodells realisiert werden. Zum Beispiel können als Objektezusätzlich die Schutzdomänen mit aufgenommen werden. Falls ein Wechselvon einer Domäne 1 in eine Domäne 2 erlaubt sein soll, wird in die Zeile
255
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
der Domäne 1 in der Spalte für Objekt Domäne 2 die Zugriffsart "enter"eingetragen.
• SchutzmonitorJeder Zugriff (D, o, a) eines Subjektes S wird mit Hilfe eines Schutzmonitorsüberprüft. Der Schutzmonitor prüft anhand seiner intern gespeicherten Schutz-matrix, ob in der Zeile von D ein Zugriffsrecht a für das Objekt o existiert. Beipositivem Ausgang wird der Zugriff zugelassen, andernfalls wird ein Schutz-alarm ausgelöst und der Zugriff unterdrückt. Der Schutzmonitor läuft meist ineinem geschützten Teil des Betriebssystems ab (z.B. Betriebssystemkern).
Schutzmonitor
Schutz
matrixP
Prozess
Betriebssystem - Systemmodus
D
Schutz-
domäneo1
o2
o3
Objekte
(D,o1,a)
Subjekt
Benutzermodus
– der Schutzmonitor ist vertrauenswürdig.
– Subjekte können in keinem Fall auf Objekte unter Umgehung desSchutzmonitors zugreifen.
– neue Prozesse müssen sich gegenüber dem Schutzmonitor authentifizieren."Anonyme Prozesse, die noch ohne Schutzdomäne sind, übergeben demSchutzmonitor Namen und Passwort des Benutzers, in dessen Auftrag siehandeln. Erkennt der Schutzmonitor die Identität an, veranlasst er denBetriebssystemkern einen Verweis auf die zugeordnete Schutzdomäne imProzesskontrollblock zu speichern; der Prozess kann nun auf die erlaubtenObjekte zugreifen."
• Schutzmatrix ist typischerweise sehr groß und dünn besetzt ⇒ einedirekte Implementierung ist deshalb nicht sinnvoll. "Deshalb ist man dazuübergegangen die Schutzmatrix entweder spaltenweise oder zeilenweise zuspeichern, um den Speicheraufwand zu reduzieren. Leere Matrixelementewerden nicht gespeichert."
• ZugriffskontrolllisteZugriffskontrolllisten ("Access Control List", ACL) realisieren die spaltenwei-se Speicherung der Schutzmatrix.
256
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
jedes Objekt o besitzt seine Zugriffskontrollliste.
Element einer Zugriffskontrollliste (ACL-Element) besteht aus Paar(Prozess, Zugriffsarten). Anstelle des Prozesses können als Komponentenin einem ACL-Element auch Schutzdomänen verwendet werden. DieVerwendung von Schutzdomänen erleichtert die Zusammenfassung vonBenutzern zu einer Gruppe, die die gleichen Zugriffsrechte besitzen. JedesACL-Element repräsentiert ein Kontrollrecht für das Objekt o.
A
Prozess Benutzer
B CBenutzer
Modus
Datei D1 A: RW; B: R
Datei D2 A: R; B: RW; C: R
Datei D3 B: RWX; C: RX
System
Modus
ACL
Neben den allgemeinen Rechten wie read, write und execute können auchobjekt-spezifische Zugriffsarten in die Zugriffskontrollliste des Objektes einge-tragen werden. Für einen Prozess (Subjekt) sind nur diejenigen Zugriffsartenauf das Objekt erlaubt, die in der zugehörigen ACL eingetragen sind. MancheSchutzsysteme unterstützen auch Wildcards für die Prozessspezifikation, d.h.ein ACL-Element (*, R) bedeutet, dass beliebige Prozesse das Leserecht aufdas Objekt besitzen.
• Capability-ListeCapability-Listen ("Zugriffsausweislisten") realisieren die zeilenweise Speiche-rung der Schutzmatrix.
jeder Prozess besitzt eine Menge von Capabilities, die die erlaubtenZugriffe auf Objekte repräsentieren.
Element einer Capability-Liste besteht aus Paar (Objekt, Zugriffsarten). EinCapability gibt dessen Besitzer gewisse Zugriffsrechte für das Objekt.
257
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
A
Prozess Benutzer
B CBenutzer
Modus
System
Modus
Capability-
Liste
D1: RW
D2: R
D1: R
D2: RW
D3: RWX
D2: R
D3: RX
– Capabilities müssen geschützt werden, um Modifikationen durch den Prozessselbst zu verhindern. Alternativen sind
Speicherung im geschützten Bereich des Betriebssystems.Capabilities sind zwar im Benutzermodus dem Prozess zugeordnet; siesind jedoch verschlüsselt. "Der Prozess kann bei einem Objektzugriffdem Schutzmonitor sein zugehöriges Capability vorzeigen, jedochdieses Capability nicht selbst verändern. Eine Änderung darf nur vomSchutzmonitor vorgenommen werden. Diese Alternative ist besondersfür verteilte Systeme geeignet. Beispielsweise schickt ein Clientzusammen mit seiner Dienstanforderung auch das zugehörige Capabilityan den Server. Das Capability muss sicher übertragen werden (z.B.verschlüsselt), damit ein heimliches Kopieren und missbräuchlicheNutzung durch andere Prozesse verhindert werden kann."
– Capabilities können zeitlich begrenzt werden. Auch könnte mit einemCapability ein Kontofeld verbunden sein. Bei jeder Verwendung desCapability wird das Kontofeld reduziert. Ein Objektzugriff ist nur möglich,wenn der Kontostand ausreichend ist. Damit kann ein Capability nur für einebegrenzte Anzahl von Zugriffen beschränkt werden.
• Zusammenfassung: Zugriffskontrolllisten und Capability-Listen haben ingewisser Weise komplementäre Eigenschaften
ACLs erlauben das selektive Zurücknehmen von Rechten. Für Capabilitiesist dies eher schwierig, da die Capabilities verteilt den einzelnen Prozessenzugeordnet sind, und auch zwischen Prozessen weitergegeben werdenkönnen.
Capabilities können weitergegeben werden. Bei der Weitergabe kann derProzess die Zugriffsrechte einschränken.
258
Schlichter, TU München 9.3. SCHUTZMECHANISMEN
9.3.4 Authentifizierung
Authentifizierung eines Nutzers erfolgt meist über Login-Name und demzugehörigen Passwort. Ein häufig benutzter Ansatz besteht darin, dass dasursprüngliche Passwort mit einem Streuwert ("salt value") kombiniert wird, unddaraus ein Hash Code generiert wird.
Generierung eines Hash Code aus dem Passwort und einem Streuwert festerLänge. Der Streuwert ist eine Zufallszahl oder der Zeitpunkt, an dem dasPasswort erzeugt wurde. Aus Passwort und Streuwert wird ein Hash Codefester Länge generiert. Die Hash Code Generierung wird gezielt verlangsamt,um Attacken durch automatisch gesteuerte Versuche entgegenzutreten. UnixSysteme nutzen oft eine MD5 basierte Hash Funktion mit einem Streuwertvon bis zu 48 Bits; Ergebnis ist ein 128-bit Hashwert.
Ein sehr sicheres Verfahren wurde für OpenBSD entswickelt. Die Hash Funktionbasiert auf dem Blowfish symmetrischen Verschlüsselungs Verfahren. Passwörterkönnen eine Länge bis zu 55 Zeichen haben, der Streuwert umfasst 128 Bit; esentsteht ein Hash Code von 192 Bit.
Langsame Hash
Funktion
User ID
Passwort Datei
Streuwert Hash Code
Passwort
Streuwert
Eintragen Passwort
Überprüfen Passwort
User ID
User ID Streuwert Hash Code
Langsame Hash
Funktion
Passwort
Streuwert
Vergleich
Ziele des Streuwerts
• Duplikate von Passwörter sollen in der Passwort Datei nicht erkennbar sein.Auch wenn zwei Benutzer das gleiche Passwort wählen, entsteht aufgrund desunterschiedlichen Streuwerts ein unterschiedlicher Hash Code.
259
Schlichter, TU München 9.4. MOBILER CODE
• Erhöht den Aufwand für offline Attacken auf die Passwort Datei. Hier wird derFall berücksichtigt, dass ein Angreifer eine Kopie der Passwort Datei erhält.Durch einen Streuwert mit b-bits erhöht sich der Aufwand um den Faktor2b. Neben dem Ausprobieren möglicher Passwörter muss der Angreifer auchjeweils die möglichen Streuwerte durchspielen.
• nicht erkennbar, ob eine Person dasselbe Passwort auf 2 oder mehrerenSystemen nutzt.
9.4 Mobiler Code
Das Internet führt zunehmend zu einer Verbreitung von mobilem Code. Beispielesind
Web Seiten mit AppletsPostscript Dateienmobile Software-Agenten (z.B. in Ecommerce Anwendungen).
Ausführung von heruntergeladenem Code birgt Risiken in sich. Beispielsweisekann ein Applet bösartigen Code enthalten, das auf Ressourcen der lokalen Um-gebung zugreift und sie unberechtigterweise modifiziert oder löscht. Methoden(anhand von Applets), um mit dieser Problematik umzugehen:
9.4.1 Sandboxing
Ausführung des Applets wird auf einen bestimmten virtuellen Adressbereichbeschränkt.
Für eine Sandbox sind die high-order Bits aller Adressen gleich, d.h.angenommen für einen 32 Bit Adressraum werden 256 Sandboxes auf 16MByte Grenzen eingerichtet⇒ für alle Adressen innerhalb einer Sandbox sind die oberen 8 Bitsidentisch.
• jedes Applet erhält zwei Sandboxes: eine Code-Sandbox, eine Daten-Sandbox.Die Code-Sandbox darf durch das Applet nicht verändert werden, um dieGefahr durch einen sich selbst-modifizierenden Code zu eliminieren.
• nach dem Laden wird Applet-Code überprüft, ob er Befehle enthält, die ein Ver-lassen der Sandbox verursachen. Es werden insbesondere Sprungbefehle (JMP)und Systemaufrufe (CALL) untersucht. Sprungbefehle, deren Sprungziele erstzur Laufzeit bestimmt werden, können erst vor deren Ausführung analysiertwerden.
260
Schlichter, TU München 9.4. MOBILER CODE
• ein Applet, das die Sandbox-Grenzen verletzt, wird zurückgewiesen.
9.4.2 Interpretation
Applet wird als Byte-Code geladen. Jeder Befehl wird vor seiner Ausführung vonder Java Virtual Machine (JVM) analysiert.
• jeder Systembefehl wird abgefangen und untersucht. Wie die einzelnenSystembefehle behandelt werden, hängt von der eingestellten Sicherheits-Policy ab.
für vertrauenswürdige Applets (z.B. geladen von lokaler Festplatte) werdenSystembefehle ausgeführt.
nicht vertrauenswürdige Applets (z.B. geladen über Internet) werdeninnerhalb einer Sandbox ausgeführt.
9.4.3 Signed Code
Es werden nur Applets von vertrauenswürdigen Quellen geladen und ausgeführt.Applets anderer Quellen werden abgelehnt. Der Applet-Code wird mit einer digi-talen Unterschrift versehen, um zu garantieren, dass der Code der vertrauenswür-digen Quelle nicht verändert wurde.
• digitale Unterschrift basiert auf public-key Verfahren.
• Erzeugung der Unterschrift durch vertrauenswürdige Quelle
Hashfunktion erzeugt von Applet-Code eine 128/160 bit Zahl.
erzeugte Hashzahl wird mit privatem Schlüssel der Quelle verschlüsselt.
digitale Unterschrift wird mit Applet-Code verschickt.
• Überprüfung der Unterschrift
Browser führt auf Applet-Code Hashfunktion aus und berechnet selbstHashzahl.
Browser entschlüsselt Unterschrift mit öffentlichem Schlüssel der vertau-enswürdige Quelle.
berechnete Hashzahl und Hashzahl in Unterschrift müssen übereinstimmen.
Falls die beiden Hashzahlen nicht übereinstimmen, wird die Ausführung desApplets abgelehnt.
261
Kapitel 10
Entwurf von Betriebssystemen
Der Entwurf eines BS erfordert ein ingenieurmäßiges Vorgehen. Es gibtjedoch keine wohl-definierten Vorgehensweisen, sondern nur Erfahrungen vonEntwicklern bzw. Nutzern.
10.1 Einführung
Die Ziele von Betriebssystemen können sich zwischen verschiedenen Systemenunterscheiden, für Server-Systeme, für Laptops, für Smartphones oder füreingebettete Systeme.
10.1.1 Hauptaspekte
Man kann die folgenden 4 Hauptaspekte unterscheiden
• Definierte Abstraktion: Jede dieser Abstraktionen wird durch konkreteDatenstrukturen instanziiert, z.B. Prozess, Datei, Semaphore
z.B. Thread, Prozess, Datei
Weitere Abstraktionen beziehen sich auf Synchronisation, Signale, Speicher-modell oder die Ein-/Ausgabe.
• Bereitstellen einfacher Operationen:
Operationen zum Manipulieren der zur Abstraktion gehörigen Datenstruk-turen. Beispielsweise können Nutzer Dateien lesen oder schreiben.
Ansprechbar über Systemaufrufe. Die primitiven Operationen werdendurch Systemaufrufe realisiert.
262
Schlichter, TU München 10.1. EINFÜHRUNG
• Sicherstellen der Abgrenzung: Da verschiedene Nutzer gleichzeitig auf einemRechner aktiv sein können, muss das Betriebssystem einen Mechanismusbereitstellen, der diese Benutzer voneinander abgrenzt. Andererseits möchtenNutzer Daten und Ressourcen gemeinsam nutzen.
Eingrenzung von Fehlern durch Abgrenzung von Prozessen. Prozessedienen zur Gruppierung von Ressourcen aus Schutzgründen
Zentrales Ziel ist, dass Nutzer nur autorisierte Operationen auf autorisiertenDaten ausführen können. Ein weiterer Punkt ist die Eingrenzung von Fehlern;der Absturz eines Nutzerprozesses soll nicht zum Absturz des gesamtenSystems führen.
• Verwalten der Hardware.
10.1.2 Probleme
Hardware hat sich gemäß des Moore‘schen Gesetzes kontinuierlich verbessert;Betriebssysteme haben zwar mehr Funktionalität, jedoch bzgl. Verfügbarkeit sindsie teilweise schlechter als die alten Systeme. Unix wurde in den 70er Jahren,Windows in den 80er Jahren entwickelt.
• Betriebssysteme sind sehr komplex. Windows 2000 bestand aus 29 MillionenCodezeilen und wurde von ca. 1400 Entwicklern realisiert. Windows XP hatteca. 40 Millionen Codezeilen und Windows Vista bereits mehr als 50 MillionenCodezeilen. Für Windows 7 wird dagegen eine Reduktion angenommen.
• Betriebssysteme müssen mit Parallelität umgehen. Parallelität von unterschied-lichen Komponenten, z.B. E/A-Geräte, führt zu Race-Conditions und Verklem-mungen.
• Betriebssysteme müssen mit feindlichen Nutzern umgehen. Benutzer könnendas System beeinflussen oder Daten stehlen. Dabei kann der Angriff lokal oderüber das Netz erfolgen.
• Nutzer möchten Daten mit anderen Nutzern gemeinsam nutzen. Einerseitssollen die Benutzer voreinander geschützt werden, andererseits möchten sieDaten gemeinsam nutzen. Das Betriebsystem muss einen Kompromiss finden,der die gemeinsame Nutzung von Ressourcen erlaubt, jedoch böswillige Nutzerausgrenzt.
• Betriebssysteme existieren eine lange Zeit. Unix wurde bereits in den 70erJahren, Windows in den 80er Jahren entwickelt. Entwickler müssen deshalb
263
Schlichter, TU München 10.2. SCHNITTSTELLENENTWURF
Betriebssysteme so flexibel gestalten, so dass auch neuere Technologien undKonzepte berücksichtigt werden können. Ein Betriebssystem muss erweitertwerden können.
• Entwickler wissen oft nicht vorab, wie ihre Systeme genutzt werden. Unixwurde zunächst für Minicomputer entwickelt; später wurde es auch als Server-BS und als Desktop-BS genutzt.
• Betriebssysteme sind portabel für unterschiedliche Hardware entworfen.
• Kompatibilität mit älteren Betriebssystem Versionen. Symptome, die hier eineRolle spielen, sind Beschränkungen bzgl Dateinamen. Oft verhindert dieerforderliche Kompatibilität eine radikale Verbesserung eines BS.
10.2 Schnittstellenentwurf
Ein BS bietet eine Reihe von Diensten, die von Benutzerprozessen in Anspruchgenommen werden können.
Bereitstellen der Dienste über Schnittstellen.
10.2.1 Leitlinien für den Entwurf
Es existieren eine Reihe von Prinzipien und Empfehlungen
• Einfachheit. Eine einfache Schnittstelle ist leichter zu verstehen und damitfehlerfrei zu implementieren. Es gilt nach Exupery: Perfektion ist nicht erreicht,wenn man nichts mehr hinzufügen kann, sondern wenn man nichts mehrentfernen kann.
• Vollständigkeit. Umfang an bereitgestellten Mechanismen: was würde passie-ren, wenn man ein Feature weglassen würde..
Bereitstellen, was man benötigt und nicht mehr.
Minimum an Mechanismen. Jeder Dienst sollte eine genau festgelegteFunktionalität haben, und nur diese erfüllen. Es sollte nach Möglichkeitvermieden werden, unterschiedliche Mechanismen für die gleiche Funktio-nalität zu verwenden, z.B. für das Speichern von Information.
• Effizienz. dem Anwendungsprogrammierer sollte intuitiv klar, wie viel einSystemaufruf kostet (Erwartungshaltung der Programmierer), z.B. erwartenUnix Programmierer dass ein lseek-Aufruf billiger als ein read-Aufruf ist.
264
Schlichter, TU München 10.2. SCHNITTSTELLENENTWURF
Nutzergruppen von BS
• Endbenutzer
Nutzung von Anwendungen⇒ grafische Oberfläche des BS
• Programmierer
Nutzung der Systemaufrufschnittstelle des BS
• Systemadmin
Aufruf von Systemdiensten
10.2.2 Paradigmen der Systemaufrufschnittstelle
Für die Einbindung der Systemaufrufe in Nutzerprogramme kann man zwischenden Ausführungs- und den Datenparadigmen unterscheiden.
Algorithmischer Ansatz
basiert auf der Idee, dass ein Programm eine bestimmte Funktion erfüllen soll, diees im Voraus oder durch Parameter kennt.
• Basislogik ist im Code festgelegt
• Gelegentliche Systemaufrufe, um
Benutzereingaben zu erhalten
BS-Dienste in Anspruch zu nehmen
Beispielmain () {
int ...;init();do_something();
read(...); /* Systemaufruf */do_something_else();
write(...); /* Systemaufruf */continue();exit(0);
}
265
Schlichter, TU München 10.2. SCHNITTSTELLENENTWURF
Ereignis-basierter Ansatz
nach einer Initialisierung warten Programme dieses Ansatzes auf Ereignisse desBetriebssystems
• Anwendungen reagieren auf Ereignisse
• Ereignisse werden durch BS erfasst und der Anwendung zugestellt
• Ereignisse sind z.B.
Tastendruck
Mausbewegung
Beim ereignis-basierten Ansatz stellt das Betriebssystem zwar ebenfallsDienste bereit, jedoch werden diese durch die Rolle als Koordinator und alsGenerator von Ereignissen überdeckt.
Beispielmain () {
mess_t msg;init();while (get_message(&msg)) {
case 1: ...;case 2: ...;case 3: ...;......
}}
Datenparadigma
Wie werden Systemstrukturen und Geräte im Betriebssystem gegenüber demProgrammierer präsentiert?
Beispiel Unix
• "Alles" ist eine Datei
• Vereinheitlichung von Dateien, E/A-Geräte und Pipes
266
Schlichter, TU München 10.2. SCHNITTSTELLENENTWURF
• Zugriff über Dateioperationen
fd1 = open("file1", O_RDWR)
fd2 = open("/dev/tty", O_RDWR)
Nach dem Öffnen der Datei bzw. des Gerätes gibt es keinen Unterschied mehr,abgesehen davon, dass auf einem Terminal kein Positionierungen möglich sind.
Beispiel Windows 2000
• "Alles" ist ein Objekt. Das Datenparadigma "Alles" ist ein Objekt istallgemeiner als jenes von Unix. Wenn ein Prozess ein gültiges Handle füreine Datei, einen Prozess, ein Semaphor, eine Mailbox erhalten hat, kann erOperationen darauf ausführen.
Systemaufrufschnittstelle
Entscheidung bzgl. der Bereitstellung unterschiedlicher Varianten von Systemauf-rufen
Z.B. Lese-Systemaufruf: read_file, read_process, read_tty, . . . Soll für jededieser Variante ein eigener Systemaufruf an der Schnittstelle bereitgestelltwerden. Dies führt zu einer sehr unübersichtlichen Systemaufrufschnittstelle.
• Besser: nur Bereitstellung des allgemeinen Falls
Z.B. Lese-Systemaufruf: read
Restliche Varianten über Bibliotheksfunktionen auf den allgemeinenSystemaufruf abbilden
• Sichtbarkeit von Systemaufrufen
Trennung von Systemaufrufen und Bibliotheksaufrufen
⇒ Ermöglicht übersichtliche Darstellung der vorhandenen Systemaufrufe
Unix hat eine wohl definierte Liste von Systemaufrufen, die jedem Program-mierer zugänglich ist. Daraus ist für einen Programmierer ersichtlich, welcheAufrufe teuer (Kernaufrufe) und welche günstig (Abarbeitung im Benutzerad-dressraum) sind. Windows API stellt mehr als 13000 Aufrufe bereits, wobeikeine Differenzierung zwischen System- und Bibliotheksaufruf erfolgt.
267
Schlichter, TU München 10.3. WEITERE IMPLEMENTIERUNGSASPEKTE
10.3 Weitere Implementierungsaspekte
Neben den Diensten und deren Bereitstellung über die Systemaufrufschnittstellestellen die folgenden Implementierungsaspekte eine wichtige Rolle beim Entwurfvon Betriebssystemen.
10.3.1 Architektur
Ein etablierter und erprobter Architekturansatz sind geschichtete Systeme. Engverbunden mit dem Thread Management ist das Prozess Management und dieInterprozesskommunikation.
Systemaufrufbehandlung
Dateisystem 1 Dateisystem m
Virtueller Speicher (Paging)
Treiber 1 Treiber n
Threads, Thread Scheduling, Thread Synchronisation
Unterbrechungsbehandlung, Dispatcher, MMU
Abstraktion der Hardware (z.B. HAL von Windows)
...
...
Ein anderer Ansatz sind Client-Server Systeme mit einem Mikrokern undausgelagerten Serverprozessen. Dies erlaubt einen modularen, flexiblen Entwurf.
10.3.2 Mechanismen vs. Policies
Trennung von Mechanismen und Policies. Legt man die Mechanismen in das BSund überlässt die Policy den Benutzerprozessen (bzw Systemprozessen), kanndas BS unverändert bleiben, auch wenn die Notwendigkeit besteht, die Policy zuändern.
• Beispiel: BS unterstützt Prioritätenbasierten Scheduler
268
Schlichter, TU München 10.3. WEITERE IMPLEMENTIERUNGSASPEKTE
Mechanismus: Feld gemäß absteigender Priorität sortiert; Scheduler durchsuchtFeld beginnend von der höchsten Priorität
Policy: Festlegen der Prioritäten
• Beispiel: BS unterstützt Paging für Arbeitsspeicher
Mechanismus: Verwaltung der Seiten-Kacheltabelle, MMU-Management,Funktionen zum Transport der Seiten zwischen Festplatte und Arbeitsspeicher
Policy: welche Seiten werden ausgelagert bei Seitenfehler
10.3.3 Namensräume
Die meisten langlebigen Datenstrukturen eines BS haben einen Namen oder einenBezeichner zugeordnet, z.B. Login-Namen, Dateinamen, Gerätenamen, Prozess-ID etc. Namen werden auf 2 Ebenen vergeben
extern: Namen, welche Menschen verwenden (z.B. Dateiname)intern: Namen, welche das System verwendet (z.B. inode Nummer)
In einem guten Entwurf wird darüber nachgedacht,
wie viele Namensräume benötigt werden,
Welche Syntax sie haben,
Ob absolute und relative Namen existieren.
Directories bilden externe Namen auf interne Namen ab.
Externer Name: /usr/ast/books/mos2/Chap-12
Chap-10 114
Chap-11
Chap-12
38
2
Directory: /usr/ast/books/mos2 Inode - Tabelle
1
2
3
4
5
6
7
..
Interner Name: 2
269
Schlichter, TU München 10.3. WEITERE IMPLEMENTIERUNGSASPEKTE
10.3.4 Statische - Dynamische Datenstrukturen
Statische Strukturen sind einfacher und schneller, jedoch weniger flexibel alsdynamische Strukturen
• Beispiel Prozesstabelle:
Statisch: feste Prozesstabelle mit 256 Einträgen.
Dynamisch: Prozesstabelle als verkettete Liste.
Schnelle Suche in statischer Prozesstabelle. Falls ein 257. Prozess erzeugtwird, ist der Aufruf nicht erfolgreich, da zu einem Zeitpunkt nur 256 Prozesseexistieren können.
• Statische Tabellen sind vernünftig
Wenn die Zahl der Einträge sehr gut vorausgesagt werden kann.
Weiterhin muss genügend großer Speicher vorhanden sein, damit ausreichendSpeicher für die Tabelle bereitgestellt werden kann. Auch bei Prozess-Scheduling spielt Statik vs. Dynamik eine Rolle. Beispielsweise kann beiEchtzeitsystemen das Scheduling von Prozessen gut vorausgesagt werden (z.B.Multimediaprozessen). Bei interaktiven Prozessen ist dies i.a. nicht möglich.
10.3.5 Verbergen der Hardware
Die unterste Schicht, die Hardware Abstraction Schicht (z.B. HAL von Windows)versucht Hardware-spezifische Eigenschaften zu verbergen
• Abfrage der Arbeitsspeichergröße zum Bootzeitpunkt
Speicherung in einer Variablen
CPU-abhängige bedingte Übersetzung. Generiert BS-Code abhängig von derBesetzung der Variablen.
#include "config.h"init(){
#if (CPU == PENTIUM) /* Pentium initialization here */#endif#if (CPU == ULTRASPARC) /* ULTRASPARC initialization here*/ #endif
... }
270
Schlichter, TU München 10.3. WEITERE IMPLEMENTIERUNGSASPEKTE
• Hardware-Architekturen unterstützenunterschiedliche WortlängenCPU-abhängige bedingte Übersetzung. GeneriertBS-Code abhängig von der unterstützten Wortlänge.
#include "config.h"{
#if (WORD_LENGTH == 32) typedef int Register; #endif#if (WORD_LENGTH == 64) typedef long Register; #endif
Register R0, R1, ...;In der Datei config.h werden die entsprechenden Variablen CPU undWord_LENGTH abhängig von der jeweiligen Rechnerarchitektur geeignetbesetzt. Bei der Übersetzung des BS-Codes muss nur die geeignete config.hDatei verwendet werden.
10.3.6 Speicherplatz vs. Laufzeit
Bei der Realisierung von Algorithmen besteht ein Abwägen zwischen Speicher-platz und Laufzeit
Nutzung von Prozeduren⇒ Aufwand für Prozeduraufruf
Nutzung von Makros⇒ direkte Einbindung; kein Prozeduraufruf
• Beispiel: Prozedur, um die Bits mit Wert 1 in einem Byte zu zählen.
#define BYTE_SIZE 8 /* a byte contains 8 bits*/int bit_count (int byte) {
int i, count=0;for (i=0; i<BYTE_SIZE; i++) if((byte >> i) &1) count++;return(count);
}Die for-Schleife vergleicht jedes einzelne Bit, ob es eine 1 ist, indem esden Bytewert um jeweils die entsprechende Stelle nach rechts schiebt. EineProzedur hat mehrere Ineffizienzquellen:
bei Prozeduraufruf muss jeweils Kellerspeicher angelegt werden.
Schleifen sind aufwändig.
• Beispiel: Macro, um die Bits mit Wert 1 in einem Byte zu zählen.
Shiften des Arguments, Ausmaskieren aller Bits außer dem niederwertigenBit, Aufaddieren der 8 Terme
#define bit_count(b) (b&1) + ((b>>1)&1) + ((b>>2)&1) +((b>>3)&1) + ((b>>4)&1) + ((b>>5)&1) + ((b>>6)&1) +((b>>7)&1)
271
Schlichter, TU München 10.4. TRENDS BEIM ENTWURF VON BETRIEBSSYSTEMEN
Wenn das Macro im Code aufgerufen wird, erscheint sum=bit_count(byte); diessieht identisch wie ein Prozeduraufruf aus.
• Beispiel: Macro, um die Bits mit Wert 1 in einem Byte zu zählen.
Wert des Bytes ist Index in eine Tabelle mit 256 Einträge
Eintrag gibt die Anzahl der Bits von Wert 1 an
char bits[256] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1, ...};#define bit_count(b) (int) bits[b];Wenn das Macro im Code aufgerufen wird, erscheint sum=bit_count(byte); diessieht identisch wie ein Prozeduraufruf aus. In diesem Fall ist keine Berechnungnotwendig, sondern es erfolgt nur ein Nachsehen in der Tabelle.
10.4 Trends beim Entwurf von Betriebssystemen
Bedingt durch den vielfältigen Einsatz der Rechner sind die jeweiligen Trends vonunterschiedlicher Bedeutung
• BS mit großem Adressraum
Übergang von 32 Bit zu 64 Bit-Adressräumen
Adressraum von 2 * 1019 Bytes
Dies erfordert andere Ansätze zur Verwaltung des virtuellen Speichers;herkömmliche Seitentabellen skalieren nicht gut für diese Größe. Dateienkönnten effektiv im virtuellen Speicher gehalten werden
• Netze werden die Grundlage für BS
Zugriff auf Web ist vollständig und nahtlos in BS integriert
• Bessere Unterstützung von parallelen und verteilten Systemen. Bisher erfolgtdie Unterstützung meist auf der Ebene von Middleware, d.h. nicht imBetriebssystem selbst.
• BS für batteriebetriebene Computer (PDAs, Smart Phone, etc.)
Energiemanagement; Adaption von BS und Anwendungen je nachEnergieversorgung
Trend hin zu "Green Computing".
272
Schlichter, TU München 10.4. TRENDS BEIM ENTWURF VON BETRIEBSSYSTEMEN
• BS für eingebettete SystemeDie Bezeichnung "Eingebettetes System" bezieht sich auf die Nutzung vonComputer Hardware und Software in einem Produkt. Unterscheidung nachAnwendungsdomäne
Automobil, z.B. Zündung, Motorkontrolle, Bremssystem
Consumer Elektronik, z.B. Set-top Box, Küchengeräte, Kamera,Smartphone
Medizinbereich, z.B. Dialysegerät, Infusionspumpe
Bürobereich, z.B. Faxgerät, Drucker
industrielle Nutzung, z.B. Roboter und Kontrollsysteme für Produktion
– Eingebettete Systeme sind eng gekoppelt mit dem Produkt, wobei dieAnforderungen sehr variieren können
Größe des Produkts, in das es eingebettet ist. Dies hat oft Konsequenzenbzgl der Kosten des Systems oder erfordert oft unterschiedlicheOptimierungsansätze.Lebensdauer. Manche Produkte haben eine sehr lange Lebensdauer, sodass bzgl Aktualisierung bzgl. des BS nachgedacht werden muss. AndereProdukte haben eine so kurze Lebensdauer, so dass ein Update zuaufwändig ist.Nutzungsumgebung. Welchen Umwelteinflüssen ist das eingebetteteSystem ausgesetzt, z.B. Strahlung, Vibration, Hitze, Luftfeuchtigkeit.Realzeitverhalten.
– Es wurden eine Vielzahl von speziellen Betriebssystemen für eingebetteteSysteme realisiert
∗ für mobile Endgeräte: Symbian OS, Windows CE oder Android (URL:http://code.google.com/android/) von Google.
Android Systemarchitektur basiert auf Linux Kernel (Treiber,Speicher-/Prozessmanagement); darauf existieren Bibliotheken (z.B.für Graphik), eine Laufzeitumgebung und ein Anwendungsframework.Das ganze Anwendungsframework ist geschrieben in Java. Alle An-wendungen benutzen dieses Framework, egal ob sie von Google inte-griert sind, oder von einem externen Entwickler geschrieben wurden.Komponenten des Frameworks sind der Window Manager, ActivityManager, der den Lebenszyklus der Anwendung kontrolliert.
∗ TinyOSfür drahtlose Sensornetze: TinyOS (URL: http://www.tinyos.net/), ent-wickelt von der UC Berkeley
273
Schlichter, TU München 10.4. TRENDS BEIM ENTWURF VON BETRIEBSSYSTEMEN
zentraler Teil des BS ist sehr klein, ca. 400 Bytes Code undDatenspeicher
Internet
Host - PC Basis
Station
Sensor
Sensor
Sensor
Relay
Sensor
Relay
Sensor
Relay
Sensor
Relay
◦ TinyOS hat keinen BS-Kern und keinen Speicherschutzmechanismus.◦ komponenten-basierter Ansatz und ereignis-basiertes Ausführungsmo-
dell. Gleichzeitig stellt es auch eine Entwicklungsumgebung und Pro-grammierplattform speziell für Hardwaresysteme mit knappen Ressour-cen in Bezug auf Speicher, Rechenleistung und Energieverwendung dar,welche autonom und sicher über Zeiträume von Monaten oder Jahrenzuverlässig funktionieren müssen.geschichtete Anordnung der Komponenten; zwischen Komponenten be-stehen Aufrufbeziehungen; elementare Komponenten kapseln HardwareKomponenten (z.B. Timer).Anwendungen werden durch Verknüpfung von Komponenten realisiert.2 Arten von Komponenten: a) Module = implementieren Funktionen,und b) Konfigurationen = beschreiben die Verknüpfung von Kompo-nenten.eine Komponente implementiert eine oder mehrere "tasks". Diese sindvergleichbar mit Threads in üblichen BS; Innerhalb einer Komponentesind tasks atomar, d.h. nach ihrem Start werden sie bis zum Endeausgeführt (kein Unterbrechung durch eine andere Task derselbenKomponente, z.B. aufgrund einer abgelaufenen Zeitscheibe). DieAusführung von Tasks kann jedoch durch Ereignisse unterbrochenwerden. Eine Task hat 3 Phasen: a) ein Aufrufer sendet ein Kommandozu einem Modul, b) Modul führt die zugehörige Task aus, und c) derModul signalisiert das Ende der Task an den Aufrufer (Ereignis).
274
Schlichter, TU München 10.4. TRENDS BEIM ENTWURF VON BETRIEBSSYSTEMEN
TinyOS Scheduler realisiert die Ausführungsreihenfolge der tasks (z.B.auf FIFO Basis).
275
Kapitel 11
Zusammenfassung
Diese Vorlesung beschäftigte sich mit den technischen Aspekten von Rechensy-stemen. Es gab eine Einführung in Betriebssysteme und systemnahe Programmie-rung. Insbesondere wurden folgende Aspekte behandelt:
• Modellierung von Prozessen, z.B. Petrinetze, sowie die Synchronisation vonProzessen beim Zugriff auf gemeinsame Ressourcen.
• Verwaltung von Prozessen und deren Zuteilung an die CPU, um sieauszuführen.
• Verwaltung des Arbeitsspeichers aus der Sicht des Betriebssystems (virtuelleSpeicherverwaltung, Seitenadressierung).
• persistente Speicherung von Information in Dateien.
• Prozesskommunikation in lokalen und verteilten Systemen.
• Verwaltung der Geräte.
• Sicherheit in Rechensystemen.
Der Entwurf und die Implementierung von Betriebssystemen ist komplex undaufwändig. Wichtige Aspekte sind
definierte Abstraktionen, z.B. Prozesse, Threads, Adressraum
Definition von Schnittstellen zur Bereitstellung von Operationen, z.B.Operation zur Synchronisation, persistente Speicherung von Information
Schnittstelle sollte einfach, vollständig und effizient sein.
Sicherstellen der Abgrenzung, z.B. Isolieren von Fehlern. Falls ein Benutzer-prozess abstürzt, sollte es möglich den Rest des Systems fortzusetzen.
276
Schlichter, TU München
Verwalten der Hardware, z.B. Geräteverwaltung.
Festlegung der Paradigmen, z.B. Ausführungsparadigma, Systemaufruf-schnittstelle, Speicherplatz vs. Laufzeit.
277
Recommended