Grundlagen: Betriebssysteme und Systemsoftware (GBS)

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


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


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


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


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


• Prof. J. Schlichter

– Lehrstuhl für Angewandte Informatik / Kooperative Systeme, Fakultät fürInformatik, TU München

– Boltzmannstr. 3, 85748 GarchingEmail: [email protected] (URL: mailto:[email protected])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


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


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


∗ 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


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


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


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


• 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


• 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


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


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


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


– 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


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


• 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


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


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


abstrakte Maschine 0


Rechnerhardware

Schicht N

Schicht N-1

Schicht 0

25


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


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


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


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


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


(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


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


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


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


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


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


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


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


• 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


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


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


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


– 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


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


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


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


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


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


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


• 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


– 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


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


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


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


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


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


• 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


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


• 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


– 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


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


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


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


– 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


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


– 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


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


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


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


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


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


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


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


}

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


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


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


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


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


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


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


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


• 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


• 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


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


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


• 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


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


• 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


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


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


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


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


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


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


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


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


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


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


• 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


• 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


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


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


– 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


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


• 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


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


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


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


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


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


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


• 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


• 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


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


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


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


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


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


• 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


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


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


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


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


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


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


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


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


• 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


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


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


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


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


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


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


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


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


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


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


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


• 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


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


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


∗ 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


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


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


k


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


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


• 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


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


• 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


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


– 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


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


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


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


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


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


+

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


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


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


• 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


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


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


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


= ?

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


= ?

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


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


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


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


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


• 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


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


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


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


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



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



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



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


– 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


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


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


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


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


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


• 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


/* 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


– 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


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


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


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


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


• 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


• 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


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


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


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


import java.io.*;import java.net.*;

216


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


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


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


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


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


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


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


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


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


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


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


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


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


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


• 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


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


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


– 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


– 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


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


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


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


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


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


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


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


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


• 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


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


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


• 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


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


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


• 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


• 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


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


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

Grundlagen: Betriebssysteme und Systemsoftware (GBS)

Documents

Transcript of Grundlagen: Betriebssysteme und Systemsoftware (GBS)