skript2005

Transcrição

skript2005

STUDIENGANG ANGEWANDTE INFORMATIK
VORLESUNGSUNTERLAGEN ZU SYSTEMSOFTWARE
Prof. Dr.-Ing. Silvia Keller
Ausgabe: 14 .03.2005
Systemsoftware-Skript Version 1.1
Seitenzahl: 102
Prof. Dr. Keller
Systemsoftw are-Skript Version 1.1
Seite 2 von 102
Inhaltsverzeichnis
1.
Einführung ........................................................................................................................................5
1.1
Historische Entwicklung ..................................................................................................................5
1.2
Betriebsarten...................................................................................................................................6
1.2.1
Direkte Maschinenprogrammierung ........................................................................................6
1.2.2
Stapelbetrieb (Batch Systeme)................................................................................................6
1.2.3
Mehrprogrammbetrieb ( Multiprogramming )...........................................................................7
1.2.4
Dialogbetrieb............................................................................................................................8
1.2.5
Realzeitbetrieb.........................................................................................................................9
1.3
Systemsoftware – Betriebssystem..................................................................................................9
1.4
Architektur von Betriebssystemen ................................................................................................11
1.4.1
Beispiel: Architektur von Windows NT...................................................................................12
1.4.2
Subsysteme unter Windows NT ............................................................................................13
1.5
Systemaufrufe ( Supervisor call )..................................................................................................14
1.5.1
Unterbrechungstechnik..........................................................................................................14
1.5.2
Systemfunktionen ..................................................................................................................15
1.5.3
Beispiel - Daten in eine Datei schreiben................................................................................16
1.6
Übungsaufgabe.............................................................................................................................17
1.6.1
Aufgabe 1 ..............................................................................................................................17
2.
Multiprogramming ..........................................................................................................................18
2.1
Prozesse .......................................................................................................................................18
2.1.1
Prozess-Adressraum .............................................................................................................18
2.1.2
Prozesszustände ...................................................................................................................19
2.2
Prozeßwechsel ( Dispatch, Scheduling ) ......................................................................................19
2.2.1
Freiwilliger Prozeßwechsel durch Aufrufen einer Systemfunktion ( non preemptive )..........19
2.2.2
Erzwungener Prozeßwechsel ( preemptive ) ........................................................................20
2.3
Threads .........................................................................................................................................20
2.3.1
Definition und Erzeugung von Threads .................................................................................25
2.4
Wichtige Systemfunktionen ..........................................................................................................25
2.5
Scheduling Verfahren ...................................................................................................................25
2.5.1
First Come First Serve (FCFS)..............................................................................................26
2.5.2
Shortest Job First (Modifikation von FCFS ) .........................................................................26
2.5.3
Round Robin (RR) Zeitscheibenverfahren ..........................................................................27
2.5.4
Prioritäten ..............................................................................................................................28
2.6
Multiprogramming in UNIX............................................................................................................29
2.6.1
Prozesse in UNIX ..................................................................................................................29
2.6.2
Scheduling in UNIX................................................................................................................34
2.7
Multiprogramming in Windows NT................................................................................................35
2.7.1
Prozesse in NT ......................................................................................................................35
2.7.2
Threads in NT ........................................................................................................................36
2.7.3
Scheduling in NT ...................................................................................................................37
2.8
Übungsaufgaben...........................................................................................................................38
2.8.1
Aufgabe 2 ..............................................................................................................................38
2.8.2
Aufgabe 3 ..............................................................................................................................38
2.8.3
Aufgabe 4 ..............................................................................................................................39
2.8.4
Aufgabe 5 ..............................................................................................................................39
2.8.5
Aufgabe 6 ..............................................................................................................................40
2.8.6
Aufgabe 7 ..............................................................................................................................41
Prof. Dr. Keller
3.
Seite 3 von 102
Arbeitsspeicherverwaltung ...........................................................................................................42
3.1
Partitionierung...............................................................................................................................42
3.1.1
Strategien zur Speicherplatzvergabe ....................................................................................43
3.2
Segmentierung..............................................................................................................................44
3.3
Virtueller Speicher.........................................................................................................................45
3.3.1
Overlays.................................................................................................................................45
3.3.2
Seitenwechselverfahren ( Paging )........................................................................................45
3.4
Speicherverwaltung in UNIX.........................................................................................................52
3.5
Speicherverwaltung in Windows NT .............................................................................................53
3.6
Übungsaufgaben...........................................................................................................................54
3.6.1
Aufgabe 8 ..............................................................................................................................54
3.6.2
Aufgabe 9 ..............................................................................................................................54
3.6.3
Aufgabe 10 ............................................................................................................................55
3.6.4
Aufgabe 11 ............................................................................................................................55
3.6.5
Aufgabe 12 ............................................................................................................................56
3.6.6
Aufgabe 13 ............................................................................................................................56
4.
Interprozesskommunikation .........................................................................................................57
4.1
Modelle zur Beschreibung eines nebenläufigen Systems ............................................................57
4.1.1
Beschreibung der Aufbaustruktur durch Instanzennetze ......................................................57
4.1.2
Beschreibung der Ablaufstruktur durch Petrinetze................................................................57
4.2
Kooperation über gemeinsame daten ( shared memory ) ............................................................58
4.3
Synchronisation ............................................................................................................................59
4.3.1
Signale, Flags ........................................................................................................................59
4.3.2
Stop/Unstop-Mechanismus ...................................................................................................59
4.3.3
Semaphore ............................................................................................................................59
4.3.4
Monitore.................................................................................................................................61
4.3.5
Verklemmungen.....................................................................................................................67
4.4
Kommunikation .............................................................................................................................68
4.4.1
Nachrichten............................................................................................................................68
4.5
Interprozesskommunikation unter UNIX .......................................................................................68
4.5.1
Signale und PIPES ................................................................................................................68
4.5.2
Semaphore, Shared Memory, Nachrichten ...........................................................................69
4.6
Interprozesskommunikation in Windows NT.................................................................................69
4.6.1
Gemeinsame Daten...............................................................................................................69
4.6.2
Synchronisation .....................................................................................................................69
4.6.3
Kommunikation über Nachrichten .........................................................................................71
4.7
Problem des schlafenden Friseurs (Sleeping Barber)..................................................................72
4.7.1
Problembeschreibung............................................................................................................72
4.7.2
Petrinetz.................................................................................................................................74
4.7.3
Pseudocode...........................................................................................................................75
4.7.4
Sourcecode............................................................................................................................75
4.8
Übungsaufgaben...........................................................................................................................78
4.8.1
Aufgabe 14 ............................................................................................................................78
4.8.2
Aufgabe 15 ............................................................................................................................79
4.8.3
Aufgabe 16 ............................................................................................................................80
4.8.4
Aufgabe 17 ............................................................................................................................81
4.8.5
Aufgabe 18 ............................................................................................................................82
4.8.6
Aufgabe 19 ............................................................................................................................82
5.
Dateiverwaltung..............................................................................................................................83
5.1
Aufbau von Dateisystemen und Katalogen...................................................................................85
Prof. Dr. Keller
5.2
Seite 4 von 102
Physikalische Organisation von Dateien ......................................................................................88
5.3
Aufbau des Dateisystems ext2 von Linux....................................................................................90
5.3.1
Repräsentation von Daten.....................................................................................................91
5.3.2
Repräsentation von Dateien ..................................................................................................91
5.3.3
Verzeichnisse und –einträge .................................................................................................92
5.3.4
Ausblick auf Ext3fs ................................................................................................................93
5.4
Memory Mapped Files ..................................................................................................................93
5.5
Inhaltsbezogener Zugriff auf Dateien............................................................................................94
5.5.1
Index-Sequentielle Dateien ( ISAM ) .....................................................................................94
5.6
Effizienzsteigerung, Fehlererkennung und Behebung..................................................................97
5.6.1
Effizienzsteigerung ................................................................................................................97
5.6.2
Fehlererkennung und Behebung ...........................................................................................97
5.6.3
RAID ......................................................................................................................................97
5.7
Übungsaufgaben...........................................................................................................................99
5.7.1
Aufgabe 20 ............................................................................................................................99
5.7.2
Aufgabe 21 ............................................................................................................................99
5.7.3
Aufgabe 22 ..........................................................................................................................100
6.
Ein-/Ausgabesystem ....................................................................................................................101
7.
Literaturverzeichnis .....................................................................................................................102
Prof. Dr. Keller
Seite 5 von 102
1. Einführung
1.1
Historische Entwicklung
RechnerZeitraum
Generation
Technologie
Betriebsart
Betriebssystem
1, 2
1945 1955
Manuell
Relais, Röhren
( Zuse,
Ein Benutzer
Eckard&Maucheley, Ein Programm
John von Neumann )
3
1955 1965
Transistor
Batch
Assembler, FORTRAN
Monitore sind erste Betriebssysteme
( FMS :
Fortran Monitoring System )
4
1965 1980
Integrierte Schaltkreise
( IBM/360 )
Spooling
Multiprogramming
Dialogbetrieb
( Time Sharing )
OS/360
MULTICS
(Multiplexed Information and
Computing Service )
UNIX
5
1980 heute
LSI, VLSI
(PC, Workstation,
Rechnernetze )
Netzwerkfähige BS
Verteilte BS
MS-DOS
UNIX
OS/2
Windows NT
keine Programmiersprache
kein Betriebssystem
Maschinenprogrammierung
mittels Einsteckkarten
Prof. Dr. Keller
1.2
Seite 6 von 102
Betriebsarten
Die Betriebsarten entwickelten sich parallel zu der historischen Entwicklung der Computer-Hardware,
nach deren Nutzung und den technischen Möglichkeiten.
1.2.1
Direkte Maschinenprogrammierung
1.2.2
Stapelbetrieb (Batch Systeme)
Stapelbetrieb ( Batch Systeme )
Lochkarten
Stapel
Listin
g
JOB
Ausgaberaum
Einleseraum
Maschinenraum
• Erste Programmiersprachen und Betriebssysteme ( Monitore )
– Assembler, FORTRAN (Formular Translator )
– FMS ( Fortran Monitoring System )
Eingabeband
Eingabe- System- Ausgabeband
band
band
Ausgabeband
CPU
Satellitenrechner
SystemOperator
Verbesserung durch Magnetbänder
Manuelles
laden
der Bänder
Satellitenrechner
Prof. Dr. Keller
Seite 7 von 102
Sequentielle Abarbeitung von Jobs. Die Jobs werden alle nacheinander vom Rechner bearbeitet.
Jeder Job durchläuft die Abarbeitungsfolge:
Lochkarten erstellen ==> Abgabe in Einleseraum. Dort werden die Jobs in einem Stapel gesammelt ==> Abarbeitung eines Jobs im Maschinenraum ==> Ausgabelisting in den Ausgaberaum ==>Listing
1.2.3
Mehrprogrammbetrieb ( Multiprogramming )
CPU bearbeitet mehrere Programme gleichzeitig ==> Bessere CPU-Auslastung
Mehrere Benutzer ( Multiuser ) und mehrere Programme eines Benutzers ( Multitasking ) können gleichzeitig auf einer CPU abgearbeitet werden.
Prof. Dr. Keller
1.2.4
Seite 8 von 102
Dialogbetrieb
Ein- und Ausgabe nicht per Lochkarten sondern über eine Online-Verbindung mit einer Dialogstation
Varianten:
Single User / Singletasking
Single User / Muktitasking
Multiuser / Multitasking
(→ MS - DOS )
(→ OS/2, WINDOWS 3.1, WINDOWS NT )
(→ UNIX, VMS, WINDOWS NT1 )
Time Sharing = Zeitscheibenverfahren
Jedes Programm darf nacheinander für eine kleine Zeitscheibe rechnen (Beispiel: UNIX , Windows NT)
1
Es werden zwar mehrere User verwaltet, anmelden kann sich jedoch nur ein User. Es gibt MultiuserErweiterungen zu Windows NT 4.0
Prof. Dr. Keller
1.2.5
Seite 9 von 102
Realzeitbetrieb
Der Rechner wird zur Steuerung oder Regelung eines technischen Prozesses eingesetzt. Jedes
Programm muss seine Tätigkeiten in fest vorgegebenen Zeiten erledigen. Diese Zeiten werden von
dem technischen Prozess vorgegeben, und nicht vom Rechner.
Es müssen mehrere verkoppelte Prozesse gleichzeitig laufen können.
Zeitgesteuert (Polling)
Ereignisgesteuert
Prioritäten
z.B. ==> alle 0,5 ms einen Messwert aufnehmen
z.B. ==> bei Störfall muss das System sofort
reagieren
Wechsel von Programmen entsprechend ihrer Wichtigkeit z.B. ist
im Störfall erst das Ventil zu öffnen und dann erst eine Meldung
am Bildschirm auszugeben
BETRIEBSSYSTEME: RSX11, OS9, RTOS, VRTX
1.3
Systemsoftware – Betriebssystem
Man unterscheidet Anwendersoftware von Systemsoftware.
Systemsoftware
Das sind Programme, die dem Betrieb des Rechners und der Programmentwicklung dienen.
Anwendersoftware
Wird mit Hilfe der Systemsoftware entwickelt und ist für spezielle Anwendungen konzipiert z.B. Tabellenkalkulation, Textverarbeitungsprogramme, Grafikeditoren, CAD-Programme u.v.m.
Prof. Dr. Keller
Seite 10 von 102
Systemsoftware
Software
System
Software
Betriebssystem
Hardwareunabhängige
Ein-/Ausgabe
Effiziente Nutzung der
ressourcen
Laden von
Programmen
Anwender
Software
Compiler
Binder
Dienstprogramme
Werkzeuge
Erstellen von
Anwenderprogrammen
Editoren
Filter
Kommandointerpreter
Mensch/Maschine
Schnittstelle
Textoreintiert z.B.
UNIX-Shell
Grafische
Oberfläche z.B.
Windows NT
Was ist ein Betriebssystem?
Software, die mit der Hardware eines Rechners ausgeliefert wird und im privilegierten Modus abläuft
Software, die dem Anwender eine einfache und komfortable Nutzung der Rechnerhardware ermöglicht
Software, die einem Anwendungsprogrammierer über eine Programmierschnittstelle ( API ) eine
virtuelle Maschine vorspiegelt
Funktionen eines Betriebssystems
Hardwareunabhängige Ein-/Ausgabe
z.B. Lesen und schreiben auf Dateien, anstatt Positionieren von Schreib-/Leseköpfen und Adressierung von Sektoren/Spuren auf Platte
Optimale Nutzung der Systemressourcen wie
Verteilung des Prozessors auf mehrere Programme ( Ziel 100%-ige Auslastung der CPU )
Verteilung des Speichers auf mehrere Programme
Zuteilung von Geräten an nebenläufige Benutzerprozesse
Laden von Anwendungsprogrammen
Realisierung von Schutzmechanismen
Prof. Dr. Keller
Seite 11 von 102
Was sind Systemressourcen?
Systemressourcen
Arbeitsspeicher
CPU
Ausführung mehrerer
nebenläufiger
Programme
(Multiprogramming)
1.4
Betriebssystem
AnwendungsProgramm
Daten
Terminal, Drucker
Plotter ...
Festplatte,
Bandlaufwerk
externer
Speicher
Ein-/Ausgabe
Geräte
Verwaltung von
Daten
Zuteilung an
Programme
Architektur von Betriebssystemen
Betriebssystemstrukturen
Struktur aus Sicht des BS-Entwicklers
8
Monolitische
Systeme
Betriebssystem besteht aus einer Sammlung von Funktionen. Jede kann jede aufrufen.
8
Schichtenmodell
Streng hierarchischer Aufbau. Jede Schicht enthält eine Sammlung von Funktionen, die eine neue virtuelle Maschine r
Funktionen der Schicht Mi können nur Funktionen der Schicht Mi-1 aufrufen.
Geringste Privilegien
Maschine M2
Maschine M1
Höchste Privilegien
8
Menge von Funktionen der Schicht M1
Maschine M0
Rechnerhardware
Client-Server-Architektur
8
8
Client 1
leichte Erweiterbarkeit
Überschaubare Struktur
Client 1
DateiServer
Übertragbar auf
verteilte Systeme
SpeicherServer
Maschine 1 Maschine 2
Maschine 3
Minimaler BS-Kern
Client
Client
Server
nur elementare Dienste: Prozeßverwaltung,
Interprozeßkommunikation
BS-Kern
BS-Kern
BS-Kern
LAN
Prof. Dr. Keller
Seite 12 von 102
Betriebssystemstrukturen
Struktur aus der Sicht des Systemprogrammierers
Systemprogramme
sonst.
Anwenderprogramme
Programmierschnittstelle
User
Modus
Systemfunktionen
Systemaufrufe
Supervisorcall ( SVC )
privilegierter
Modus
Betriebssystemkern
Rechnerhardware
1.4.1
Beispiel: Architektur von Windows NT
Windows NT Modell
zu jedem
Subsystem
existiert eine
API
Anwenderprogramm Anwenderprogramm
( WIN 16 Client )
( WIN 32 Client )
Protected Subsysteme ( Server )
WIN32
OS/2
POSIX
WIN16
User
Modus
DOS
System Calls
NT Executive
privilegierter
Modus
HAL
Rechnerhardware
Windows NT = Windows New Technologie
HAL = Hardeware Abstraction Layer
Die Architektur von Windows NT ist eine Kombination von Client/Server-Modell und Schichtenmodell.
Der privilegierte Systemteil, dazu gehören die System Calls, die NT Executive und HAL, wurde im
Schichtenmodell realisiert.
Das Protected Subsystem bildet das Client/Server-Modell. Jedes Subsystem ist ein Server, der als eigenständiger Prozess im User Modus abläuft, und bestimmte Systemfunktionen und Benutzerumgebun-
Prof. Dr. Keller
Seite 13 von 102
gen realisiert. Klienten sind die Anwendungsprogramme, die in einer bestimmten Benutzerumgebung
laufen und Systemfunktionen von den Servern abrufen.
In der NT Executive werden elementare Objekte und Systemfunktionen zu Verfügung gestellt, die über
System Calls von den Servern aufgerufen werden. Ein Client kann selbst keine System Calls auslösen. In
der NT Executive sind folgende Module realisiert:
Objekt Manager
Er verwaltet alle internen Systemobjekte. In NT werden
Betriebssystemressourcen und Prozesse als Objekte realisiert.
Prozeß Manager
Er verwaltet Prozesse und Threads. Er beinhaltet den Scheduler.
Speicherverwaltung
I/O Manager
Er realisiert die Dateiverwaltung, Geräte- und Netzwerktreiber
Die HAL ( Hardware Abstraction Layer ) ist die unterste Schicht, die hardwareunabhängige Gerätefunktionen zur Verfügung stellt. Zur HAL gehören daher alle Interruptroutinen.
1.4.2
Subsysteme unter Windows NT
Windows NT - Protected Subsysteme
DOSClient
Virtual
DOS
Machine
( VDM )
WIN 3.1
Client
NT Client
WIN 16 API
WIN 32 API
WIN16
Subsystem
Botschaft
Unix
Client
OS/2
Client
POSIX API
OS/2 API
POSIX
Subsystem
OS/2
Subsystem
WIN32 Subsystem
(Bearbeitung API + Benutzeroberfläche )
System Call
NT Executive
Ein Subsystem ist ein Server, der für Anwendungsprogramme ( Clients ) eine bestimmte Systemumgebung und Systemfunktionen zu Verfügung stellt.
Jedes Subsystem ist ein unabhängiger Prozess, der im User Modus läuft.
Jedes Subsystem stellt der Anwendung ein eigenes API zu Verfügung. Jeder API-Aufruf im Klienten bewirkt, dass eine Botschaft an den Server geschickt wird. Der Server wiederum löst über System Calls
Aktionen in der NT Executive aus.
Prof. Dr. Keller
Seite 14 von 102
NT unterscheidet zwei Arten von Servern ( Subsystemen )
1. Environment Subsystem
Diese realisieren bzw. emulieren eine bestimmte Betriebssystemumgebung einschließlich der Benutzeroberfläche.
Das WIN32 Subsystem bildet die grafische Benutzeroberfläche von NT.
Das WIN16 Subsystem realisiert eine Windows 3.1 Umgebung und bildet zusammen mit dem
DOS Subsystem eine virtuelle DOS Maschine (VDM)
Das OS/2 Subsystem realisiert eine OS/2 Umgebung
Das POSIX Subsystem realisiert eine UNIX-Umgebung
2. Integral Subsystems
Durch diese Server werden wichtige Betriebssystemfunktionen aus der Executive ausgelagert, die nicht
den privilegierten Modus verlangen. z.B verwaltet das Security Subsystem alle User Accounts, Passworte, Quoten, Privilegien u.v.m.
Der Workstation Service und der Server Service stellen die Netzwerkumgebung ( Networking Subsystem)
zu Verfügung.
1.5
Systemaufrufe ( Supervisor call )
Funktionen des Betriebssystemkerns laufen im privilegierten Modus. Die Unterbrechungstechnik ermöglicht eine Umschaltung vom Benutzermodus in den privilegierten Modus. Der Eintritt in Betriebssystemfunktionen des Kerns ist daher nur über Unterbrechungstechnik möglich. Unterbrechungsroutinen bilden
den Betriebssystemkern.
1.5.1
Unterbrechungstechnik
Asynchrone
Unterbrechung
Interrupt
Gerätetreiber
Synchrone
Unterbrechung
TRAP, SVC
Betriebssystemkern
Ausnahme
bei
Befehlsabwicklung
Fehlerbehandlung
Prof. Dr. Keller
Seite 15 von 102
Systemaufrufe ( SVC )
Ablauf einer synchronen Unterbrechung
User Mode
UserProgramm
Trap
Priviilegierter
Modus
Systemstack
Retten User PC
SVC
Unterbrechungsbearbeitung
im Steuerwerk
BSProgramm
Besorgen BS-Adresse
( Hardware )
RTE
Rückkehr zu
unterbrochenem Programm
Besorgen User PC
Tabelle mit
Startadressen der
Unterbrechungsprogramme
Umschalten Modus
Verzweigen in BS
1.5.2
Systemfunktionen
Systemfunktionen bilden die Schnittstelle zum Programmierer. Die Funktionen stehen in einer Systembibliothek als Unterprogramme dem Programmierer zu Verfügung
Systemfunktionen als Programmierschnittstelle
User
Modus
Privileg.
Modus
User-Programm
Betriebssystemkern
Unterprogrammaufruf
werden aus
Systembibliotthek
dazugebunden
Parameter
Systemfunktionen
Parameter setzen
SVC
Rücksprung von UP
TrapBehandlung
BS-Daten
IRBehandlung
RTE
I/OGeräte
Prof. Dr. Keller
Seite 16 von 102
Systemaufrufe
Systemfunktion
User
Programm
Aufruf
Systemfunktion
Bearbeitung
SVC ( BS-Routine )
UP-Aufruf
Bearbeitung
Interrupt
Privilegierter Modus
Parameter für Systemaufruf
bereitstellen
Betriebssystem
Asynchrone
Unterbrechung
Synchrone Unterbrechung
Systemaufruf ( TRAP )
Parameter auswerten
Ergebnis holen und interpretieren
Interruptbearbeitung
Aktionen ausführen
BenutzerProzeß
RTS
Rückkehr
Ergebnis zu Verfügung stellen
User Modus
1.5.3
Rücksprung
RTE
Beispiel - Daten in eine Datei schreiben
Systemfunktion:
write( datei, datenpuffer, anzahl_byte )
SVC:
Trap-Routine Nr. 5
Parameter werden in Registern übergeben
Beispiel : Daten in Datei schreiben
User
Programm
Systemfunktion
write(file,buffer,anz)
Bearbeitung
SVC ( BS-Routine )
UP-Aufruf
Bearbeitung
Interrupt
Privilegierter Modus
Parameter in Register
schreiben
Platte zum schreiben
bereit
Synchrone Unterbrechung
TRAP #5
Parameter auswerten
IO-Auftrag beschaffen
Ergebnis holen
und interpretieren
Fehler
rückmelden
Rückkehr
IO-Auftrag für
Platte erzeugen
Daten schreiben
RTS
Auftragsbearbeitung
starten
User Modus
Rücksprung
IO-Auftrag löschen
RTE
RTE
Prof. Dr. Keller
1.6
Seite 17 von 102
Übungsaufgabe
1.6.1
Aufgabe 1
In der Vorlesung wurde ein Schichtenmodell als Architektur für ein Betriebssystem eingeführt. Dabei wurde das Betriebssystem in zwei Softwareschichten aufgeteilt, die Systemfunktionen und die Systemaufrufe, auch Supervisor Calls ( SVC ) genannt.
a)
Kennzeichnen Sie in der folgenden Grafik die Schicht der "Systemfunktionen" und die Schicht der
" Systemaufrufe (SVC) ".
Anwenderprogramme
Rechnerhardware
b)
Erläutern sie kurz die Aufgaben, die eine Systemfunktion übernimmt und mit welcher Programmiertechnik eine Systemfunktion realisiert wird, d.h. in welcher Form Systemfunktionen dem Anwenderprogramm zur Verfügung stehen.
c)
Erläutern Sie kurz mit welcher Technik ein Systemaufruf ( SVC ) realisiert wird und was bei einem
Systemaufruf im Rechner abläuft?
d)
Das System unterscheidet zwei Abwicklungsmodi User und Privilegiert.
In welchem Modus laufen die Systemfunktionen ?
In welchem Modus laufen die Systemaufrufe ?
Prof. Dr. Keller
Seite 18 von 102
2. Multiprogramming
2.1
Prozesse
Ein Prozess ist ein Programm, welches auf einem Prozessor unter einem Betriebssystem als atomare Einheit abläuft.
Jeder Prozess besitzt seinen eigenen virtuellen Prozessor mit seinem eigenen virtuellen Adressraum, der gegenüber anderen Prozessen geschützt ist, d.h. auf Adressen eines Prozesses A
kann kein anderer Prozess im System zugreifen. Jeder Prozess läuft unabhängig von allen anderen auf dem Rechner ab.
Ein Prozess ist eine Verwaltungseinheit des Betriebssystems. Das BS vergibt dazu für einen Prozess eine eindeutige Kennung ( PID = process identifikation ).
Für jeden Prozess erzeugt und verwaltet das BS eine Datenstruktur, in der Kennung, Zustand
und Umgebung eines Prozesses gespeichert sind. Dieser Prozesskontrollblock ( PCB ), in dem
alle Information über einen Prozess abgelegt ist, wird in einer Prozesstabelle verwaltet. Die Prozesstabelle enthält alle aktuellen Prozesse im laufenden System. Diese Prozesstabelle kann statisch ( z.B. UNIX ) oder aber auch dynamisch angelegt werden.
Zu einem Prozess gehört ein ausführbares Programm, die Daten des Programms und ein dynamischer Stack. Weiterhin gehört zu jedem Prozess ein eigener Hardwarekontext, das sind die
Hardwareregister, der Programmzähler ( PC ), und ein Stackzeiger ( SP ) sowie weitere Informationen, die den Zustand und die Eigenschaften des Prozesses beschreiben (Softwarekontext) z.B.
verbrauchte Rechenzeit, Abarbeitungspriorität, geöffnete Dateien.
Das Betriebssystem stellt Funktionen zur Verfügung mit Hilfe derer zur Laufzeit dynamisch Prozesse erzeugt und vernichtet werden können. In UNIX sind dies z.B. die Funktionen fork() zum
Erzeugen eines Prozesses, exit() zum freiwilligen beenden eines Prozesses und kill() zum unfreiwilligen Vernichten eines Prozesses durch einen anderen Prozess.
2.1.1
Prozess-Adressraum
Multitasking - Prozess, Task
Betriebssystem
Code + Daten
Programm
auf
Festplatte
Laden
Starten
Enthält
Verwaltungsdaten
zu einem
Prozess
Prozess #1
Code
Prozess #12
statische
Daten
Stack
Arbeitsspeicher
Heap für
dynamische
Daten
Prof. Dr. Keller
2.1.2
Seite 19 von 102
Prozesszustände
Multitasking - Prozesszustände
Zuteilung durch BS
( Scheduling )
rechnend
Prozess
terminieren
Prozess
bereit
erzeugen
Verdrängen durch BS
( Laden, Starten )
Blockieren durch Prozess
Deblockieren durch BS
Eintreffen von Ereignissen
freiwerden von Ressourcen
Warten auf Ereignisse
oder Ressourcen
blockiert
• preemptive Scheduling
• non preemptive Scheduling
– Prozesswechsel wird vom
Betriebssystem erzwungen
(Zeitscheibenverfahren )
2.2
2.2.1
– Prozesswechsel erfolgt nur
durch freiwillige Abgabe der
CPU durch einen Prozess
(Systemaufrufe im Programm)
Prozeßwechsel ( Dispatch, Scheduling )
Freiwilliger Prozeßwechsel durch Aufrufen einer
Systemfunktion ( non preemptive )
Multitasking
Prozesswechsel durch Systemaufruf
Prozess blockieren
Aktionen
Benutzerprozess
Systemfunktion
I/O-Auftrag
initieren
IO-Auftrag ausführen
Prozess deblockieren
Aktionen
Benutzerprozess
BenutzerProzesse
Dispatcher
Prozessauswahl
Scheduler
Prozess aktivieren
Betriebssystem
Prof. Dr. Keller
2.2.2
Seite 20 von 102
Erzwungener Prozeßwechsel ( preemptive )
Multitasking
Prozesswechsel durch Zeitscheibe
Zeitscheibe
abgelaufen
Aktionen
Benutzerprozess
Dispatcher
aktivieren
Prozess
verdrängen
Aktionen
Benutzerprozess
BenutzerProzesse
2.3
Dispatcher
Prozessauswahl
Prozess aktivieren
Scheduler
Betriebssystem
Threads
Threads
•
Sequentielle Programm- / Funktionsausführung innerhalb eines
Prozesses
( thread = Ausführungsfaden )
– Ein thread bearbeitet eine sequentielle Teilaufgabe innerhalb eines
Prozesses
– Mehrere nebenläufige Teilaufgaben können in mehreren Threads
innerhalb eines Prozesses abgearbeitet werden ( Multithreading )
– Thread verfügt über einen eigenen Hardwarekontext ( PC, SP,
Prozessorregister ), einen Ausführungszustand und einen eigenen
Stack
– läuft jedoch im Softwarekontext des Prozesses und teilt sich damit
den virtuellen Adressraum und alle Ressourcen mit allen anderen
Threads des Prozesses
Prof. Dr. Keller
Threads
Nebenläufige Ausführungsfunktionen
Prozess 1
Prozess 2
3 Threads
1 Thread
Verwaltungsungs-/
Sicherungsaufgaben
Adressraum
Ressourcen
Schutzfunktionen
Verwaltungsungs-/
Sicherungsaufgaben
Adressraum
Ressourcen
Schutzfunktionen
Programmausführung
Programmausführung
Globale
Variable
Threads
• Vorteile:
– schneller Prozesswechsel, da nur der Hardwarekontext
ausgetauscht werden muss
– einfacher Austausch von Informationen zwischen
nebenläufigen Threads durch einen gemeinsamen
Adressraum (globale Daten des Prozesses )
• Nachteile:
– Durch den gemeinsamen Adressraum ist kein Schutz vor
fehlerhaftem Zugriff auf globale Daten möglich
• Wenn mehrere Threads auf gemeinsame Daten arbeiten,
müssen diese Threads synchronisiert werden. Fehlende oder
fehlerhafte Synchronisation verursacht Datenverluste oder
Dateninkonsistenzen
Seite 21 von 102
Prof. Dr. Keller
Multithreading
Thread-Implementierung
• Benutzer-Threads ( ULT = user level Thread )
– Unix, Linux
• Kernel-Threads ( KLT = kernel level thread )
– Windows NT/2000/XP, Linux, Mach
• Kombination ( Solaris )
Multithreading
Benutzer-Threads
•
•
•
Laufen im User Modus. Der BS-Kern ( Kernel ) kennt unbd
verwaltet selbst keine Threads sondern nur Prozesse.
Der Anwendungsprozess verwaltetet seine Threads selbst
Die Verwaltung erfolgt über eine Thread-Bibliothek, in der alle
Funktionen zur Verwaltung, Erzeugung, Terminieren und
Synchronisieren realisiert werden.
– In der Bibliothek sind für jeden Thread entsprechende
Datenstrukturen implementiert.
– Weiterhin übernimmt die Bibliothek auch das Umschalten und
Scheduling zwischen den Threads innerhalb des Prozesses.
– Scheduling von Prozessen ist damit unabhängig vom Scheduling
der Threads
Seite 22 von 102
Prof. Dr. Keller
Multithreading
Benutzer-Threads
•
Beispiel
– BS kennt Prozess A und Prozess B
– Prozess A besitzt Thread A.1 und Thread A.2.
– Prozess B besitzt nur Thread B.1
– Fall 1:
• Prozess A ist rechnend. Innerhalb A ist Thread A.2 rechnend. Thread
A.2 ruft eine blockiernde Systemfunktion z.B. I/O-Wunsch auf.
– SVC d.h. Sprung in den Kernel zur Abarbeitung der Systemfunktion.
– Prozess A wird blockiert. Prozess B wird rechnend.
– Im Prozess A wird Thread A.2 immer noch als rechnend eingestuft.
• I/O.Ereignis ist eingetroffen.
– Sprung in den Kernel
– Prozess A wird vom Kernel wieder deblockiert.
– Wenn Prozess A vom Kernel wieder in den Zustand rechnend überführt wird
kann Thread A.2 weiter ausgeführt werden.
Multithreading
Benutzer-Threads
• Beispiel
– BS kennt Prozess A und Prozess B
– Prozess A besitzt Thread A.1 und Thread A.2.
– Prozess B besitzt nur Thread B.1
– Fall 2:
• Prozess A ist rechnend. Innerhalb A ist Thread A.2 rechnend.
Thread A.2 ruft blockiernde Funktion der Thread-Bibliothek auf
z.B. warten auf Ereignis von Thread A.1
– Prozess A bleibt rechnend ( falls Zeitscheibe noch nicht
abgelaufen ist ),
– Thread A.2 wird blockiert und Thread A.1 wird rechnend.
Seite 23 von 102
Prof. Dr. Keller
Multithreading
Benutzer-Threads
• Vorteile:
– Threadwechsel wird im User-Modus abgearbeitet. Kein SVC
und daher wesentlich schneller.
– Prozessspezifisches Scheduling der Threads unabhängig
vom Scheduling des BS-Kerns.
– Die Bibliothek kann auf jedes beliebige Betriebssystem
aufgebaut werden. Es sind keinerlei Änderungen im Kernel
notwendig.
• Nachteile:
– Blockiert ein thread blockiert auch der Prozess und damit
auch alle anderen threads im Prozess.
– Mehrprozessorbetrieb ist nicht nutzbar. Alle Threads eines
Prozesses laufen auf einem Prozessor ab.
Multithreading
Kernel-Thread
•
Kernel übernimmt die Verwaltung von Threads und Prozessen
•
Das Scheduling erfolgt im Betriebssystem auf Basis der threads.
•
Vorteile:
– Unterstützt Mehrprozessoren-Archtiketur
– Ein blockierter thread blockiert nicht nicht andere threads im
gleichen Prozess.
•
Nachteil:
– Ein Threadwechsel bedeutet immer auch aufrufen eines SVC und
damit Übergang in den privilegierten Modus.
Seite 24 von 102
Prof. Dr. Keller
2.3.1
Seite 25 von 102
Definition und Erzeugung von Threads
STATISCHE
THRE
ADS
Die Anzahl der Threads in einem Prozess wird bei der Programmentwicklung d.h. zum Zeitpunkt des
Übersetzens festgelegt
DYNAMISCHE
THR
EADS
Das Erzeugen und Beenden von Threads erfolgt während der Prozesslaufzeit. Das Betriebssystem stellt
dazu Funktionen zum Erzeugen und Vernichten von Threads zu Verfügung
→ Windows NT, Linux
2.4
Wichtige Systemfunktionen
Neuen Prozess erzeugen
Neuen Thread erzeugen
Prozess freiwillig beenden
Thread freiwillig beenden
Prozess / Thread ohne Grund freiwillig blockieren ( suspendieren )
Prozess / Thread deblockieren
Prozesse im Hintergrund laufen lassen
Prozesse zu bestimmten Zeiten starten
Prozessinformationen anzeigen lassen
PID des Prozesses / Thread besorgen
2.5
Scheduling Verfahren
Optimierungskriterien:
Antwort
des
Systems
Zeit I/ORequest
• Antwortzeit ↓
t0
t1
• CPU-Auslastung (möglichst hin zu 100%, real 50-80%) ↑
• Durchsatz:
Anzahl der beendeten Jobs / Zeiteinheit ↑
• Verweildauer:
Zeit vom Start eines Prozesses bis zu
dessen Terminierung inkl. aller Wartezeiten ↓ t0
• Wartezeit:
Zeitpunkt der
Terminierung
Startzeit
Inkl. aller
Wartezeiten
Zeit in der ein Prozess in der Bereit-Schlange liegt
t1
Prof. Dr. Keller
Seite 26 von 102
Algorithmen:
2.5.1
First Come First Serve (FCFS)
BA
FÜR
TCH
-BE
TRIEB
GEEIGNET
BEISPIEL:
D
C
B
A
10
5
3
20
→ tatsächliche
Rechenzeit
FIFO (einfach verkettete Liste)
Annahme:
- kein I/O
- Alle Prozesse werden direkt nacheinander gestartet (d.h. Startzeit ist gleich)
Zeitliche Abarbeitungsfolge:
t0
A
B
C
D
20
3
5
10
t
Verweildauer der Prozesse:
VD(A)=20
VD(B)=23
VD(C)=28
VD(D)=38
2.5.2
Mittlere Verweildauer:
VD=(20+23+28+38)/4=27
Vorteile:
- einfach
- schnell
Nachteile:
- sehr lange Verweildauer
- große Schwankungen in der Verweildauer
Shortest Job First (Modifikation von FCFS )
Zeitliche Abarbeitungsfolge ( siehe Beispiel FCFS)
t0
B
C
D
A
3
5
10
20
Mittlere Verweildauer:
Vorteil:
Nachteil:
VD=(3+8+18+38)/4=17
- Minimale Verweildauer
- Rechenzeit ist zur Zeit des Starts nicht bekannt
t
Prof. Dr. Keller
2.5.3
Round Robin (RR)
Zeitscheibenverfahren
GEEIGNET
FÜR
D
IALOGBETRIEB
Rundlauf
B
A
Seite 27 von 102
Annahme: - Zeitscheibe hat Zeiteinheit ∆t=5
C
E
D
Zeitliche Abarbeitungsfolge ( siehe Beispiel FCFS)
A
B
C
D
A
D
A
A
5
3
5
5
5
5
5
5
t
VD=(38+8+13+28)/4=87/4≈22
BEISPIELE MIT UNTERSCHIEDLICHER ZEITSCHEIBE (A: RZ=20, B: RZ=3, C: RZ=5, D: RZ=10)
∆t=2
A
B
C
D
A
B
C
D
A
C
D
A
D
A
D
A
A
A
A
A
2
2
2
2
2
1
2
2
2
1
2
2
2
2
2
2
2
2
2
2
VD(A)=38
VD(B)=11
VD(C)=18
VD(D)=28
t
VD=(38+11+18+28)/4=95/4≈24
∆t=10
A
B
C
D
A
10
3
5
10
10
VD=(38+13+18+28)/4=24,...
t
Prof. Dr. Keller
2.5.4
Seite 28 von 102
Prioritäten
Jedem Prozess wird eine Priorität zugeordnet
statisch ( beim starten des Programms )
Wie werden die Prioritäten vergeben
dynamisch (Prioritäten werden zur Laufzeit des Prozesses
geändert)
BEISPIELE:
non-preemptives Verfahren
Prioritäten
A: Prio=5 , Rz=20
B: Prio=3 , Rz=3
C: Prio=7 , Rz=5
D: Prio=1 , Rz=10
(7 ist höchste Priorität)
Alle Prozesse starten zum Zeitpunkt t=0
t0=0
C
5
A
B
D
20
3
10
t
VD=(5+25+28+38)/4=96/4=24
preemptives Verfahren
Alle Prozesse starten zu unterschiedlichen Zeitpunkten.
Es gilt folgende Annahme:
t0=0
Startzeit von A=0
B=1
C=5
D=8
A
C
A
B
D
5
5
15
3
10
VD(A)=25
VD(B)=28-1=27
VD(C)=10-5=5
VD(D)=38-8=30
t
VD=(25+27+5+30)/4=87/4≈22
non-preemptive mit unterschiedliche Startzeiten ( Startzeiten siehe oben ):
t0=0
VD(A)=20
VD(B)=27
VD(C)=20
VD(D)=30
A
C
B
D
20
5
3
10
VD=(20+27+20+30)/4=97/4≈24
t
Prof. Dr. Keller
2.6
2.6.1
Seite 29 von 102
Multiprogramming in UNIX
Prozesse in UNIX
Prozesse unter UNIX - Prozessarten
• Interaktive Prozesse
– Shell-Prozesse arbeiten mit stdin ( Tastatur ) und stdout (
Bildschirm )
• Dämon-Prozesse ( deamon )
– arbeiten im Hintergrund ohne stdin und stdout z.B.
Druckspooler, Swapper, Paging Dämon
Als Daemon ( Disk And Execution MONitor ) werden unter Linux die verschiedenen dienstbaren Geister
bezeichnet. Das sind Prozesse, die unauffällig im Hintergrund warten, ob es etwas für sie zu tun gibt.
Wenn ja, wird das erledigt, dann gehen sie wieder in Wartestellung. Benutzerinteraktionen finden hierbei
nur auf indirektem Weg statt.
Bei Microsoft Windows heißen die entsprechenden Programme "services" bzw. "Dienste".
Daemons werden nicht vom Computerbenutzer interaktiv bedient, sondern warten im Hintergrund, bis sie
durch eine Netzwerkanfrage oder ein anderes Programm aktiviert werden.
Typische Daemonprogramme sind Server-Prozesse wie Netzwerkdienste, File-Sharing, E-Mail-Server,
Datenbankserver und Druckerserver. Sie dienen auch der Hardwarekonfiguration bzw. Überwachung,
oder sie laufen zu vorher festgelegten Zeiten automatisch an.
Ein typisches Beispiel ist der lpd, der line printer daemon. Er wartet, ob ein Druckauftrag gegeben wurde,
wenn ja, wird er von ihm abgearbeitet. Der lpd kann Druckjobs entgegennehmen, auch wenn der Drucker
nicht betriebsbereit oder sogar nicht einmal angeschlossen ist, die Dateien werden eben solange zwischengespeichert.
Daemonen können z.B. gleich beim Systemstart aus den Startdateien heraus gestartet werden, z.B. aus
/etc/rc.d/rc.local heraus. Daemonen im Leerlauf verbrauchen zwar nur wenig Systemleistung, bei einem
gut ausgebauten Server sind aber recht viele Daemonen am Werk, die dann eben doch eine nennenswerte Grundlast erzeugen.
Daher existiert noch eine weitere Startmöglichkeit über den Metadaemon inetd.
Aufgrund von Konfigurationsdateien achtet er permanent darauf, ob vom System die Dienste eines Dämonen benötigt werden. Wenn ja, startet er den entsprechenden Dämon, der sich nach Abarbeitung des
Auftrages dann wieder beendet. Im Idealfall ist dann nur dieser Metadaemon permanent am Laufen, alle
anderen laufen nur, wenn sie auch gerade benötigt werden. Der Metadaemon inetd wird aus der Datei
/etc/rc.d/rc.inet2 heraus gestartet. Wann er welchen Daemon starten soll, erfährt inetd aus der Konfigurationsdatei /etc/inetd.conf
Prof. Dr. Keller
Seite 30 von 102
Beispiele (bei Unix)
initd Daemon (/sbin/initd)
Der initd Daemon ist das letzte Programm, das der Kernel beim
Hochfahren startet. Er bleibt so lange aktiv, bis das System heruntergefahren wird. Der Init-Daemon wird durch die Konfigurationsdatei /etc/inittab
gesteuert.
cron daemon
Startet andere Programme zu festgelegten Zeiten
syslogd daemon
nimmt Meldungen von Programmen entgegen und schreibt diese ins Logfile
sendmail daemon
Mail Transfer Agent
lpd
der line printer daemon - wartet auf Druckaufträge und bearbeitet diese
Prozesse unter UNIX
• Prozesse werden in einer Prozesstabelle und PCB‘s
verwaltet. Ein Prozess wird unter Unix auch als Task
bezeichnet.
– Jeder Eintrag in der Prozesstabelle verweist auf den PCB
des Prozesses.
• Jeder Prozess wird durch eine eindeutige PID
verwaltet und verfügt über eine Gruppen-ID und
Benutzer-ID.
– Über Gruppe und Benutzer werden Zugriffsrechte auf
Ressourcen geregelt.
Prof. Dr. Keller
Seite 31 von 102
Prozesse unter UNIX - Erzeugen und
Terminieren
•
Prozess erzeugen
– Systemfunktion pid =fork()
• Es wird eine Kopie des aktuellen Prozesses erzeugt.
• Ergebnis der Funktion ( gespeichert in pid ):
– < 0 wenn Prozess nicht erzeugt werden konnte ( z.B. Prozesstabelle ist voll )
– = 0 im Sohnprozess
– >0 im Vaterprozess;
•
freiwilliges Ende
– exit (...)
•
Variable pid enthält die Prozessidentifikation der erzeugten Kopie
d.h. des Sohnprozesses
( wird vom Sohn aufgerufen )
Ausführen eines neuen Programms
– exec(....) ( wird vom Sohnprozess aufgerufen )
•
warten auf das Ende eines erzeugten Sohnprozesses
– wait(....), waitpid()
( wird vom Vater aufgerufen )
Prozesse unter UNIX - Erzeugen
Beispiel
.
.
.
.
pid = fork();
if ( pid <0 ) printf("Prozeß wurde nicht erzeugt\n");
else
if ( pid == 0 )
/* Starten eines neuen Programms im erzeugten Sohnprozeß
execl(......)
else
/* Vaterprozeß wartet auf Ende des Sohnprozesses */
wait(...)
*/
Prof. Dr. Keller
Seite 32 von 102
Prozesse unter UNIX erzeugen
Vater
Erzeuge Prozeß
pid = fork()
Ausgabe
Fehlermeldung
Warte auf
Ende Sohn
Sohn
Erzeugte Kopie
Führe ein neues
Programm xxxx aus
Erzeuge Prozeß
pid = fork()
Ausgabe
Fehlermeldung
Warte auf
Ende Sohn
Führe ein neues
Programm xxxx aus
freiwilliges Ende
freiwilliges Ende
Prozesse unter UNIX
•
Jeder Prozess kennt seinen Vater, seine Geschwister und alle seine
Kinder
•
Terminiert ein Sohnprozess, so wird er in den Zustand Zombie
versetzt bis der Vaterprozess den Terminierungsstatus vom BS
abgeholt hat.
•
Terminiert der Vaterprozess, so werden alle existierenden
Sohnprozesse einem neuen Vater zugeordnet.
– Dieser Vater ist immer der Prozess INIT ( Pid = 1 ).
•
Möchte der Vater nicht auf das Ende eines Sohnprozesses warten,
sondern ohne zu warten nur den Terminierungsstatus abholen, um
seinen Sohn aus dem zustand Zombie zu erlösen, kann er die
Systemfunktion waitpid() verwenden.
Prof. Dr. Keller
Seite 33 von 102
Prozesse unter UNIX - Systemfunktionen
• Eigene PID erfragen pid()
• Pid des Vaterprozesses erfragen ppid()
A
UFBAU
EINES
B
AUMES
UNTER
UNIX
BS-Kern
erzeugen
Systemfkt. exit ( )
für freiwilliges
Terminieren
PID=1
Urprozeß
Programm
Daten
Kontext
Sohnprozeß
erzeugen
Systemfkt:
fork ( )
PID=2
PID=2
Programm
Daten
Kontext
INIT
PCB
Warteschlangen
Überladen des
Programms
P
Systemfkt:
exec ( )
*
*
D
Kontext
*
Bei fork wird eine identische
Kopie erzeugt !! (Urprozeß geklont)
INIT (pid=1)
Login
Shell
prim
vi
emacs cc
Terminiert unter Unix ein Prozess, ohne dass der return-Status vom Vater abgeholt wurde, so wird der
Prozess in den Zustand „Zombie“ versetzt. Ein Zombi-Prozess kann nicht durch senden des kill-Signals
abgebrochen werden, da er schon terminiert ist. Erst wenn der Vater den return-Wert vom Betriebssystem abruft, dies geschieht durch die Systemfunktion wait() oder waitpid(), wird der Zombie-Prozess erlöst
und ist danach wirklich tot.
Prof. Dr. Keller
Multithreading
Seite 34 von 102
linux
• Linux verwaltet keinen eigenen threads
– Ein thread wird wie ein prozess behandelt.
• Unter linux werden threads durch Kopieren von
Prozessen erzeugt. Der Prozess erbt damit auch die
Ressourcen des Vaterprozesses.
• Es ist möglich das ein kopierter Prozess sich den
virtuellen Speicher mit seinem Vaterprozess teilt
– Dadurch entsteht ein thread in einem Prozess
2.6.2
Scheduling in UNIX
Scheduler in UNIX
Timesharing nach Round Robin
Ziel :
Optimieren der Antwortzeiten von interaktiven Prozessen
Zeitscheibe: 100ms
Zuteilung der CPU nach Prioritäten
Die Priorität eines Prozesses wird dynamisch entsprechend seiner Aktiviäten verändert.
Rechneintensive Prozesse werden bestraft. Interaktive Prozesse werden belohnt.
Auslastung der CPU durch den Prozeß: a
Der Wert von a wird wird mit jedem Zeittakt um 1 erhöht. Nach jeder Sekunde werden die Prioritäten neu berechnet
a:= a/2
Priorität:= Basispriorität +a/Konstante +Nice-Wert
Round Robin innerhalb einer Prioritätenschlange
Niedrigste
Priorität
Priorität = n
Nice
Rechenzeit
Priorität = 0
Höchste
Priorität
SVC
Priorität = - m
User
Prozesse
Basispriorität
Prozesse warten
auf Ereignis
( privileg. Modus )
Prof. Dr. Keller
2.7
Seite 35 von 102
Multiprogramming in Windows NT
2.7.1
Prozesse in NT
Ein Prozess wird in NT als Systemobjekt mit Eigenschaften ( Objektattribute ) und Methoden, die
von der Objektklasse „Process“ geerbt werden, realisiert. Zugriffe des Systems auf einen Prozess erfolgt damit nur über die implementierten Methoden der Objektklasse.
Das Scheduling erfolgt nur über Threads. Damit muss ein Prozess mindestens einen Thread besitzen, damit er lauffähig ist.
Ein Prozess kann über die Systemfunktion CreateProcess() dynamische zur Laufzeit mehrere
Threads erzeugen.
Zwischen Prozessen besteht keine Vater/Sohn-Beziehung wie in UNIX. Für jeden Prozess wird
ein Systemobjekt angelegt, in dem die Eigenschaften des aktuellen Prozesses gespeichert sind.
Jeder Prozess besitzt einen eigenen geschützten virtuellen Adreßraum von 4 GByte.
Objektklasse Prozess in Windows NT
Objektklasse PROZESS
Process ID
Access token
Base priority
Default processor affinity
Quota limits
Execution time
I/O counters
VM operation counters
Execution/debugging ports
Exit status
Create process
Open process
Query process information
Set process information
Current process
Terminate process
Allocate/free virtual memory
Read/write virtual memory
Protect virtual memory
Lock/unlock virtual memory
Query virtual memory
Flush virtual memory
Objektattribute
Objektmethoden
Objektattribute in Windows NT
Process ID :
Access token:
Base priority:
Default processor affinity:
Quota limits:
Execution time:
I/O counters:
Eine eindeutige Nummer, die NT für jeden erzeugten Prozess vergibt, um
damit den Prozess eindeutig identifizieren zu können.
Eine Referenz auf ein NT-Objekt, in dem Sicherheits- und Zugriffsinformationen über den eingeloggten Benutzer, zu dem der Prozess gehört,
abgelegt sind.
Eine Basispriorität für den Prozess. Beim starten des Prozesses wird die
Priorität auf diese Basispriorität gesetzt.
Eine vorgegebene Menge von Prozessoren, auf denen die Threads eines
Prozesses laufen können.
Maximalwerte für die Anzahl von physikalischen Seiten, Größe der Paging-Datei, und Rechenzeit
Die aktuell von allen Threads verbrauchte Rechenzeit.
Zähler für die Anzahl der I/O Operationen.
Prof. Dr. Keller
VM operation counters:
Execution/debugging port:
Exit status:
2.7.2
Seite 36 von 102
Zähler für die ausgeführten Speicheroperationen.
IP-Kanal, über den der Prozessmanager Nachrichten versendet, falls
eine Fehlersituation eingetreten ist.
Ein Wert, der den grund für ein Prozessende beschreibt.
Threads in NT
Ein Thread ist ein sequentieller Programmteil eines Prozesses, das nebenläufig zu anderen sequentiellen Programmteilen ( Threads ) im Adressraum des erzeugenden Prozesses abläuft. Ein
Thread kann damit als „Subprozess“ innerhalb eines Prozesses erklärt werden.
Ein Prozess besteht aus mindestens einem Thread. Grund: Scheduling in NT erfolgt ausschließlich
über Threads.
Ein Thread läuft im Kontext des Prozesses und teilt sich damit Adressraum und Ressourcen mit allen anderen Threads eines Prozesses.
Ein Thread kann selbst wieder Sohn-Threads erzeugen.
Eigenschaften eines Thread sind: eine eindeutige Kennung ( Client ID, Hardwarekontext bestehend aus Prozessorregister, PC, Stack, Stackzeiger ), Priorität, Rechenzeit, Wartezeit
Multithreading
Windows 2000
•
Threads werden als Kernel-Threads realisiert
•
Ein Prozess kann mehrere Threads besitzen
•
Scheduling in NT erfolgt ausschließlich über Threads
–
Ein Prozess besteht aus mindestens einem Thread.
•
Ein Thread kann selbst wieder Sohn-Threads erzeugen.
•
Eigenschaften eines Thread sind :
–
–
–
–
–
–
eine eindeutige Kennung ( Thread-ID )
Thread-Kontext (Prozessorregister, PC, Stack, Stackzeiger )
Basispriorität und Dynamische Priorität
Prozessoraffinität ( Prozessoren auf der dieser Thread ausgeführt werden kann )
Ausführungzeit ( = Rechenzeit )
Terminierungsstatus
Prof. Dr. Keller
2.7.3
Seite 37 von 102
Scheduling in NT
Threadzustände
Thread erzeugen
und starten
Windows 2000
Ressource
wird verfügbar
bereit
unterbrochen
unterbrochen
Scheduler
transition
Objekt wird
“signaled”
standby
Ressource
nicht verfügbar
wartend
Dispatcher
beendet
“Terminieren”
rechnend
Threadzustände
System Call
warte auf
“Objekt signaled”
Windows 2000
•
Bereit
– kann vom Scheduler eingeplant werden
•
Rechnend ( aktiv )
– Ist gerade auf einem Prozessor rechnend
•
Standby
– Wurde vom Scheduler ausgewählt muss aber noch auf einen bestimmten Prozessor
warten. Die Abarbeitung erfolgt sobald der Prozessor frei wird.
•
Wartend
– wartet auf Ereignis, auf I/O, auf Systemobjekte oder freiwillig ohne Grund
•
transition
– Grund der blockierung ist aufgehoben kann jedoch nicht abgearbeitet werden da noch
Ressourcen z.B. Speicher fehlen.
•
Beendet ( Terminiert )
– Hat sich selbst beendet oder wurde von anderen threads bzw. dem Vaterprozess
beendet
Preemptives zeit- und prioritätengesteuertes Scheduling.
Variable Prioritäten (1..15) werden zur Laufzeit vom Kernel verändert mit dem Ziel interaktive Prozesse mit hoher Priorität, I/O-intensive Threads mit mittlerer Priorität und rechenintensive Prozesse mit niedriger Priorität zu behandeln.
Die Priorität wird erhöht, wenn ein Prozess vom Zustand „wartend“ in den Zustand „bereit“ gelangt.
Prof. Dr. Keller
Seite 38 von 102
Die Priorität wird erniedrigt, wenn ein Thread nach Ablauf einer Zeitscheibe unterbrochen wird.
Die Priorität wird minimal zur Basispriorität und maximal af 15 verändert.
Realzeitprioritäten ( 16 .. 31 ) werden nicht vom System geändert.
Ein Thread erbt die Basispriorität vom Prozess.
Ein Thread kann die vererbte Basispriorität um maximal 2 nach oben oder nach unten verändern.
Diese veränderte Basispriorität des Thread wird die Priorität beim ersten rechnen des Thread.
2.8
Übungsaufgaben
2.8.1
Aufgabe 2
In einem Multiuser/Multitasking-Betriebssystem können mehrere Prozesse nebenläufig abgearbeitet werden. Jeder Prozeß läuft dabei auf einer virtuellen CPU ab, die im Multiplexverfahren einer realen CPU
zugeteilt werden. Die Speicherverwaltung kann bei Speicherbedarf Prozesse auslagern.
a)
Wie wird ein Prozeß vom Betriebssystem verwaltet? Welche Datenstrukturen werden beim Erzeugen eines Prozesses angelegt und welche Informationen sind dort abgelegt.
b)
Prozesse nehmen normalerweise verschiedene Zustände an. Geben Sie den Zustandsgraph eines
Prozesses an. Erläutern Sie die Bedeutung der Zustände und die Bedingungen für die Zustandsübergänge.
2.8.2
Aufgabe 3
In einem Multiuser/Multitasking Betriebssystem können mehrere Prozesse nebenläufig abgearbeitet werden. Jeder Prozess läuft dabei auf einer virtuellen CPU ab, die im Multiplexverfahren einer realen CPU
zugeteilt werden. Die Zuteilung einer virtuellen CPU an die reale CPU erfolgt durch das Betriebssystem
nach einem bestimmten Algorithmus.
a)
Erklären Sie die Funktion von Dispatcher und Scheduler.
Gegeben ist folgendes Petrinetz, das die kausale Abfolge von Aktionen bei der Prozessverwaltung
beschreibt. Kennzeichnen Sie im Petrinetz diejenige Transitionen, die zur Programmabwicklung eines Prozesses gehören mit P, diejenigen, die zum Dispatcher gehören mit D und diejenigen Transitionen, die zum Scheduler gehören, mit S ( Jede Transition im Petrinetz muss gekennzeichnet
werden).
Programmbefehl abwickeln
aktuellen Prozeß deaktivieren
neuen Prozeß auswählen
neuen Prozeß aktivieren
Prof. Dr. Keller
b)
Seite 39 von 102
Bei der Zuteilung der realen CPU an einen Prozess unterscheidet man non-preemptive und
preemptive Zuteilungsstrategien. Durch welche Ereignisse findet ein Prozesswechsel statt
•
•
2.8.3
im Falle von non-preemptive Scheduling
im Falle von preemptive Scheduling.
Aufgabe 4
Die Verweildauer eines Prozesses ist die Zeit vom Start eines Prozesses ( Einlagerung in die ReadyWarteschlange ) bis zum Ende eines Prozesses. Die Verweildauer umfasst damit sowohl reine Rechenzeit, als auch die Zeit, die der Prozess auf die Zuteilung warten muss. Die mittlere Verweildauer von Prozessen ist die Summe der Verweildauer aller Prozesse, die in einem Zeitintervall ablaufen, geteilt durch
die Anzahl der ausgeführten Prozesse. Sie kann als Gütemaß für einen Zuteilungsalgorithmus herangezogen werden.
Berechnen Sie die mittlere Verweildauer für die im Folgenden angegebene Situation:
y Fünf Prozesse werden auf zwei Rechnersystemen mit unterschiedlicher Zuteilungsstrategie in der
gleichen zeitlichen Reihenfolge gestartet.
y Betriebssystem A arbeitet nach der non-preemptive Strategie FIRST COME FIRST SERVE
( Prioritäten werden nicht berücksichtigt ).
y Betriebssystem B arbeitet mit preemptive PRIORITÄTENGESTEUERTER Zuteilung.
Berechnen Sie die mittlere Verweildauer für beide Fälle Betriebssystem A und Betriebssystem B.
Prozeßnummer
1
2
3
4
5
2.8.4
Startzeitpunkt ( in ms )
(bezogen auf to=0 ms)
0
5
8
10
15
Rechenzeit
( in ms )
10
5
3
10
7
Priorität
1
2
5
3
3
Aufgabe 5
In einem Multitasking-Betriebssystem werden mehrere Prozesse nebenläufig abgearbeitet.
Bei der Zuteilung der CPU an einen rechenbereiten Prozess verfolgt das Betriebssystem eine preemptive Prioritätensteuerung mit dynamischen Prioritäten d.h. beim Starten eines Prozesses erhält der
Prozess eine Basispriorität, die während der Laufzeit dynamisch vom Betriebssystem verändert wird. Gibt
es zwei Prozesse mit gleicher Priorität, so hat immer der gerade rechnende Prozess Vorrang vor einem
wartenden Prozess. Gibt es mehrere wartende Prozesse, so hat der Prozess Vorrang, der als letzter
gerechnet hat, also der Prozess mit der kleinsten Wartezeit.
Die dynamische Korrektur der Priorität erfolgt nach folgenden Regeln:
a)
b)
c)
d)
Nach jeder Zeiteinheit Rechenzeit wird die Priorität um 1 erniedrigt. Negative Prioritäten werden zu
0 gesetzt.
Nach einem Systemaufruf (SVC) wird nach Ablauf der Zeiteinheit die Priorität um 2 erhöht.
Bei der Berechnung der Priorität am Ende einer Zeiteinheit wird sowohl Regel a) als auch Regel b)
angewendet, d.h. ein Prozess ohne SVC wird um 1 erniedrigt ein Prozess mit SVC wird um 1 erhöht.
Tritt ein SVC zum Zeitpunkt einer Zeiteinheit auf, so wird Regel a) und Regel b) angewendet d.h.
die Priorität erhöht sich in diesem Fall um 1.
Im folgenden Beispiel werden drei Prozesse P1, P2 und P3 betrachtet. Die Prozesse starten alle zum
gleichen Zeitpunkt t=0, haben jedoch unterschiedliche Basisprioritäten. Alle SVC's treten zum Zeitpunkt
einer Zeiteinheit auf ( d.h. in diesem Fall soll Regel d anwendet werden ).
In der folgenden Tabelle sind die drei Prozesse im Detail beschrieben. Startzeit und Rechenzeit der einzelnen Prozesse sind in Zeiteinheiten (ZE) angegeben.
Prof. Dr. Keller
Prozessnummer
1
2
3
Rechenzeit
(in ZE)
6
5
4
Basispriorität
Seite 40 von 102
SVC bei Rechenzeit
kein SVC
1,2
2
5
3
4
Startzeit
0
0
0
Tragen Sie in die folgende Zeitleiste ein, welcher Prozess in der jeweiligen Zeiteinheit abläuft. Zeiten, in
denen das Betriebssystem arbeitet, sind wegzulassen.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
J Zeit in ZE
2.8.5
Aufgabe 6
Auf ihrem Rechner ist ein Multiprogramming-Betriebssystem MUBS installiert.
Der Scheduler von MUBS realisiert eine preemptive Zuteilungsstrategie, eine Kombination aus Round
Robin (RR) und dynamischen Prioritäten.
Die Priorität eines Prozesses wird beim Start angegeben. Ein Prozess kann die Priorität während der
Laufzeit durch Aufruf der Systemfunktion PRIO() um den Wert 1 erniedrigt werden. Die Erniedrigung der
Priorität wird erst in der folgenden Zeitscheibe wirksam.
Eine Erhöhung der Priorität um den Wert 2 erfolgt durch das Betriebssystem, wenn ein Prozess ein
I/O_Operation über die API-Funktionen IO_read() und IO_write() durchführt. Die Erhöhung der Priorität
wird erst in der folgenden Zeitscheibe wirksam.
Eine beim Start vergebene Priorität bleibt solange erhalten, bis der Prozess endet oder bis durch Aufruf
der Systemfunktion PRIO() die Priorität erniedrigt wird oder das BS aufgrund einer I/O-Operation eine
Erhöhung anordnet. Die neu berechnete Priorität bleibt erhalten, bis zum Ende des Prozesses oder einem erneuten Aufruf von PRIO() bzw. I/O-Operation.
Wird PRIO() oder eine IO_Operation innerhalb einer Zeitscheibe mehrmals aufgerufen wird die Priorität
bei jedem Systemaufruf erniedrigt bzw. erhöht d.h. nach dem zweiten Systemaufruf von PRIO() ist die
Priorität um 2 niedriger, nach zwei I/O_Operationen innerhalb einer Zeitscheibe um 4 erhöht.
Existieren zu Beginn einer Zeitscheibe mehrere Prozesse mit gleicher Priorität, so wird das Round Robin
Verfahren angewendet und es darf der Prozess beginnen, der am längsten nicht gerechnet hat.
In der folgenden Tabelle ist eine Situation beschrieben, in der 4 Prozesse zu unterschiedlichen Zeiten
starten. Alle Zeiten in der Tabelle sind als Zeiteinheiten angegeben ( 1 Zeiteinheit= 1 Zeitscheibe ). Die
Prozesse starten mit unterschiedlicher Priorität. Prozess 1,2 und 3 erniedrigen zur Laufzeit ihre Prioritäten. In der Spalte 5 ist angegeben in welcher Zeiteinheit ein Aufruf von PRIO() erfolgt. In Spalte 6 ist eingetragen, ob und wann die Prozesse eine I/O-Operation durchführen. Die Rechenzeit wird in Anzahl von
Zeiteinheiten angegeben, die der Prozess rechnet. Nach dem Start befindet sich ein Prozess daher in der
Rechenzeit 1.
Prozess-ID Startzeit Priorität beim
Start
Rechenzeit Aufruf von PRIO()
im Zeitintervall
1
0
3
3
2
I/O-Operationen
innerhalb des Zeitintervalls
3
2
2
4
5
2
1
3
5
6
7
1 und 5
-
4
10
5
5
-
2 und 4
Prof. Dr. Keller
Seite 41 von 102
Tragen Sie in die vorgegebene Zeitleiste ein, welcher Prozess in welcher Zeiteinheit mit welcher Priorität
abläuft
ProzessID
Priorität
Zeiteinheit
0
2.8.6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Aufgabe 7
In einem Multiuser/Multitasking-Betriebssystem werden mehrere Prozesse nebenläufig abgearbeitet. In
dem gegebenen Betriebssystem ist ein preemptive Scheduling-Algorithmus als Kombination von RoundRobin und Prioritätensteuerung realisiert.
a)
In der folgenden Tabelle ist eine Situation beschrieben, in der fünf Prozesse zu unterschiedlichen
Zeiten mit unterschiedlichen Prioritäten starten. Die Startzeit, als auch die Rechenzeit der einzelnen Prozesse sind in Zeiteinheiten (ZE) angegeben. Die Zeitscheibe beträgt 1 ZE. Die Prioritäten
werden mit steigendem Wert höher, d.h. Priorität 1 ist weniger wichtig als Priorität 5.
Prozessnummer
Startzeitpunkt ( ZE )
(bezogen auf to=0 ZE)
0
3
5
8
10
1
2
3
4
5
Rechenzeit
( in ZE)
10
3
8
2
5
Priorität
1
5
2
3
3
Tragen Sie in die folgende Zeitleiste ein, welcher Prozess in der jeweiligen Zeitscheibe abläuft. Zeiten, in denen das Betriebssystem arbeitet, sind wegzulassen.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
20
25
30
Zeit in ZE
b)
Die Verweildauer eines Prozesses ist die Zeit vom Start eines Prozesses (Einlagern in die ReadyWarteschlange) bis zum Ende eines Prozesses. Die Verweildauer umfasst damit sowohl reine Rechenzeit als auch die Zeit, die der Prozess auf die Zuteilung warten muss.
Wie groß ist die Verweildauer der einzelnen Prozesse aus Teilaufgabe a)?
Verweildauer(1)=
Verweildauer(2)=
Verweildauer(3)=
Verweildauer(4)=
Verweildauer(5)=
Prof. Dr. Keller
Seite 42 von 102
3. Arbeitsspeicherverwaltung
Speicherverwaltung
• Arbeitsspeicher muss auf mehrere Prozesse
aufgeteilt werden
– Dynamisches Einlagern und Auslagern von Prozessen
– Verschieben von Prozessen zur Laufzeit ( relocation )
Adresse 0
Betriebssystem
Dialogbetrieb
Prozeß 1
Prozeß 2
Prozeß 3
Swapping
( Auslagern )
Starten und
Beenden von
Prozessen
Adresse n
3.1
Partitionierung
Speicherpartitionierung
Partition
Feste Größe
Variable Größe
BS
BS
BS
BS
BS
Prozeß 1
Prozeß 1
Prozeß 1
Prozeß 1
Prozeß 1
frei
frei
Prozeß 2
Prozeß 2
Prozeß 3
Prozeß 3
Prozeß 3
Fragmentierung
Garbage
Collection
Prof. Dr. Keller
Seite 43 von 102
Dynamische Speicheranforderung
• Prozesse können zur Laufzeit dynamisch
Speicherblöcke anfordern bzw. freigeben
• Beispiel: Aufbau einer verketteten Liste, Bäume, Grafen
• Funktionen : malloc(), free() in C, new(), dispose() in PASCAL
• Realisierung durch Speicherverwaltung
Speicherbelegung
statisch beim Laden
Speicherbelegung
dynamisch zur Laufzeit
benachbarter
Speicher belegt
Speicherbereich
im Voraus reservieren
( beim Laden )
benachbarter
Speicher frei
Speicherpartition
belegen
3.1.1
Speicher voll
Speicher hat
noch Platz
Verschieben von
Prozessen im Speicher
Swapping
Strategien zur Speicherplatzvergabe
First Fit
Nehme den ersten passenden Block den du findest
Vorteil:
Nachteil:
Schnell
Viele kleine Blöcke bilden sich am Speicheranfang
Next Fit
Wie First Fit, jedoch beginne Suche nach dem letztem vergebenen Block
Best Fit
Suche nach einem Block, der am besten passt
Vorteil:
Nachteil:
Worst Fit
geringe Speicherverschwendung
langsam, da die gesamte Speicherliste durchsucht werden muß
Suche den größten Block und teile ihn, so das ein Block ausreichender Größe
übrig bleibt
Prof. Dr. Keller
3.2
Segmentierung
Segmentierung
Segment
Logische Einheit eines Programms
Segmentierung schon in der ExecutableDatei
physikalischer Adreßraum
(Arbeitsspeicher)
Segment 0
Code
Segment 1
Daten
0
1
2
3
Segment 2
Stack
Segmentnummer
Segment 3
Heap
Segmenttabelle
Adresse
im
Speicher
Segmentierung
•Adreßumrechnung
Physikalische Adresse
Logische Adresse
Segmentnummer
Offset
Basisadresse
Offset
•Eintrag einer Segmenttabelle
Anfangsadresse
Größe des Segments
Attribute
•Attribute eines Segments
•Zugriffsrechte (lesen, schreiben, ausführen)
•verschiebbar
•Auslagerbar
•sharable
•Compiler muß Segmentierung unterstützen
Seite 44 von 102
Prof. Dr. Keller
3.3
3.3.1
Beispiel
Virtueller Speicher
Overlays
ASSEMBLER
37K
Code Phase 1
8K
Code Phase 2
14K
Gemeinsame
Routinen
5K
Symboltabelle
10K
St
Overlay-Baum:
15
G
8K P1
Σ 23K
3.3.2
P2 14K
Phase 1: Aufbau der Symboltabelle
Phase 2: Codeerzeugung
Wird in beiden Phasen benötigt
( Rootsegment )
Rootsegment
Overlay’s
Σ 29K
Seitenwechselverfahren ( Paging )
Virtueller Speicher
Adreßraum des Prozesses > physikalischer
Adreßraum
virtueller Adreßraum
des Prozesses
0
physikalischer Adreßraum
( Arbeitspeicher )
Adreßabbildung
dff
BS
200
fff
ffff
Programmadresse
32-Bit
Adreßbus
24-Bit
Adreßabbildung durch Hardware und Betriebssystem
Seite 45 von 102
Prof. Dr. Keller
Seite 46 von 102
Paging
Problem
Nicht jede Adresse kann einzeln abgebildet werden
• Aufteilung des virtuellen Speichers in Seiten und des
physikalischen Speichers in Kacheln gleicher Größe
• Adressierung durch Seitennummer und Offset
Lösung
Verfahren
• Nur Abbildung der Anfangsadresse einer Seite auf eine Kachel
• Ein-/Auslagern von ganzen Seiten auf Festplatte zur Laufzeit
Paging - ein Beispiel
• PhysikalischerAdreßraum:
4K
• Vorhanden:
4K
• Virtueller Adreßraum:
8K
• Seitengröße:
1K
4 Kacheln
8 Seiten
Kachelnummer
Seitentabelle
Seite 0
Seite 1
Seite 2
Seite 3
Seite 4
Seite 5
0
1
2
3
4
5
6
7
1
1
2
1
-
0
3
1
-
0
-
0
-
0
0
1
Kachel 0
Kachel 1
Kachel 2
Kachel 3
Seite 6
Seite 7
Attribute
Präsenzflag
2 Bit
3 Bit
Seitennummer
Offset
10 Bit
Kachelnumer
10 Bit
Offset
Prof. Dr. Keller
BE
Seite 47 von 102
ISPIELE
Paging: Drei-Stufen-Paging, die SPARCReferenz
(8)
index 1
Kontext
0
(6)
index 2
erste Ebene
0
(6)
index 3
(12)
offset
zweite Ebene dritte Ebene
0
0
8
8
255
63
63
4095
8
Drei Ebenen Seitentabelle
im Speicher mit Auslagerung
Kontexttabelle
in MMU
8
0
4 K Kacheln
8
Speicherwort
8
8
Je Prozeß ein
Prozeßkontextzeiger
Kontextumschaltung durch
neuen Kontextzeiger
Kontextzeiger über die
Lebensdauer in Kontext-Tabelle (
MMU- Hardware) konstant
Beschränkung auf 4K Prozesse
Kontextzeiger und virtuelle
Adresse p
 hysikalische
Adresse
4 G vitueller Adressraum je
Prozess
1 M Seiten je Prozess á 4 K
384 Einträge je "process page
table"
4095
Vier-Stufen-Paging, M 68030 - Flexibilität
(32)
(0-25)(0-25)
d
(0-25)
(0-25)
(0-25)
( 7 - 15)
c
b
a
offset
unused
vier-stufige-Seitentabelle
•
•
•
Paging kann durch das
Betriebssystem mitbestimmt
werden (parametrierbare
Hardware- MMU
0 - 4 Stufen und Anzahl der
Adressbits, die eine Stufe
ausmachen sind SW-seitig
einstellbar (Index - Breite)
t ranslation control register
werden durch BS definiert
BS legt die Interpretation der
virtuellen Adresse fest
virtueller Adressraum kann
eingestellt werden ( < 232 )
Seitengröße kann eingestellt
werden (265 bytes bis 32 K)
Einstellung wieviel bit der
Adressraum wirklich hat
Die Eigenschaften des Paging werden ausschließlich durch das Betriebssystem bestimmt
Kein bekanntes Betriebssystem nutzt die Flexibilität ernsthaft aus
Prozeß-spezifische Definitionen des virtuellen Adressraums denkbar und eventuell sinnvoll
Prof. Dr. Keller
TR
ANSLATION
L
OOKASIDE
BUFFE
Seite 48 von 102
R
Bei mehrstufigen Verfahren liegen die Seitenersetzungstabellen im Arbeitsspeicher. Die Adressumrechnung erfordert daher mehrere Speicherzugriffe. Das bedeutet aber eine Verlangsamung der Adressumrechnung ( z.B. M68030 virtuelle Adresse erfordert fünf Speicherzugriffe ).
Die meisten Programme haben viele Speicherzugriffe in einer kleinen Zahl von Seiten. Für diesen kleinen
Anteil umgeht man die Seitentabellen durch eine schnellere Sonderlösung, einen Assoziativspeicher,
den Translation Lookaside Buffer ( TLB )
Translation Lookaside Buffer ( TLB )
virtuelle Adresse
Seitennummer
Offset
MMU
Seitennummer
Seitennummer
Seitennummer
Kachelnummer
Kachelnummer
Kachelnummer
TLB Hit
Zeiger PT
Page Table
Kachel
Kachel
Kachel
Kachel
Kachel
TLB Miss
Kachelnummer
Offset
physikalische Adresse
Der Assoziativspeicher ist Teil der MMU (minimal 32 Speicherzellen). Im Assoziativspeicher werden für
den aktuell rechnenden Prozess die im Moment gebräuchlichsten Seiten mit ihrem Seitentabelleneintrag
vorgehalten. Neben der Seitennummer enthält ein Speichereintrag auch die Kachelnummer.
Assoziativspeicher realisieren eine parallele Suche, d.h. die virtuelle Adresse wird gleichzeitig
mit allen Tabelleneinträgen verglichen.
Wird eine virtuelle Seite im TLB gefunden ( TLB Hit ), steht dort die Kachelnummer und die Adressumrechnung kann direkt erfolgen
War die Suche im TLB ohne Erfolg ( TLB Miss ), muß auf die Seitentabellen im Arbeitsspeicher
zurückgegriffen werden
Bei einem Prozesswechsel muss der TLB komplett ausgetauscht werden, da jetzt die Seiten des neuen
Prozesses eingetragen werden müssen. Für den Austausch des TLB-Inhaltes gibt es zwei Strategien:
Man startet mit einem leeren TLB. Und füllt in nach jeder Seitenreferenz
Man rettet den Inhalt des TLB im Prozesskontext und kann dann nach Prozesswechsel den gesicherten Inhalt zurückschreiben
Prof. Dr. Keller
3.3.2.1
SE
Seite 49 von 102
ITENERSETZUNGSSTRATEGIEN
Generelle Regeln
A)
Wird eine Seite ausgelagert, die im Speicher nicht verändert wurde ist nur die Seitentabelle zu
aktualisieren und die Kachel freizugeben.
Wird eine Seite ausgelagert, die im Speicher verändert wurde, muß diese Seite auf die Platte kopiert werden, die Seitentabelle aktualisiert und die Kachel freigegeben werden.
Damit eine Änderung einer Seite im physikalischen Speicher erkannt werden kann, muss durch
die Hardware bei einem schreibenden Speicherzugriff auf eine Seite in der Seitentabelle ein Bit
( M-Bit ) gesetzt werden.
B)
Lokale Algorithmen betrachten beim Aus-/Einlagern nur Seiten des betroffenen Prozesses
Globale Algorithmen betrachten alle eingelagerten Seiten im Speicher unabhängig von den
Prozessen
C)
Einlagerung von Seiten, nur wenn diese auch aktuell benötigt werden ( Demand Paging ).
Einlagern einer Menge von Seiten bevor ein Prozess rechnet. Während der Laufzeit dann aber
nur nach Bedarf. ( Prepaging )
D)
Paging Daemon
Ein Daemon ( Disc And Execution Monitoring ) ist ein Betriebssystemprozess, der im Hintergrund
läuft ( ins Deutsche übersetzt auch Dämon-Prozess ).
Sind viele Kacheln frei, ist ein schnelles Einlagern von Seiten möglich, da keine Seite ausgelagert
werden muss. Eine Garantie, dass viele Kacheln frei sind kann durch einen periodisch aktivierten
Hintergrundprozess realisiert werden. Dieser so genannte Paging Daemon schaut periodisch
nach, ob eine gewisse Menge von Kacheln frei ist. Sind nicht genügend Kacheln frei, werden im
Vorgriff Seiten ausgelagert.
Algorithmen
Nach einem Page Fault muss eine neue Seite in den physikalischen Speicher gelegt werden. Ist der
Speicher voll, muss das Betriebssystem Platz schaffen, indem eine eingelagerte Seite ausgelagert wird.
Welche Kachel das sein wird, wird durch einen Seitenersetzungsalgorithmus festgelegt.
DER OPTIMALE ALGORITHMUS
Jede im Speicher liegende Seite wird bei der Ausführung eines Befehls zu einer Zeit x angesprochen.
X = Anzahl der Befehl, die noch ausgeführt werden müssen, bevor ein Seitenzugriff erfolgt.
Lagere also diejenige Seite aus, deren x am größten ist.
Problem:
x ist erst dann bekannt, wenn ein Zugriff auf diese Seite erfolgt. Dies liegt jedoch in der
Zukunft. Das Betriebssystem kennt daher die Größe x nicht.
Prof. Dr. Keller
Seite 50 von 102
NOT RECENTLY USED ( NRU )
Lagere diejenige Seite aus, die im Moment am wenigsten benutzt wird
Realisierung:
Für jede Seite wird in der Seitentabelle zwei Bit gespeichert.
R-Bit:
Dieses wird bei jedem Speicherzugriff auf 1 gesetzt.
Das Betriebssystem setzt dieses Bit periodisch nach Ablauf der Zeitscheibe auf 0
zurück.
M- Bit: Dieses wird bei einem schreibenden Zugriff auf die Seite auf 1 gesetzt.
Das Betriebssystem verändert dessen Wert danach nicht mehr.
Klassifizierung der Seiten:
Klasse 0:
Klasse 1:
Klasse 2:
Klasse 3:
R=0 und M=0
R=0 und M=1
R=1 und M=0
R=1 und M=1
FIRST IN FIRST OUT ( FIFO )
Lagere diejenige Seite aus, die am längsten im Speicher liegt
SECOND CHANCE
Eine Modifikation von FIFO. Es wird der Wert des R-Bit für die älteste Seite betrachtet.
R= 0 ?
R= 1 ?
Lagere die Seite aus
Setze R-Bit auf 0 und gib dieser Seite eine neue Chance, indem Sie an den
Schluss der FIFO gehängt wird
LEAST RECENTLY USED ( LRU )
Lagere diejenige Seite aus, die am längsten nicht benutzt wurde
B
EISPIEL
:
Ein Programm erzeugt folgenden reference string:
0
1
0
2
0
le
le
le
schr le
.
0
Hier
Zeitscheibe
schr
0
4
5
1
1
3
0
le
le
schr le
le
schr le
4
schr
Es stehen 3 Kacheln zu Verfügung. Wie werden die Kacheln nacheinander belegt mit dem Verfahren
a) NRU
K1
K2
K3
0
Le
1
le
0
le
2
0
schr le
.
0
Zeit
schr
0 – 1,0
0 – 1,0
1 – 1,0
0 – 1,0
1 – 1,0
0 – 1,0
1 – 1,0
2 – 1,1
0 – 1,0
1 – 1,0
2 – 1,1
0 – 1,0
1 – 1,0
2 – 1,1
0
0
1
0
1
0
1
2
0
1
2
0
1
2
0 – 0,0
1 – 0,0
2 – 0,1
0
le
4
Le
5
1
schr le
1
le
3
0
schr le
4
schr
0 – 1,0
1 – 0,0
2 – 0,1
2 – 0,1
0 –1,0
4 – 1,0
0 – 1,0
4 – 1,0
5 – 1,1
4 – 1,0
5 – 1,1
1 – 1,0
4 – 1,0
5 – 1,1
1 – 1,0
5 – 1,1
4 – 1,0
3 – 1,1
0 – 1,0
3 – 1,1
5 – 1,1
3 – 1,1
5 – 1,1
4 – 1,1
0
1
2
0
4
2
0
4
5
1
4
5
1
4
5
3
4
5
3
0
5
3
4
5
Prof. Dr. Keller
Seite 51 von 102
b) FIFO
K1
K2
K3
0
Le
1
le
0
le
2
0
schr le
.
0
schr
0
le
4
Le
5
1
schr le
1
le
3
0
schr le
4
schr
0
0
1
0
1
0
1
2
0
1
2
0
1
2
4
1
2
4
5
2
4
5
1
4
5
1
3
5
1
3
0
4
0
1
2
3
0
1
c) Second Chance
K1
K2
K3
0
Le
1
le
0
le
2
0
schr le
.
0
Zeit
schr
0
le
4
Le
5
1
schr le
1
le
3
0
schr le
4
schr
0 – 1,0
0 – 1,0
1 – 1,0
0 – 1,0
1 – 1,0
0 – 1,0
1 – 1,0
2 – 1,1
0 – 1,0
1 – 1,0
2 – 1,1
0 – 1,0
1 – 1,0
2 – 1,1
0 – 1,0
1 – 0,0
2 – 0,1
2 – 0,1
0 –1,0
4 – 1,0
0 – 1,0
4 – 1,0
5 – 1,1
4 – 0,0
5 – 0,1
1 – 1,0
4 – 0,0
5 – 0,1
1 – 1,0
5 – 0,1
1 – 1,0
3 – 1,1
1 – 1,0
3 – 1,1
0 – 1,0
3 – 0,1
0 – 0,0
4 – 1,1
0
0
1
0
1
0
1
2
0
1
2
0
1
2
0
1
2
0
4
2
0
4
5
1
4
5
1
4
5
1
3
5
1
3
0
4
3
0
0
le
4
Le
5
1
schr le
1
le
3
0
schr le
0 – 0,0
1 – 0,0
2 – 0,1
d) LRU
K1
K2
K3
0
Le
1
le
0
le
2
0
schr le
.
0
Zeit
schr
0
0
1
0
1
0
1
2
0
1
2
0
1
2
4
schr
Prof. Dr. Keller
3.4
Seite 52 von 102
Speicherverwaltung in UNIX
FREISPEICHERVERWALTUNG
über verkettete Liste.
Verfahren First Fit.
SEGMENTIERUNG, SWAPPING UND PAGING KOMBINIERT.
Speicherverwaltung in UNIX
Segmentierung
Swapping
•Der virtuelle Adreßraum wird in 4 Segmente eingeteilt:
-Text-Segment ( read-only, shared )
-Statische Daten ( initialisiert, nicht initialisiert (BSS ))
-Dynamische Daten ( Stack von unten nach oben, heap
von oben nach unten )
•Hintergrundprozeß mit PID=0.
Wird aktiviert zum Auslagern von Prozessen, wenn die
Page Fault Rate zu hoch ist, oder kein Speicherplatz mehr
vorhanden ist.
Wird Periodisch aktiviert um nachzusehen, ob Prozesse
wieder eingelagert werden können
•Demand Paging mit globalem modifízierten FIFO Algorithmus
Paging
•Paging Dämon
Hintergrundprozeß mit PID=2 . Dieser wird periodisch alle
250 msec aktiviert. Falls weniger als 1/4 des Speichers frei
ist, werden im Vorgriff Seiten ausgelagert
Prof. Dr. Keller
3.5
Seite 53 von 102
Speicherverwaltung in Windows NT
Windows NT ermöglicht die virtuelle Adressierung eines linearen Adressraumes von 4 Gigabyte ( = 2
32
Byte ).
Jeder Prozess hat einen eigenen, gegenüber anderen geschützten virtuellen Adressraum, von insgesamt
4 Gigabyte, davon 2 Gigabyte Systembereich und 2 Gigabyte User-Bereich.
Virteller Adreßraum eines NT Prozesses
0
User Bereich
2 Gigabyte
non paged system area
System Bereich
32
2 -1
2 Gigabyte
non paged area
Die Speicherverwaltung ( Virtual Memory Manager VM ) realisiert Paging.
Die Seitengröße beträgt 4 KByte, d.h. jeder Prozess kann insgesamt 220 Seiten adressieren. NT benutzt
eine 2-stufige Seitentabelle.
Die erste Stufe bildet mit 210 Einträgen das Page Directory ( PD ). In der 2. Stufe existiert eine Seitentabelle ( PT ) mit ebenfalls 210 Einträgen. Der Offset innerhalb einer Seite beträgt 12 Bit (Seitengröße von
4K Byte).
Jeder Prozess besitzt seine eigene Page Directory und damit auch seine eigene Seitentabelle. Page
Directory und Seitentabelle können selbst ausgelagert werden unterliegen daher dem Paging.
Prof. Dr. Keller
Seite 54 von 102
Paging in Windows NT
31
PDE
PD Eintrag
21
11
PTE
Offset
0
PT Eintrag
Page Directory
Adresse
Kachelnr.
Page Directory
Page Table
Arbsp. Kacheln
Ein-/Auslagerungs-Strategie:
Demand Paging mit „Clustering“, d.h. eine Seite wird nach Bedarf eingelagert zusammen mit einer kleinen Zahl von zusätzlichen Seiten in der Umgebung der benötigten Seite.
Lokale, d.h. auf einen Prozess bezogene, FIFO Strategie.
Shared Memory
Windows NT ermöglicht das Anlegen von Shared Pages. Dazu wird bei der Adressumrechnung von virtuellen Seiten in physikalische Kacheln eine zusätzliche Stufe eingeschoben, die Prototype Page Table (
PPT ), eine vom Betriebsystem dynamisch angelegte Seitentabelle, in der für alle shared pages die physikalische Adresse der Kachel eingetragen wird. Im entsprechenden Page Table Eintrag der Prozesse
steht nicht die Kacheladresse sondern die Adresse des Eintrages in der Prototype Page Table. Beim Ein/Auslagern einer Shared Page muss damit nicht die Seitentabelle aller beteiligten Prozesse geändert
werden, sondern nur der Eintrag in der PPT.
3.6
3.6.1
Übungsaufgaben
Aufgabe 8
Ein Rechner mit 32-Bit virtueller Adressierung benutzt eine 2-stufige Seitentabelle. Eine virtuelle Adresse
setzt sich zusammen aus 9 Bit Seitenindex 1. Stufe, 11 Bit Seitenindex 2. Stufe und Offset. Wie groß ist
eine Seite ? Wie viele Seiten hat der virtuelle Adressraum ?
3.6.2
Aufgabe 9
In einem Multitasking Betriebssystem muss der Arbeitsspeicher auf mehrere gleichzeitig ablaufende Prozesse aufgeteilt werden. Sie haben in der Vorlesung zwei unterschiedliche Techniken kennengelernt, wie
trotz geringem Arbeitsspeicher alle Prozesse bearbeitet werden können, das Swapping und Paging.
Prof. Dr. Keller
Seite 55 von 102
a)
Erklären Sie den Unterschied dieser beiden Techniken. Ist eine Realisierung dieser beiden Techniken ohne zusätzliche Hardwarevorkehrungen möglich oder nicht ?
b)
Beim Paging tritt unter bestimmten Umständen ein sogenanntes Seitenflattern ( thrashing ) auf.
Nennen Sie den/die Grund/Gründe für das Auftreten dieses Effektes.
3.6.3
Aufgabe 10
In einem Paging-System stehen 3 Kacheln (physikalische Seiten) Arbeitsspeicher zur Verfügung. Es soll
ein Prozeß abgewickelt werden, der aus 5 virtuellen Seiten ( 0..4 )besteht. Dabei sei ausnahmsweise die
Reihenfolge der Seitenzugriffe bekannt. Die Seiten werden in der Reihenfolge: 0,1,2,3,0,1,4,0,1,2,3,4
benötigt. Das Paging System arbeitet nach dem FIFO Verfahren und hat zum Startzeitpunkt drei "gereinigte" Kacheln zu Verfügung.
Tragen sie in die nachfolgende Tabelle 1 die Belegungen der Kacheln mit Seiten ein und kennzeichnen
Sie im Page Fault-Feld die auftretenden Seitenfehler
Tragen Sie in die Tabelle 2 bei gleicher Reihenfolge für den gleichen Prozeß die Belegung und die Seitenfehler ein, wenn Sie vier Kacheln zur Verfügung haben
Bei welcher Lösung ergeben sich mehr Seitenfehler?
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
3.6.4
Aufgabe 11
Ein Multitasking-Betriebssystem verwaltet den Arbeitsspeicher nach dem Pagingverfahren. Die Seitengröße beträgt 1K. Jeder Prozess adressiert 8 virtuelle Seiten d.h. der virtuelle Adressraum eines Prozesses beträgt 8K. Dem Betriebssystem stehen 4 Kacheln zu Verfügung. In der Kachel 0 liegt das Betriebssystem permanent eingelagert. Die Seitentabelle eines Prozesses wird direkt in der MMU gespeichert.
Bei der Abarbeitung eines Prozesses entsteht die folgende Sequenz von Seitenreferenzen ( Referenzstring ):
Referenzstring :
1 2 3 2 4 2 3 5 2 1 2 4 5
Das Betriebssystem muss diese virtuellen Seiten auf 3 Kacheln im Arbeitsspeicher abbilden.
Wie sieht die Zuordnung der virtuellen Seiten auf die Kacheln aus wenn das Least Recently Used (LRU)
Verfahren angewendet wird. Bei dieser Strategie wird diejenige Seite verdrängt, die in einem zurückliegenden Zeitintervall die längste Zeit unbenutzt war.
Tragen Sie in die vorgegebene Tabelle die Belegung der Kacheln mit virtuellen Seiten ein. Kennzeichnen
Sie die Situationen "Auftreten eines Page Fault" durch einen Pfeil, der auf die Spalte zeigt, in der ein Page Fault auftritt.
Referenzstring 1
Kachel 1
Kachel 2
Kachel 3
2
3
2
4
2
3
5
2
1
2
4
5
Prof. Dr. Keller
3.6.5
Seite 56 von 102
Aufgabe 12
Ihr Betriebssystem realisiert virtuellen Speicher in Form von Paging. Die Seitengröße ist 1 KByte. Als
Seitenersetzungsstrategie wird NRU (Not Recently Used ) benutzt. Der Adressraum eines Prozesses
umfasst 8 virtuelle Seiten. Physikalisch sind 8 Kacheln vorhanden. Das Betriebssystem belegt permanent
die Kachel 0 und 1, d.h. diese beiden Kacheln werden nicht ausgelagert.
Zum Zeitpunkt x rechnet ein Prozess A. Die Seitentabelle des Prozesses hat zu diesem Zeitpunkt folgendes Aussehen:
0:
1:
2:
3:
4:
5:
6:
7:
a)
Kacheln P
R
M
2
1
0
0
7
1
1
0
0
0
0
0
0
0
0
0
4
1
1
1
0
0
0
0
5
1
0
1
0
0
0
0
P: Seite präsent
M: Seite wurde modifiziert
R: Seite wurde in der aktuellen Zeitscheibe benutzt
Bei der Abwicklung des Prozesses A treten innerhalb der aktuellen Zeitscheibe folgende Seitenreferenzen auf:
1 (l), 5 (sch), 2 (sch), 1 (l), 7 (sch), 3 (sch), 1 (l),6 (l)
sch: schreibend, l: lesend
Tragen sie in die folgende Tabelle die Kachelbelegungen für die oben gegebene Seitenreferenzen
ein. Die aktuelle Belegung zum Zeitpunkt x ist in der Spalte x vorgegeben, d.h. Kachelnummer 3
und 6 sind unbelegt.
Kachelnr.
2
3
4
5
6
7
b)
x
0
4
6
1
1
5
2
1
7
3
1
Wie sieht die Seitentabelle des Prozesses nach der letzten Seitenreferenz aus ?
Kachelnr.
P
R
M
0:
1:
2:
3:
4:
5:
6:
7:
c)
6
Wie oft und in welchen Situationen wird ein "Page Fault" ausgelöst ?
3.6.6
Aufgabe 13
Paging – Vergleich FIFO, Second Chance ( im Skript )
Prof. Dr. Keller
Seite 57 von 102
4. Interprozesskommunikation
4.1
4.1.1
Modelle zur Beschreibung eines nebenläufigen Systems
Beschreibung der Aufbaustruktur durch Instanzennetze
Mit Instanzennetzen kann man die Aktionsträger (Prozesse) und die Datenflüsse eines Softwaresystems
modellieren.
Ein Instanzennetz ist ein gerichteter bipartiter Graf.
Ein bipartiter Graf besteht aus 2 Knotentypen. Kanten dürfen nur Knoten unterschiedlichen Typs verbinden.
Knotensymbole:
Instanzen
Aktionsträger
"Prozesse"
Datenräume
Speicher für Datenwerte
passive Elemente
Beispiel: Erzeuger/Verbraucher-Problem
Warenlager
Produzent
4.1.2
Konsument
Beschreibung der Ablaufstruktur durch Petrinetze
Mit Petrinetze kann man die zeitliche Abfolge von Ereignissen/Aktionen eines Softwaresystems modellieren.
Ein Petrinetz ist ein gerichteter bipartiter Graf mit zusätzlichen Eigenschaften.
Knotensymbole:
Transitionen
kennzeichnen Ereignisse / Aktionen
Stellen
kennzeichnen Systemzustände
Prof. Dr. Keller
4.2
Seite 58 von 102
Kooperation über gemeinsame Daten
( shared memory )
Beispiel
Prozeß
#1
Prozeß
#2
DruckSpooler
FIFO
Druckaufträge
Problem
Zeitlicher Wettlauf
zwischen Prozeß 1
und Prozeß 2
Ursache
Prozeßwechsel
innerhalb kritischem
Bereich.
Kritischer
Bereich
Teil des Prozsesses, in dem ein
Zugriff auf gemeinsame
Datenbereiche erfolgt
Aktionen P1
Aktionen P2
Zugriff auf
gemeinsame
Daten
kritischer
Bereich
kritischer
Bereich
Lösung
Realisierung
Wechselseitiger Ausschluß
( mutual exclusion )
Binäre Semaphore
Aktionen P1
kritischer
Bereich
Semaphor
MUTEX
Aktionen P2
kritischer
Bereich
Prof. Dr. Keller
4.3
Seite 59 von 102
Synchronisation
4.3.1
Signale, Flags
4.3.2
Stop/Unstop-Mechanismus
Synchronisation durch passives Warten
Beispiel: Produzent/Verbraucher-Problem
Prüfe Pufferstatus
Prüfe Pufferstatus
Betriebssystem
Stop
Stop
Puffer voll
sonst
Puffer leer
sonst
Lege Ware ins Lager
Hole Ware aus Lager
Erhöhe Pufferstaus um 1
Erniedrige Pufferstaus um 1
UNSTOP Konsument
UNSTOP Produzent
PRODUZENT
4.3.3
BI
ZÄ
NÄRE
VERBRAUCHER
Semaphore
SE
HLENDE
MAPHORE
SE
MAPHORE
BEISPIEL: PRODUZENT-VERBRAUCHER
In
1
Kapazität=N
Konsumie-
Produziere
MUTEX
krit.
Bereich
Lege Ware
ins Lager
1
Kap.=N
Out
Hole Ware aus
dem Lager
1
Synchron. Starten
Prof. Dr. Keller
Art
Binärer Semaphor
Seite 60 von 102
Datenstruktur im BS
Boolsche Variable S
FIFO zu S mit Eintag
PID
unsigned int S
FIFO zu S mit Eintrag
PID
Funktionen im BS
P(S)
V(S)
Allgemeiner Semaphor
mit Flusszahl > 1
unsigned int S
FIFO zu S
Eintrag: PID, Flußzahl
P(k*S)
V(k*S)
Mengen (bzw.Vektor)
Semphore
unsigned int S1,S2
FIFO für alle Semaphore
Eintrag:
PID, Liste:
Sempahor,Flußzahl
P(n*S1,m*S"2)
V(k*S1,l*S2)
Allgemeiner Semaphor
Petrinetz-Modell
P(S)
V(S)
Prof. Dr. Keller
4.3.4
Monitore
Monitore
• Synchronisationsmethode nach Hoare(1974) und
Hansen ( 1975 )
– Ein Monitor besteht aus
• einer Menge von Prozeduren, Variablen und Datenstrukturen,
• die in einem Modul bzw. Objekt-Klasse zusammengefasst sind
– Ein Programm kann nur über die Monitorprozeduren auf die
Daten im Monitor zugreifen
– Nur genau ein Prozess kann einen Monitor betreten
• realisiert mutual Exclusion.
Monitore
• Monitore sind Konstrukte einer Programmiersprache.
– Der Compiler realisiert die Monitore in folgender weise:
• Ruft ein Prozeß P2 eine Monitorprozedur auf, während gerade
ein anderer Prozess P1 den Monitor benutzt, so wird P2
blockiert, bis der Prozess P1 den Monitor wieder verlässt.
• Ist kein anderer Prozess im Monitor aktiv, so erhält P2 das
Recht die Monitorprozedur zu benutzen und sprerrt damit für
andere Prozesse den Zugriff auf die Monitordaten.
– Der Compiler muss für einen Monitor den wechselseitigen
Ausschluss umsetzen.
– Falls vorhanden verwendet der Compiler dazu binäre
Semaphore
Seite 61 von 102
Prof. Dr. Keller
Monitore
Daten im
kritischen Bereich
Prozedur 1
Prozedur 2
Monitor
Prozeß 1
(aktiv
in Monitor)
Prozeß 2
( blockiert)
Monitore
Konstrukte einer Programmiersprache
• Vorteil:
• Der Programmierer muss sich um mutual exclusion nicht selbst
kümmern.
• Dies regelt der Compiler. Daher können auch keine Fehler
durch zeitliche Wettläufe erfolgen. Der Programmierer muss
nur alle kritischen Bereiche in Monitore legen.
• Nachteil:
– Monitore sind Elemente einer Programmiersprache.
• C und C++ ermöglichen keine Monitore.
• JAVA unterstützt das Monitorkonzept
Seite 62 von 102
Prof. Dr. Keller
Monitore - Synchronisation
•
In den meisten Fällen muss neben mutual exclusion zusätzlich
ein Synchronisationsprotokoll zwischen den Prozessen
implementiert werden, das einen Prozess blockiert wenn die
globale Variable bestimmte Bedingungen nicht erfüllt, und den
Prozess wieder deblockiert wenn die Bedingungen wieder
hergestellt sind.
•
Beispiel Druckspooler:
– Der Zugriff auf die Druckwarteschlange ( Einschreiben von
Druckaufträgen, herausnehmen von Druckaufträgen ) muss mittels
mutual exclusion sicher implementiert werden.
– Ist kein Auftrag in der Schlange muss der Druckspooler blockieren.
– Ist die Druckerwarteschlange voll muss der druckende Prozess
blockiert werden.
Lösung
•
Die Bedingung zum Blockieren und Deblockieren
kann nur in den Prozeduren des Monitors erkannt
werden.
•
Blockieren und Deblockieren von Prozessen kann
daher nur innerhalb des Monitors durch
– warten auf Bedingungsvariablen / Ereignisse und
– setzen von Bedingungsvariablen / Ereignisse
realisiert werden
Seite 63 von 102
Prof. Dr. Keller
Seite 64 von 102
•
Wird in einer Monitorprozedur erkannt das eine Weiterverarbeitung
nicht möglich ist, wird auf das Eintreten einer Bedingung gewartet (
wait(event)
–
Realisierung
–
•
Dies bewirkt dass der Prozess, der sich in der Monitorprozedur befindet
blockiert wird.
Darauf wird er Monitor für einen auf Zutritt in den Monitor wartenden
Prozess freigegeben, der dann eine Monitorprozedur ausführen kann, die
die Bedingung für die Weiterverarbeitung eines blockierten Prozesses
herstellen kann ( signal(event) ).
Damit nicht zwei Prozesse gleichzeitig den Monitor benutzen,
–
–
darf der jetzt deblockierte Prozess erst dann den Monitor betreten, wenn
der die Deblockierung auslösende Prozess den Monitor wieder verlassen
hat.
Das Deblockieren eines Prozesses sollte daher die letzte Anweisung in
einer Monitorprozedur sein.
Monitore - JAVA-Beispiel
Produzent
Lager
Verbraucher
4/4
4
Produziere
Hole aus Lager
1
4
Lege ins Lager
4/0
1
Verbrauche
Prof. Dr. Keller
Seite 65 von 102
Monitore - JAVA-Beispiel
JAVA-Klasse
AnwendungsKlasse
Thread
Monitor
Lager
erzeugt
Zugriff auf
erzeugt
Klasse
Produzent
erzeugt
Klasse
Konsument
Ist ein
JAVA
Programmbeispiel
// Anwendungsklasse - IPCTest erzeugt einen Monitor und zwei Threads ( Produzent, Verbraucher )
import java.lang.*;
public class IPCTest
{
monitor lager;
producer produzent;
consumer verbraucher;
// ------------Methoden ---------------------public IPCTest ()
{
lager=new monitor();
// Monitor erzeugen
System.out.println("Monitor erzeugt");
produzent=new producer(lager);
// Thread Produzent erzeugen
System.out.println("Produzent erzeugt ");
verbraucher=new consumer(lager);
// Thread Verbraucher erzeugen
System.out.println("Verbraucher erzeugt ");
produzent.start();
verbraucher.start();
// Produzent starten
// Verbraucher starten
}
public static void main(java.lang.String[] args)
{
IPCTest anwendung=new IPCTest();
}
}
Prof. Dr. Keller
Seite 66 von 102
// Klasse realisiert einen Monitor für das Schraubenlager zwischen den beiden Threads Produzent,
Verbraucher
import java.lang.*;
public class monitor
{ int lager=0;
final int MAX = 4;
// ---------------Methoden ------------------public synchronized void aus_lager(int zahl)
{ while ( (lager-zahl)<0 )
{ System.out.println("Lager hat nicht genug Schrauben - ich warte");
try { wait(); }
catch ( InterruptedException e ) { System.out.println("Exception in Monitor.Methode:
aus_lager"); }
}
lager=lager-zahl;
// Schauben aus Lager entfernen
System.out.println(" "+zahl+" Schrauben aus Lager genommen");
notify();
// wartende Threads informieren
}
public synchronized void in_lager(int zahl)
{
while ( (lager+zahl) > MAX)
{ System.out.println("Lager hat nicht genug Platz für "+zahl+" Schrauben - ich warte");
try { wait(); }
catch (InterruptedException e) {System.out.println(" Exception in Monitor.Methode:
in_lager");}
}
lager=lager+zahl;
// Schrauben in Lager legen
System.out.println(" "+zahl+" Schrauben in Lager gelegt");
notify();
// wartende Threads informieren
}}
// Klasse realisiert den Thread Schrauben-Produzent
public class producer extends Thread
{
private monitor lager;
// Referenz auf globale Variable Lager
public producer(monitor data)
{
super();
lager=data;
}
public void run()
// Thread-Anweisungen
{ int i,status;
for ( i=1; i<=12; i++)
{
System.out.println("Produziere 1 Schraube");
lager.in_lager(1);
}
}}
// Klasse realisiert den Thread Schrauben-Verbraucher
import java.lang.*;
public class consumer extends Thread
{
private monitor lager;
// Referenz auf globale Variable lager
public consumer(monitor data)
{
super();
lager=data;
}
public void run()
// Thread-Anweisungen
{ int i,status;
for(i=1; i<=3;i++)
{
lager.aus_lager(4);
System.out.println("Verbrauche 4 Schrauben");
}
}
}
Prof. Dr. Keller
4.3.5
Seite 67 von 102
Verklemmungen
Verklemmungen
•
Entdecken und Beheben
– Protokollieren von Betriebsmittelanforderungen und
Betriebsmittelbenutzung durch Aktualisieren des Betriebsmittelgraphen.
– Prüfen des Graphen auf Zyklen und entfernen eines Prozesses aus dem
Zyklus, so daß Zyklus aufgelöst wird.
•
Was ist ein Betriebsmittelgraph ?
Symbol für ein Betriebsmittel
Symbol für ein Prozeß
BM
P
Prozeß P benutztt Betriebsmittel BM
BM
P
Prozeß P ist blockiert und
wartet auf Betriebsmittel BM
Beipiel
BM1
P2 benutzt BM1
P1 wartet auf BM1
P1 benutzt BM2
P2 wartet auf BM2
P1
P2
Zyklus
Verklemmung
BM2
Verklemmungen
• Vermeidung
– Vorbeisteuern an Verklemmungen dadurch, daß man
Anforderungsketten von vorneherein vermeidet
– Banker Algorithmus ( Dijkstra, 1965 )
( Quelle: Tanenbaum, Modern Operating Systems )
• Algorithmus geht davon aus, daß jeder Prozeß zu Beginn
angibt wie viele Betriebsmittel er zur Laufzeit benötigt
• reine Theorie, in der Praxis nicht anwendbar
Prof. Dr. Keller
4.4
4.4.1
4.5
4.5.1
Kommunikation
Nachrichten
Interprozesskommunikation unter UNIX
Signale und PIPES
Interprozesskommunikation unter UNIX
•
Signale
– UNIX kennt 32 verschiedene Signale. Signal sind asynchron.
– Der Benutzer kann sich seine eigene Signalhandler schreiben.
– Funktionen:
kill(Signal,PiD): sende Signal an Prozess
pause( ): warte auf nächstes Signal
sigaction(Signal, Zeiger auf Funktion): Definition eines
eigenen Signalhandlers
•
Pipes
– Eine pipe ist eine Byte-FIFO. Zugriffe auf die pipe sind vergleichbar mit
Dateibearbeitung. Eine pipe kann maximal 4096 Byte speichern und bildet
einen unidirektionalen Kanal zwischen zwei Prozessen. Ist die pipe voll wird
der einschreibenede Prozess blockiert ist die pipe leer wird der lesende
Prozess blockiert
write()
read()
Prozess 1
Prozess 2
schreibt
in die pipe
pipe
liest
aus der pipe
Seite 68 von 102
Prof. Dr. Keller
4.5.2
Seite 69 von 102
Semaphore, Shared Memory, Nachrichten
Interprozesskommunikation unter UNIX System V
•
Gemeinsame Daten ( shared memory )
– gemeinsame Nutzung von Segmenten im virtuellen Adreßraum.
Das Segment wird systemglobal erzeugt und mittels einer
Kennung kann auf den Datenbereich zugegriffen werden. UNIX
stellt 3 Funktionen zu Verfügung
• kreieren eines gemeinsamen Datenbereichs
• benutzen eines erzeugten Datenbereiches
• Segment wieder freigeben
•
Semaphore
– Es können allgemeine Semaphore und Semaphormengen benutzt
werden. Die Semaphore werden systemglobal angelegt
– Binäre Semaphore gibt es nicht
•
Nachrichten ( messages )
– Es wird eine systemglobale Nachrichten-FIFO erzeugt. Mit zwei
Funktionen send und receive können Nachrichten ausgetauscht
werden.
4.6
Interprozesskommunikation in Windows NT
4.6.1
Gemeinsame Daten
Die Einrichtung eines Shared Memory wird nur zwischen Prozessen benötigt. Nebenläufige Threads eines Prozesses laufen im gleichen Adressraum ab und können damit auf globale Programmvariablen
zugreifen.
Shared Memory basiert in NT auf der Technik File Mapping. Beim File Mapping wird eine Datei in den
virtuellen Adressraum eines Prozesses eingelagert. Nach dem Einlagern erfolgen die Dateizugriffe nicht
auf die Festplatte sondern über Zeiger direkt im Arbeitsspeicher. Beim Einlagern kann man als Zugriffsmodus readonly oder read/write vereinbaren. Um auf eine shared memory zuzugreifen benutzen unterschiedliche Prozesse das gleiche mapped file. Mapped Files können in NT auch im paging-File liegen.
Die Technik ist nicht netzwerkfähig.
4.6.2
STOP/U
Synchronisation
NSTOP
-ME
CHANISMUS
Zu jedem Thread wird ein Zähler angelegt, der die Stop- und Unstop-Anweisungen zu einem Thread
speichert.
Jeder stop-Aufruf erhöht den Zähler. Jeder unstop deblockiert den Thread, wenn der Zähler auf 0 gesetzt
wird. Ist der Zähler größer 0 wird nur der Zähler erniedrigt, der Thread aber nicht blockiert.
Funktionen:
suspendThread(Thread)
resumeThread(Thread)
entspricht stop
entpricht unstop
Prof. Dr. Keller
KRITISC
BERE
HE
Seite 70 von 102
ICHE
Kritische Bereiche können nur von nebenläufigen Threads innerhalb eines Prozesses bei Zugriff auf globale Variablen benutzt werden. Ein kritischer Bereich wird als globale Variable vom Typ CRITICAL_SECTION im Prozess erzeugt. Es kann immer nur ein Thread in den kritischen Bereich eintreten,
d.h. die Variable benutzen.
Funktionen:
InitializeCriticalSection(kritischer Bereich)
EnterCriticalSection(kritischer Bereich)
LeaveCriticalSection(kritischerBereich)
DeleteCriticalSection(kritischer Bereich)
initialisiert die Variable.
betreten des den kritischen Bereichs
durch ein Thread. Der kritische Bereich
ist damit für andere Threads gesperrt.
der kritische Bereich wird wieder freigegeben.
löscht die Variable
Mutex-Objekte
Unter NT entspricht ein Mutex-Objekt einem binären Semaphor. Mutex-Objekte werden zum Schutz von
shared memory genutzt auf den verschiedene Prozesse zugreifen.
Funktionen:
CreateMutex()
OpenMutex(Mutexobjekt)
waitforSingleObject(MutexObjekt)
ReleaseMutex(Mutexobjekt)
Ein Mutex-Objekt wird erzeugt
Benutzt ein vorhandenes Mutex-Objekt
Wird benutzt um sich den Mutex zu holen. Ist da
Mutexobjekt schon von einem anderen Prozeß
benutzt wird der aktuelle Prozeß blockiert, bis der
Mutex wieder freigeben ist.
gibt den Mutex wieder frei
Signale
Signale unter NT sind Events. Signale sind synchron.
Funktionen:
CreateEvent(Initialwert)
DeleteEvent(event)
ResetEvent(event)
PulsEvent(event)
Signal erzeugen und initialisieren.
Signal auf 1 setzen. Alle wartenden Threads
werden deblockiert.
Signal wird gelöscht.
Signal auf 1 setzen. Wenn alle wartenden
Threads deblockiert sind, dann wird das Signal
wieder auf 0 gesetzt.
Um auf ein Signal zu warten wird die Funktion waitforSingleObject(Objekt) verwendet. Als Objekte
können hier nicht nur Signale sondern auch Prozesse, Mutex-Objekte, Semaphore u.a. angeben werden.
Windows NT stellt auch eine Funktion waitforMultipleObejcts(Objektliste) zu Verfügung. Mit dieser
Funktion kann auf das Eintreten mehrerer Signale reagiert werden. Über ein Flag können die angegebenen Objekte entweder UND- oder ODER-verknüpft werden.
Semaphore
NT stellt allgemeine Semaphore zu Verfügung.
Beim Erzeugen eines Sempahors kann ein Maximalwert für den Sempahor vereinbart werden. Setzt man
diesen Maximalwert auf 1 erhält man einen binären Semaphor. Eine P-Operation blockiert ein Thread,
falls der Semaphorwert 0 ist, sonst wird der Semaphor um 1 erniedrigt. Bei der V-Operation kann der
Sempahorwert um einen Betrag größer 1 erhöht werden ( Flusszahl > 1 ).
Prof. Dr. Keller
Funktionen:
CreateSemaphor( Initialwert, Maximalwert,)
ReleaseSempahor(Semaphorobjekt, Flußzahl )
WaitForSingleObject(Semaphorobjekt)
Seite 71 von 102
Erzeugt und initialisiert ein
Semaphor-Objekt.
Entspricht der V-Operation
Entspricht der P-Operation
Mit der Funktion WaitForMultipleObjects(Sempahor1, ...,Sempahor-n, Flag=UND) kann ein Mengensemaphor realisiert werden.
4.6.3
Kommunikation über Nachrichten
Pipes
Anonyme Pipe:
vergleichbar mit Unix.
Die Pipe ist ein unidirektionaler Nachrichtenkanal zwischen zwei Prozessen. Die Pipe ist nicht netzwerkfähig.
Named Pipe:
Eine Pipe mit einem frei vergebbaren Namen. Die Verbindung kann sowohl uni- als auch bidirektional aufgebaut werden. Es ist sowohl ein
byteweiser Zugriff wie bei einer Unix-Pipe, als auch Nachrichten(Paket-)
orientierter Zugriff möglich.
Netzwerkfähig.
Mail Slots
Netzwerkfähig.
Ein Mailslot ist eine Nachrichten-FIFO ( mailslot-Server), die auf einem lokalen Rechner in einem
Netzwerk erzeugt wird. Nur der Prozess, der den Mailslot erzeugt, kann als Empfänger einer
Nachricht die Nachrichten aus der FIFO lesen. Es können jedoch beliebige Prozesse auf unterschiedlichen Rechnern im Netzwerk Nachrichten in die mailslot schreiben.
Bei Mailslots kann ein Sender seine Nachrichten an einen oder mehrere Empfänger senden (
Broadcasting ). Dies wird dadurch realisiert, dass auf verschiedenen Rechnern im Netzwerk
mailslots mit gleichen Namen angelegt werden. Eine Nachricht an einen mailslot mit Namen xxx
wird dann an alle Rechner im Netzwerk gesendet, auf denen ein mailslot-server mit Namen xxx
installiert ist.
Funktionen:
CreateMailslot (Name, Maximale Größe einer Nachricht)
Lesen mit readFile(), Schreiben mit writeFile()
Prof. Dr. Keller
4.7
4.7.1
Seite 72 von 102
Problem des schlafenden Friseurs (Sleeping Barber)
Problembeschreibung
Das Beispiel des schlafenden Friseurs zeigt anschaulich, was passieren kann, wenn es keinen gegenseitigen Ausschluss durch Semaphoren für die Synchronisation von Prozessen oder Threads gibt.
Auf den Abbildungen ist die Türglocke der Zähler, jedes Mal wenn die Tür aufgeht, klingelt die Türglocke
und der Friseur zählt seinen Kundenzähler um eins hoch. Wenn der Friseur mit einem Haarschnitt bei
einem Kunden fertig ist, zählt er seinen Zähler um eins herunter. Beim Hinausgehen klingelt die Glocke
nicht.
Die Fehlerquelle liegt bei der Türglocke, da gleichzeitig mehrere Kunden hereinkommen können, während die Türglocke nur einmal bimmelt. Um den Fehler zu verhindern, müsste gewährleistet werden,
dass immer nur ein Kunde durch die Tür kann. In der Interprozesskommunikation wäre diese Schutzmöglichkeit ein Semaphor. Der Kundenzähler wird also auf 3 inkrementiert, obwohl sich 4 Kunden im Raum
befinden.
Prof. Dr. Keller
Seite 73 von 102
Die Folge des Fehlers ist, dass der Kundenzähler beim Hinausgehen des vorletzten Kunden bereits auf 0
dekrementiert wird, obwohl sich noch ein Kunde im Raum befindet.
Der Friseur legt sich wieder schlafen, da er davon ausgeht, dass keine Kunde mehr im Raum ist.
In der Praxis könnte man das Friseurproblem anhand eines Druckerspoolers demonstrieren. Jeder Prozess, der eine Datei ausdrucken möchte, muss den Namen der Datei in ein spezielles SpoolerVerzeichnis schreiben. Der Drucker-Dämon überprüft periodisch, ob dort auszudruckende Dateien eingetragen worden sind, druckt sie gegebenenfalls aus und löscht die Namen aus dem Verzeichnis.
Es gibt zwei Variablen, die eine verweist auf den nächsten freien Platz, die andere auf die nächste zu
druckende Datei. Diese beiden Variablen stehen in einer Datei auf die alle Prozesse zugreifen können.
Nun kann es vorkommen, dass zwei Prozesse mehr oder weniger gleichzeitig eine Datei ausdrucken
möchten. Der Prozess A, der gerade ausgeführt wird, liest die Variable mit dem nächsten freien Platz und
merkt sie sich. Der Prozess A wird unterbrochen, da seine Prozessorzeit um ist. Das Betriebssystem
veranlasst einen Prozesswechsel zum Prozess B, der auch drucken möchte. Dieser liest ebenfalls die
Variable mit den freien Platz im Verzeichnis, merkt sie sich, schreibt den Dateinamen an die freie Stelle
und erhöht den Wert um 1 (auf den nächsten freien Platz). Seine restliche Prozessorzeit verwendet er für
andere Dinge. Irgendwann wird der Prozess A, der zuerst drucken wollte, an der Stelle weiter ausgeführt
an der er unterbrochen wurde. Er hat sich die freie Stelle gemerkt und schreibt nun seinen Dateinamen
an diese Stelle, dabei überschreibt er den anderen Dateinamen.
Die Datei vom zweiten Prozess B wird also nie gedruckt.
Prof. Dr. Keller
Seite 74 von 102
Dieses Problem kann durch gegenseitigen Ausschluss (Mutual Exclusion) der Prozesse beim Zugriff auf
das Spooler-Verzeichnis umgangen werden.
4.7.2
Petrinetz
Startet
Customer
0
Schlafe
Prüfe Waiting
0
Melde Dich an
Mutex
Waiting --
0
0
0
Warte
0
Melde Dich bereit
Barber
0
Haarschnitt
0
Schneide
0
Gehe
0
Terminiert
Frisör
Kunde
Gehe
Prof. Dr. Keller
4.7.3
Seite 75 von 102
Pseudocode
Algorithmus für den Friseur:
Wenn kein Kunde (Kundenzähler = 0) da ist, schlafe. Wenn Türglocke bimmelt, wache auf und zähle den
Kundenzähler um eins hoch und schneide Haare. Wenn fertig mit Haare schneiden, zähle Kundenzähler
um eins herunter. Solange Kundenzähler nicht Null ist, schneide Haare.
Algorithmus für Kunden:
Wenn Friseur schläft, wecke ihn. Wenn Friseur beschäftigt, warte auf Wartestuhl. Wenn schon fünf Kunden warten, gehe wieder und komm später wieder.
Eine geeignete Lösung für dieses Problem, ohne dass es unter den einzelnen Kunden (Threads) zu
Wettkampfbedingungen kommt, wäre folgender Pseudocode:
Binary semaphore mutex = 1;
Binary semaphore barber = 0;
Counting semaphore customers = 0;
int waiting = 0;
void Barber(void)
{
while(true)
{
P(customers); // wait for or get next customer
P(mutex);
Waiting--;
V(barber);
V(mutex);
Cut_Hair();
}
}
void Customer(void)
{
while(true)
{
P(mutex); //check waiting room
if(waiting < numChairs)
{
waiting++;
V(customers);
V(mutex);
P(barber); //wait for barber
get_hair_cut();
}
else
V(mutex);
}
}
4.7.4
Sourcecode
Barber
// Erzeugung der Ressourcen durch den Barber
TSharedMemory *Msg;// = new TSharedMemory;
// zählende Semaphore für die Kunden
hCustomer = CreateSemaphore(NULL, 0, 5, "SemCustomer");
// binäre Semaphore für sich selbst
hBarber
= CreateSemaphore(NULL, 0, 1, "SemBarber");
Prof. Dr. Keller
// binäre
hMutex
// Shared
hWaiting
Seite 76 von 102
Semapohre als Mutex
= CreateMutex(NULL, TRUE, "Mutex");
Memory
= ::CreateFileMapping((HANDLE)0xFFFFFFFF, NULL,PAGE_READWRITE,
0, sizeof(TSharedMemory), "MemWait");
// Barber öffnet und initialisiert das Shared Memory
Msg
=
(TSharedMemory*)::MapViewOfFile(hWaiting,
FILE_MAP_WRITE,
0, sizeof(TSharedMemory));
Msg->Zaehler = 0;
0,
// Shared Memory schliessen
::UnmapViewOfFile(Msg);
// Mutex freigeben
ReleaseMutex(hMutex);
while(!Terminated)
{
// Barber blockiert sich an der Semapohre des Kunden
if(WaitForSingleObject(BarbForm->hCustomer, 100) == WAIT_OBJECT_0)
{
// Messages an Toolbook entsprechen den Transitionen
SendTBMessage(WacheAuf);
SendTBMessage(BHoleMutex);
// Handle auf Mutex erzeugen
hMutex = OpenMutex(MUTEX_ALL_ACCESS|SYNCHRONIZE, 0, "Mutex");
// auf Mutex warten
if(hMutex != NULL)
{
if((WaitForSingleObject(hMutex, INFINITE))== WAIT_OBJECT_0)
{
TSharedMemory *Msg;
// Handle auf Shared Memory erzeugen
hWaiting = ::OpenFileMapping(FILE_MAP_WRITE, 0, "MemWait");
if (hWaiting)
{
// Shared Memory öffnen
Msg = (TSharedMemory*)::MapViewOfFile(hWaiting,FILE_MAP_WRITE,
0, 0, sizeof(TSharedMemory));
// Zähler erniedrigen
Msg->Zaehler --;
// Message an Toolbook
SendTBMessage(BWaiting);
// Handle schliesse
::CloseHandle(hWaiting);
// Mutex freigeben
}
}
}
SendTBMessage(BGebeMutex);
// Semaphore erhöhen
ReleaseSemaphore(BarbForm->hBarber, 1, NULL);
// Botschaften lösen Toolbook Animationen aus
SendTBMessage(ErhoeheBarber);
SendTBMessage(Schneide);
SendTBMessage(Schlafe);
}
}
}
Prof. Dr. Keller
Seite 77 von 102
Customer
SendTBMessage(CHoleMutex);
// Customer verschafft sich ein Handle auf den Mutex und blockiert dann
hMutex = OpenMutex(MUTEX_ALL_ACCESS|SYNCHRONIZE, 0, "Mutex");
if(hMutex != NULL)
{
if((WaitForSingleObject(hMutex, INFINITE))== WAIT_OBJECT_0)
{
TSharedMemory *Msg;
// Shared Memory öffnen
hWaiting = ::OpenFileMapping(FILE_MAP_WRITE, 0, "MemWait");
if (hWaiting)
{
Msg = (TSharedMemory*)::MapViewOfFile(hWaiting,FILE_MAP_WRITE, 0,
0, sizeof(TSharedMemory));
// Zähler prüfen
if(Msg->Zaehler < 5)
{
// Zähler erhöhen
Msg->Zaehler++;
SendTBMessage(CWaiting);
// Handle freigeben
SendTBMessage(CGebeMutex);
SendTBMessage(Erhoehe Customer);
// Handle auf zählende Semaphore erzeugen
hCustomer = OpenSemaphore(SEMAPHORE_MODIFY_STATE, false,
“SemCustomer”)
// Wert erhöhen
ReleaseSemaphor(hCustomer, 1, NULL);
CloseHandle(hCustomer);
// Handle auf Semaphor des Barbers erzeugen
hBarber = OpenSemaphore(SEMAPHORE_MODIFY_STATE|SYNCHRONIZE,
false, “SemBarber”);
if(NULL != hBarber)
{
SendTBMessage(Warte);
// Customer blockiert sich an der Sempahore des Barbers
If((WaitForSingleObject(hBarber, INFINITE)) == WAIT_OBJECT_O)
{
// Handle schliessen
CloseHandle(hBarber);
SendTBMessage(Haarschnitt);
SendTBMessage(Gehe);
// Customer beendet sich selbst
Terminate();
}
}
}
// Im Fall, dass schon 5 Customer da sind
else
{
// Handle schliessen
// Mutex freigeben
Prof. Dr. Keller
Seite 78 von 102
SendTBMessage(CCancle);
Application->Terminate();
}
}//hWaiting
}//waitfor
}
// Möglicherweise ist kein Barber da.
else
{
MessageDlg("No Barber", mtError, TMsgDlgButtons() << mbOK, 0);
Application->Terminate();
}
}//if mutex
4.8
Übungsaufgaben
4.8.1
Aufgabe 14
Das folgende Petrinetz zeigt zwei verkoppelte Prozesse P1 und P2. Die Transitionen a und b beschreiben Aktionen von P1, die Transitionen c und d Aktionen von P2, die Stellen M, S1 und S2 sind Synchronisationsstellen zwischen den beiden Prozessen.
M
a
c
S1 S2
b
d
Prozeß P1
Prozeß P2
Zur Synchronisation stehen den beiden Prozessen binäre Semaphore und die beiden Funktionen
Anfordern Semaphor S:
Freigabe Semaphor S:
P(S)
V(S)
zur Verfügung.
a)
Geben Sie das Programm der beiden Prozesse P1 und P2 in Pseudocode an.
Zur Initialisierung der Semaphore wird ein eigenes Programm INIT realisiert. Gehen Sie davon aus,
dass dieser Prozess die Semaphore nach obigem Petrinetz korrekt initialisiert bevor P1 und P2
starten.
Prof. Dr. Keller
program P1;
var
M,S1,S2 : Semaphor;
begin
program P2;
var
M,S1,S2 : Semaphor;
begin
end.
end.
Seite 79 von 102
b)
Prüfen Sie das System auf Verklemmungsfreiheit, indem Sie den Ereignisgraphen (Markierungsübergangsgraphen) zu dem Petrinetz erstellen und die Zustände markieren, in denen eine Verklemmung vorliegt.
c)
Das verkoppelte System kann verklemmungsfrei realisiert werden, indem Sie die Ursache für die
Verklemmung eliminieren. Geben Sie die Programme von P1 und P2 für ein verklemmungsfreies
System an, wenn die Aktionen der beiden Prozesse die folgende Sequenz bilden sollen:
a b c d a b c d a ...
4.8.2
Aufgabe 15
Stellen Sie sich vor, Sie arbeiten mit einem Betriebssystem, dass zur Prozesssynchronisation ausschließlich binäre Semaphore zur Verfügung stellt. Zur Synchronisation zweier Prozesse P1 und P2
brauchen Sie jedoch einen allgemeinen Semaphor. Sie müssen sich die entsprechenden Systemfunktionen P ( Anfordern Semaphor ) und V ( Freigeben Semaphor ) selbst schaffen.
Zeigen Sie, wie man mit Hilfe von binären Semaphoren einen allgemeinen Semaphor realisieren kann.
Ergänzen Sie die untenstehenden Programmfragmente so, dass zwei Prozeduren für die Semaphoroperationen P und V entstehen! Verwenden Sie zur Beschreibung eine PASCAL ähnliche Notation.
Hinweis:
Die Realisierung der allgemeinen Semaphore basiert auf der Idee eine globale Zählvariable SEMA mit
einem Wertebereich { -n,...0,...n } zur Realisierung eines allgemeinen Semaphor einzuführen. Negative
Werte von SEMA kennzeichnen die Anzahl von Prozessen deren P-Operation in den Zustand blockiert
führte. Zum Schutz von kritischen Bereichen und zum Blockieren eines Prozesse werden zwei binäre
Semaphore S und M benötigt.
Vorgaben
Prozeduren für binäre Semaphoroperationen : pbin (var s: binärer Semaphor)
vbin (var s: binärer Semaphor)
binäre Semaphore :
S und M
zählende Semaphorvariable :
SEMA Wertebereich{-n,...0,...n} = ganze Zahl
Zu realisierende Prozeduren für allgemeine Semaphore:
P() und V()
Anfangswerte der Variablen
Gehen Sie bei Ihren Überlegungen davon aus, dass die Semaphore und die globale Variablen wie folgt
vorbelegt sind:
M = 1; S =0
SEMA = 0
Prof. Dr. Keller
Seite 80 von 102
Prozedurfragmente zur Vervollständigung
p()
begin
v()
begin
if (SEMA < 0) then
begin
if (SEMA < 0) then
begin
end
else
begin
end
else
begin
end;
end;
end;
end;
4.8.3
Aufgabe 16
Sie arbeiten mit einem Betriebssystem, in dem zur Interprozesskommunikation binäre und allgemeine
Semaphore ( nur mit Flusszahl=1 ) verwendet werden können.
Das Betriebssystem stellt 16 binäre und 8 allgemeine Semaphore zu Verfügung. Ein binärer Semaphor
wird über eine Nummer zwischen 0 und 15, ein allgemeiner Semaphor durch eine Nummer zwischen 16
und 23 angesprochen.
Über die Betriebssystemfunktionen Pbin(Semaphornummer) und Vbin(Semaphornummer) kann man
die binären Semaphore nutzen.
Mit P(Semaphornummer) und V(Semaphornummer) benutzt man die allgemeinen Semaphore.
Beschreiben Sie den Algorithmus, wie das Betriebssystem die beiden Funktionen für binäre Semaphore,
Pbin() und Vbin(), realisiert. Geben Sie die Programmstücke von Pbin und Vbin jeweils durch ein Programmstück in Pseudocode an.
Welche Datenstrukturen bzw. Variablen benötigt das Betriebssystem zusätzlich zu den Semaphorvariablen ?
void Pbin(unsigned int sema)
{
void Vbin(unsigned int sema)
{
}
}
Prof. Dr. Keller
4.8.4
Seite 81 von 102
Aufgabe 17
Sie wollen Ihr Betriebssystem um allgemeine Semaphore erweitern und sollen dazu die indirekte
Nachrichtenkommunikation zur Realisierung benutzen. Dazu müssen Sie zwei Funktionen
P ( Semaphor S ) und V ( Semaphor S )
programmieren und in einem vorübersetzten Modul als Objekte den Prozessen zu Verfügung stellen. Ein
zusätzlicher Prozess zur Verwaltung von Semaphoren wird nicht benötigt
Über diese beiden Funktionen kann ein Prozess immer nur genau einen Semaphor beantragen oder freigeben ( Flusszahl = 1 ).
Wie wird ein Semaphor im System realisiert ?
Wie sind die beiden Funktionen P() und V() zu realisieren, wenn sie die beiden Systemfunktionen
send(Mailbox,Nachricht) und recieve(Mailbox,Nachrichtenpuffer) zu Verfügung haben.
procedure P( Semaphor S )
begin
end;
procedure V( Semaphor S )
begin
end;
Prof. Dr. Keller
4.8.5
Seite 82 von 102
Aufgabe 18
Auf Ihrem Rechensystem soll ein Weckdienst installiert werden. Dieser Weckdienst soll durch eine
reentrant Prozedur " WakeMe " und ein Systemprozess " Clock " realisiert werden. Ein Prozess, der sich
für eine endliche Zeit selbst blockieren will, kann dies durch Aufruf der Prozedur WakeMe erreichen. Die
Wartezeit des Prozesses wird dieser Prozedur als Parameter in Form einer ganzen Zahl übergeben, die
die Wartezeit in Anzahl von Zeiteinheiten ( clock ticks ) angibt. Der Prozess clock wird periodisch bei jedem Timer-Interrupt aktiviert. Die Synchronisation zwischen Benutzerprozess, Prozess clock und Interruptroutine erfolgt über binäre Semaphore. In einer globalen Variablen count wird die Anzahl der wartenden Prozesse gespeichert. Der Prozess clock deblockiert nach jedem Timer IR die wartenden Benutzerprozesse, so dass diese Ihre verbleibende Wartezeit korrigieren können und bei Ablauf der Wartezeit
weiter arbeiten können.
Die Prozedur WakeMe und der Prozess clock sind wie folgt implementiert:
Vereinbarte Semaphore zur Synchronisation:
MUTEX:
WAIT:
QUIT:
TICK:
semaphor=1;
semaphor=0;
semaphor=0;
semaphor=0;
Benötigte globale Variable zum Speichern der Anzahl von wartenden Prozessen
count: integer = 0;
procedure WakeMe(time : integer)
begin
while ( time > 0 ) do
begin
P(MUTEX);
count := count + 1;
P(WAIT);
V(MUTEX);
V(QUIT);
time := time -1;
end;
end;
process clock
begin
while ( TRUE )do
begin
P(TICK);
P(MUTEX);
while ( count > 0 ) do
begin
V(WAIT);
P(QUIT);
count := count -1 ;
end;
V(MUTEX);
end;
end.
Analysieren Sie die beiden Programme. Ist die Synchronisation korrekt oder können Fehler auftreten?
Wenn ja welche Fehler und wie sind diese zu beheben ?.
4.8.6
Aufgabe 19
Realisierung von Semaphoren mit Flusszahl >1 mit asynchronen, indirekten Nachrichten
Prof. Dr. Keller
Seite 83 von 102
5. Dateiverwaltung
Dateien dienen der langfristigen ( persistente ) Speicherung von Daten.
Massenspeicher präsentieren sich als eine sehr große Liste von Blöcken, die einzeln ausgelesen und
verändert wieder zurück geschrieben werden. Diese Datenblöcke werden beginnend mit 0 fortlaufend
durchnummeriert. Ohne ein Dateisystem fehlen nicht nur jegliche Informationen, welche Blöcke belegt
sind und welche nicht; auch können weder die Namen der Dateien noch die Struktur der Verzeichnisse
festgehalten werden. Wie man sieht, besteht die Dateiverwaltung auf Massenspeichern nicht nur aus
dem reinen Ablegen der einzelnen Daten; vielmehr gibt es eine große Zahl weiterer Anforderungen. Diese zu erfüllen, ist die Aufgabe eines Dateisystems: Es bildet den Mittler zwischen der "physikalischen
Struktur" der Festplatte bzw. Diskette und der logischen Struktur der Daten.
Da sich sowohl die im System befindlichen Dateien, als auch die Verzeichnisstruktur, bedingt durch die
Arbeit damit, ständig ändern, muss ein Dateisystem entsprechende Funktionen anbieten, mit denen Dateien und Verzeichnisse erzeugt, gelöscht oder umstrukturiert werden können. Dies ist über die "Systemfunktionen" möglich, die von den einzelnen Programmen aufgerufen werden. Im interaktiven Betrieb sind
z.B. unter Linux vor allem die GNU-Utilities wie cp, mv, ls ... für die Arbeit mit dem Dateisystem verantwortlich. Auch sie verwenden die entsprechenden Systemaufrufe, die von Kernel und Dateisystem zur
Verfügung gestellt werden.
Natürlich ist es auch notwendig, dass diese Aktionen so schnell und effektiv wie möglich durchgeführt
werden - zusätzlich sollte auch noch möglichst wenig Speicherplatz für die Speicherung der Struktur verbraucht werden, sowie größtmögliche Sicherheit im Umgang mit den Daten geboten sein. Daraus ergeben sich vier wesentliche Forderungen an ein gutes Dateisystem:
1. Das Dateisystem muss eine sehr große Menge von Informationen effizient und sicher verwalten
können.
2. Verschiedene Prozesse sollen auf die Dateien zugreifen können, ohne einander zu stören.
3. Die Arbeit mit den Dateien soll so wenig Ressourcen des Systems wie möglich verwenden.
4. Die einzelnen Dateien sollen nur von Benutzern verwendet werden können, die dazu berechtigt
sind.
Die Festplatte wird hierzu in Systembereich und Datenbereich unterteilt. Im Systembereich werden alle
Informationen zur Verwaltung des Datenträgers und aller dazu notwendigen Datenstrukturen gespeichert.
Dazu gehören in der Regel ein Bootblock, ein Superblock sowie weitere Systemdatenblöcke. Im Datenbereichbefinden sich die Datenblöcke, in denen die eigentlichen Daten gespeichert werden. Alle Informationen, die für die Verwaltung des Dateisystems benötigt werden, müssen sich auf der Festplatte befinden.
Der Superblock enthält alle wichtigen Informationen die zur Verwaltung des dateisystems notwendig sind.
Der Bootblock enthält den Urlader, ein Programm zum Laden des betriebssystems.
Eine Festplatte kann in mehrer Partitionen ( logische Platten ) aufgeteilt werden. Jede Partition hat dann
sein eigenes Dateisystem.
Prof. Dr. Keller
Die seek time liegt im Bereich von 5- 15 m, die latency time liegt bei maximal 11 ms.
Die mittlere Zugriffszeit liegt im Bereich von 7-12 ms.
Im Vergleich dazu ist die mittlere Zugriffszeit auf Daten im Hauptspeicher bei ______ .
Die Kapazität liegt in der Größenordnung mehreren GigaByte.
Typische Blockgrößen:
512 Byte – 4 kByte
Seite 84 von 102
Prof. Dr. Keller
5.1
Seite 85 von 102
Aufbau von Dateisystemen und Katalogen
Aufbau des Dateisystems - Kataloge
Einstufiges Dateisystem
Katalog ( Directory)
Inhaltsverzeichnis des
Volume
Verwaltung der Dateien
Pro Datei genau 1 Eintrag
Datenträger
Volume
Katalogeintrag
Datei
#1
Name der Datei
Dateiattribute
Ort der Daten auf dem Volume
Datei
#n
Stammverzeichnis
Zweistufiges Dateisystem
Datenträger
Volume
Katalogeintrag
Benutzerkatalog
Verweis auf Benutzerkatalog
Katalogeintrag
Katalogeintrag
Datei
#1
Datei
#n
Benutzerdateien
Datei
#1
Datei
#m
Prof. Dr. Keller
Seite 86 von 102
Stammverzeichnis ( root )
Hierarchisches Dateisystem
Datenträger
Volume
Katalogeintrag
Unterverzeichnis
Stufe 1
Datei
Stufe 2
Stufe 3
Arbeitsverzeichnis
Stufe 4
Zugriff auf eine Datei über
Pfadangabe
absolut
relativ zum Arbeitsverzeichnis
Hierarchisches Dateisystem mit Links
root
Datenträger
Volume
Katalogeintrag
Datei
Link
Originaldatei
(Owner)
Datei existiert genau einmal ( Owner)
Es können mehrere Katalogeintrage auf
die Datei verweisen ( Links )
Prof. Dr. Keller
Seite 87 von 102
Hierarchisches Dateisystem mit Links
Hard-Link
Logischer Link
Der Link wird über eine zusätzliche
(Link-)datei realisiert
Die (Link-)datei enthält nur den
Pfadnamen der verlinkten Datei
Der Katalogeintrag verweist auf diese
angelegte Link-datei.
Der Katalogeintrag verweist auf eine physikalische
Adresse, in der eine Beschreibung der Originaldatei liegt.
Diese Dateibeschreibung ist fest mit der Originladatei
verbunden und enthält alle Dateiattribute, auch die
physikalische Lage auf der Festplatte und einen LinkZähler.
Nachteil: Wird die Originaldatei
gelöscht oder verschoben
so existiert die (Link-)datei
noch und enthält den alten
unveränderten Pfadnamen.
Der Link ist ist aber ungültig
Vorteil: Beim verschieben oder umbenennen der Datei
bleibt der Link auf die Dateibeschreibung
gültig. Beim Löschen wird der Linkzähler
geprüft. Die Datei wird nur dann gelöscht wenn
der Linkzähler auf 1 steht, sonst wird nur der
Link-Zähler erniedrigt.
Vorteil: Netzwerkfähig, da der Pfadname
eine Netzwerkadresse
beinhalten kann.
Nachteil: Löscht der Erzeuger A die Datei
während noch ein weitere Link von B existiert,
wird zwar die Datei nicht gelöscht. Der
Katalogeintrag von A wird gelöscht, der Link von
B existiert weiter. Jedoch wird nicht der
Besitzereintrag in der Dateibeschreibung
geändert. Besitzer bleibt also A.
Beispiel:
Beispiel:
Windows NT
UNIX
Dateisystem
Aufbau von Katalogen
• Einstufiges Dateisystem ( CP/M )
Ben.
code
Dateiname
8 Hierarchisches
Dateiname
Anzahl
Blöcke
Dateityp Erweiterung
Dateisystem
Dateityp
Liste von
16 Blöcken
( DOS )
Attribute
Zeit
Datum
Erster
Block
Größe
8 Hierarchisches
Dateisystem
( UNIX )
8Je Datei eine Dateibeschreibung ( i-node )
i-node
Nummer
Dateiname
Dateiattribute
i-node
10 direkte Blöcke
Einfach indirekt
Zweifach idirekt
Dreifach indirekt
Blocknummer
Blocknummer
Blocknummer
Blocknummer
Blocknummer
Blocknummer
Blocknummer
Blocknummer
Blocknummer
Prof. Dr. Keller
Seite 88 von 102
Dateisystem
Aufbau von Katalogen
Informationen über die Datei
Dateiname
Eintrag
Eintrag
Dateiname
Blöcke mit
Verwaltungsinfo
Dateityp
Dateigröße
Datenblock
Eigentümer
Eintrag
Eintrag
Shutzinformation
Datenblock
Erstellungszeitpunkt
Zeitpunkt der letzten Änderung
Datenblock
Liste der physikal. Blöcke
Physikal.
Lage auf der Platte
•
•
5.2
Je Datei ein Eintrag
Je Eintrag Dateiname, Attribute, Lage auf Platte
Physikalische Organisation von Dateien
Datei
Sequenz von logischen Blöcken adressiert durch Dateiname
Block 0
Block 1
Block 2
Dateianfang
Festplatte
Letzter
Block nicht
voll belegt
mit Daten
Dateiende
Sequenz von physikalischen Blöcken adressiert über Spur und
Sektor
Block 0
Spur
Sektor
0
0
Block 1
0
1
Block 2
0
2
Block 3
0
3
Block 4
1
0
Block 5
1
1
Block 6
1
2
Prof. Dr. Keller
Seite 89 von 102
Kompakte zusammenhängende Speicherung
Datei
Block 0
Block 1
Block 2
Nur Block 0 in
Katalogeintrag
Festplatte
Block 0
Block 1
Block 2
Block 3
Block 4
Block 5
Block 6
Vorteil: schneller Zugriff auf die Daten
Nachteil: Fragmentierung
Ausdehnung von Dateien schwierig
Verkettete Liste
Datei
Block 0
Block 1
Block 2
Nur Block 0 in
Katalogeintrag
Festplatte
0 1 2 3 4 5 6 7 8 9 10
EOF
Vorteil:
keine externe Fragmentierung
Ausdehnung von Dateien einfach
Nachteil: langsamer, sequentieller Zugriff
Dateninhalt < Blockgröße
Prof. Dr. Keller
Seite 90 von 102
Indextabelle ( Beispiel: FAT ( File Alocation Table ) )
Index
Datei
Block 0
Block 1
Block 2
Belegt durch BS
0
Belegt durch BS
1
frei
2
5
3
Nur Block 0 in
Katalogeintrag
frei
5
8
Tabelle liegt im
Systembereich der
Platte
defekt
frei
8
EOF
Festplatte
0 1 2 3 4 5 6 7 8 9 10
frei
EOF
Vorteil:
einfach; schneller Zugriff bei kleinen
Platten
Nachteil: langsam; speicherintensiv bei großen
Platten
5.3
Genau eine Indextabelle pro Platte
Für jeden physikalischen Block ein
Tabelleneintrag
Aufbau des Dateisystems ext2 von Linux
Ext2 ( extended filesystem Version 2) ist das Standard Filesystem unter Linux. Es unterstützt Dateinamen bis 255 Zeichen, dateien bis 2 GByte und Datenträger bis 4 TByte.
Unter Linux wird die Festplatte in einzelne Blockgruppen unterteilt, in denen sich sowohl die Datenblöcke,
in denen die eigentlichen Daten gespeichert werden, als auch Freiraum für spezielle zur Verwaltung des
Dateisystems benötigte Datenstrukturen befindet.
Eine Blockgruppe setzt sich aus den in der folgenden Liste aufgezählten Elementen zusammen:
- Superblock
- Gruppendeskriptor
- Block-Bitmap
- Inode-Bitmap
- Inode-Tabelle
- Datenblocks
Die Zusammensetzung einer Blockgruppe präsentiert sich wie folgt...
Superblock
Gruppendeskriptor 0
Gruppendeskriptor 1
…
Gruppendeskriptor n
Blockbitmap
i-Nodebitmap
i-Nodetabelle
Daten
blöcke
…
Datenblöcke
Das ext2-Dateisystem kann mit Blöcken von 1, 2 oder 4 KB Größe arbeiten. Standardmäßig wird eine
Blockgröße von 1 KB verwendet.
Prof. Dr. Keller
5.3.1
Seite 91 von 102
Repräsentation von Daten
Die in einer Datei enthaltenen Daten werden in einem oder mehreren Datenblöcken gespeichert: Ist die
Datenmenge kleiner (oder, im Extremfall) genau so groß wie die Blockgröße, genügt logischerweise ein
einziger Block, um den Inhalt der Datei zu speichern; anderenfalls müssen mehrere Blöcke verwendet
werden. Ein Block kann immer nur als Ganzes belegt werden, d.h. es ist nicht möglich, dass sich beispielsweise zwei kleine Dateien einen Block "teilen". Ext2fs verfährt also so, dass in einem Block stets
nur die Daten einer einzigen Datei gespeichert werden können.
Tatsächlich stellt sich das Problem allerdings differenzierter dar, da man nicht nur auf die optimale Plattenauslastung, sondern auch auf die Geschwindigkeit achten muss: Ein Datenblock besteht normalerweise aus 1 KByte. Es ist auch möglich, von diesem Wert abweichende Blockgrößen von 2 oder 4 KByte zu
verwenden; allerdings muss diese Festlegung bereits beim Formatieren geschehen. Bei Platten, die zur
Aufnahme sehr großer Dateien verwendet werden, wie sie beispielsweise bei Datenbankapplikationen
entstehen, kann sich eine Vergrößerung der Blockgröße positiv auf die Geschwindigkeit auswirken. Sollen hingegen sehr viele kleine, d.h. nur wenige KB umfassende Dateien verwaltet werden, empfiehlt es
sich, für die Blockgröße einen gegenüber dem Standard verkleinerten Wert zu verwenden, um so eine
bessere Ausnutzung der vorhandenen Kapazität (bei kleineren Blockgrößen wird weniger Speicherplatz
durch nicht vollständig ausgefüllte Blöcke vergeudet) zu erreichen - allerdings auf Kosten der Geschwindigkeit, da der eben genannte Vorteil durch einen höheren Verwaltungsaufwand erkauft wird (Je kleiner
die Blockgröße ist, desto mehr Blöcke müssen für eine Datei organisiert und verwaltet werden).
Wie man erkennt, stellt die verwendete Blockgröße immer einen Kompromiss zwischen Geschwindigkeit
und Ausnutzung der Festplattenkapazität dar. Hinsichtlich dieser beiden Pole hat sich die Blockgröße von
1 KByte bewährt und ist für den allergrößten Teil der Computernutzungen der beste Wert, der bedenkenlos übernommen werden kann. Der eigentliche Grund, warum ein Block immer nur für eine einzige Datei
verwendet werden kann, ist allerdings durch die Art und Weise bedingt, mit der ext2fs eine Datei verwaltet wird.
5.3.2
Repräsentation von Dateien
Es muss zwischen der Repräsentation von Daten und Dateien unterschieden werden. Eine Datei ist quasi
eine Symbiose zwischen zwei verschiedenen Arten von Daten: Zum einen die „Nutzdaten“, die bisher als
Daten bezeichnet wurden, und zum anderen die zur Verwaltung der Nutzdaten notwendigen „Zusatzdaten“ wie Dateiname, Datengröße, etc.
All diese Informationen werden in einer Datenstruktur zusammengefasst, die man als i-Node bezeichnet
– der Kern der gesamten Unix-Dateiverwaltung. Jede Datei ( und auch, wie man später sehen wird, jedes
Verzeichnis) wird unter Unix durch einen einzelnen i-Node repräsentiert, der Inhaltund Typ der Datei beschreibt.
Superblock und Gruppendeskriptoren
Dateien werden also mittels i-Nodes verwaltet, die sich neben den Nutzdaten mit auf der Festplatte befinden.
Wie aber werden die i-Nodes selbst verwaltet?
Da sich auf jeder Platte eine große Anzahl von i-Nodes herumtreibt, müssen auch diese vom Dateisystem verwaltet werden.. ext2fs verwendet zu diesem Zweck zwei weitere Konstruktionen, die zum einen
als "Gruppendeskriptoren" und zum anderen als "Superblock" bezeichnet werden.
Blockgruppe
Alle Datenblöcke, die auf der Platte verfügbar sind, werden zu mehreren in übergeordnete Einheiten zusammengefasst, die man als "Blockgruppe" bezeichnet. Sinnvollerweise befinden sich in einer Blockgruppe nur Blöcke, die sich auch physikalisch auf der Festplatte nebeneinander befinden - die Zugriffszeit
beim Lesen oder Schreiben von Blöcken innerhalb einer Blockgruppe sinkt dadurch enorm, da der Lesekopf der Festplatte unter anderem keine weiten Strecken auf der Festplatte zurücklegen muss.
Prof. Dr. Keller
Seite 92 von 102
Wie kann man aber feststellen, welche dieser Blöcke bereits mit Daten belegt sind und welche noch Daten aufnehmen können?
Linux verwendet hierzu eine Struktur, die als Blockbitmap bezeichnet wird, und die in jeder Blockgruppe
gespeichert wird - als Bestandteil des Gruppendeskriptors.
Im Prinzip handelt es sich bei der Blockbitmap umeine Bitliste, in der jedes Bit einen Block innerhalb der
Blockgruppe kennzeichnet. Ein Bit der Liste enthalten entweder eine 0 oder eine 1. Eine 1 weist darauf
hin, dass der Block bereits belegt ist, während eine 0 den jeweiligen Block als frei verfügbar markiert.
Für die Speicherung der i-Nodes selbst werden wiederum einige Blöcke aus der Blockgruppe verwendet.
Die Inode-Tabelle wird im Gruppendeskriptor durch eine Zahl repräsentiert, die auf einen Block zeigt den Startblock für die Speicherung der i-Nodes. Zusätzlich wird eine bestimmte Anzahl von Blocks, die
sich aus der Blockgröße und der Zahl der i-Node’s pro Blockgruppe ergibt, hinter dem Startblock gespeichert (da diese Werte beim Anlegen eines Ext2-Filesystems variabel eingestellt werden können, ist die
Zahl der belegten Blöcke für die Speicherung der i-Node’s auch nicht fest, sondern schwankt je nach
verwendeten Filesystem-Parametern).
Der Superblock bildet zusammen mit den Gruppendeskriptoren quasi ein Layout der Festplatte, in dem
alle für den Zugriff auf die Daten relevanten Informationen gespeichert sind. Die Integrität dieser Strukturen ist für ein fehlerfreies und sicheres Arbeiten mit dem Dateisystem also von höchster Bedeutung. Um
eine Korruption dieser Strukturen auf alle Fälle zu vermeiden, speichert das ext2-Filesystem sie gleich
vielfach auf der Platte ab: In jeder Blockgruppe befindet sich sowohl eine Kopie des Superblocks als auch
der Gruppendeskriptoren aller anderen Blöcke. Normalerweise wird zwar nur der Superblock aus Blockgruppe 0 verwendet; sollte dieser aber einmal einen Fehler enthalten, kann er mit in den anderen Blockgruppen angelegten "Sicherheitskopien" wieder restauriert werden. Zusätzlich werden Block- und InodeBitmap sowie die Inode-Tabelle der jeweiligen Blockgruppe hinter der Liste aller Gruppendeskriptoren
gespeichert.
Diese Aufteilung bringt übrigens noch einen weiteren Vorteil mit sich: Durch die physikalische Nähe der
Inode-Tabelle zu den Datenblöcken auf der Platte wird das Lesen und Schreiben von Dateien zusätzlich
beschleunigt, da weniger Kopfbewegungen auf der Festplatte zu verrichten sind
5.3.3
Verzeichnisse und –einträge
Wir haben nun alle Dateien und Daten sicher auf der Festplatte untergebracht, aber ein entscheidender
Punkt fehlt noch: Wie kann man sie wiederfinden? Dies wird auch dadurch erschwert, daß bisher noch
nirgends der Begriff "Dateiname" aufgetaucht ist und dieser ist schließlich ein essentieller Bestandteil
einer Datei. In diesem Abschnitt wird deshalb erläutert, wie Dateien in die Verzeichnisstruktur eingebunden und anhand ihres Namens gefunden werden.
Als kurze Vorbemerkung: Ich werden in den folgenden Beispielen nur absolute Dateinamen verwenden,
d.h. sie gehen alle vom root-Verzeichnis des Systems (/) aus. Auch intern werden im Kernel nur absolute
Dateinamen verwendet, da die Erweiterung von relativen zu absoluten Angaben z.B. bereits durch die
Shell erfolgt. Ein Verzeichnis wird durch eine relativ simple Datenstruktur beschrieben. Sie enthält nur
vier Elemente, die folgende Bedeutungen haben:
inode name name_len rec_len -
Die Inode, mit deren Hilfe die Daten für das jeweilige Verzeichnis verwaltet werden.
Der Name des Verzeichnisses.
Die Länge des Verzeichnisnamens.
Die Länge der Einträge.
Jedes Verzeichnis ist an genau eine Inode geknüpft, kann aber mehrere Datenblöcke besetzen - genau
so, wie es auch bei normalen Dateien der Fall ist. Die einzelnen Einträge des Datenblocks stehen für eine
Datei; sie sind aus jeweils drei Elementen zusammengesetzt: Der Inode, dem Namen und der Länge des
Namens. Ein Verzeichnis ist also nichts anderes als eine Datei, in der Daten über die darin gespeicherten
Dateien oder über eventuell vorhandene Unterverzeichnisse gespeichert sind. Exemplarisch soll nun
erklärt werden, was geschieht, wenn die Datei (genauer die Inode der Datei) /usr/include/stdio.h gesucht
werden soll.
Prof. Dr. Keller
Seite 93 von 102
Begonnen wird die Suche nach einer Datei immer im root-Verzeichnis, d.h. /.
Die Inodennummer für dieses Verzeichnis ist im Superblock gespeichert und dem System daher stets
sofort bekannt.
Linux muß sich nun Verzeichnis für Verzeichnis nach vorne "hangeln", bis die Inode schließlich gefunden
ist.
Über die Inode des root-Verzeichnisses wird auf den Datenblock zugegriffen, der zu dieser Inode gehört.
Da auch das root-Verzeichnis ein ganz normales Verzeichnis ist, folgt es den vorgestellten Konventionen
- im Datenblock sind also Einträge enthalten, die Dateien und Verzeichnisse aus dem /-Verzeichnis enthalten. Diese Einträge werden solange durchsucht, bis Linux auf den Namen usr trifft. Zusätzlich zum
Namen ist eine Inode gespeichert, die die Nummer der für das /usr-Verzeichnis verantwortlichen Inode
enthält. Mit dieser Nummer ist wiederum der Zugriff auf den Datenblock möglich, in dem die Verzeichniseinträge von /usr enthalten sind. Sie werden von Linux nach dem Namen include durchsucht; war die
Suche erfolgreich, erhält man als Ergebnis wiederum die Indexnummer für eine Inode, deren Datenblock
die Einträge des /usr/include-Verzeichnisses festhält. Diese Einträge werden nun solange durchsucht, bis
Linux auf den Namen stdio.h trifft. Mit diesem Namen ist eine assoziierte Inode gespeichert, die für die
Datei verantwortlich ist - voila, mit ihrer Hilfe kann auf die Datenblöcke und somit auf den Inhalt der Datei
zugegriffen werden.
Die ersten beiden Einträge aller Datenblöcke, in dem die Verzeichniseinträge gespeichert sind, heißen
übrigens immer . und ... Sie bezeichnen das aktuelle bzw. das vorhergehende Verzeichnis und speichern
die Nummern der entsprechenden Inodes. Sicher sind ihnen diese beiden Spezialeinträge schon aufgefallen, wenn sie die Ausgabe von ls betrachtet haben.
Der Nachteil der oben gezeigten Methode zum Auffinden von Dateien soll nicht verschwiegen werden:
Bei jeder Suche ist eine Anzahl von Festplattenzugriffen notwendig, die bekanntlich nicht gerade schnell
vor sich gehen. Um dies zu vermeiden, verwendet Linux diverse Caches und Puffer, die die entsprechenden Prozesse beschleunigen sollen. Das ganze Schema ist also in Wirklichkeit etwas komplizierter, als
es gerade beschrieben wurde.
5.3.4
Ausblick auf Ext3fs
Ext3fs ist der direkte Nachfolger vom Ext2fs, dem "second extended file system". Dieses ist seit langem
das Standard-Dateisystem für Linux und wird von allen Distributionen standardmäßig unterstützt. Da
Ext2fs kein Journaling bietet, hat sich Stephen Tweedie daran gemacht, eine Journal-Erweiterung für
Ext2fs zu programmieren; das Ergebnis der Bemühungen ist Ext3fs. Ext3fs ist also kein völlig neues,
unerprobtes Dateisystem, sondern die Ergänzung von Ext2fs um einen Journal-Treiber. Das bedeutet für
Ext3fs einen großen Vorteil gegenüber anderen Journaling Filesystems: Ext3fs ist zu Ext2fs vollständig
auf- und abwärtskompatibel. Das heißt, dass es möglich ist, eine Ext2fs-Partition "on the fly" auf Ext3
umzustellen und diesen Schritt auch unkompliziert wieder rückgängig zu machen. Es bedeutet außerdem, dass sich eine Ext3fs-Partition als Ext2fs-Dateisystem mounten lässt, was unter Umständen sehr
nützlich sein kann, wenn man sein System (etwa zu Wartungszwecken oder bei Überschreiben des BootSektors) von einer Boot-Diskette ohne Ext3fs-Support starten muss. Ein dritter Vorteil ist, dass Ext3fs
aufgrund der Abwärtskompabilität das Dateisystem-Check-Tool e2fsck von Ext2fs benutzen kann. Damit
verfügt Ext3fs von Anfang an über ein praxiserprobtes und äußerst zuverlässiges Dateisystem-CheckProgramm, auf welches man bei anderen Journaling Filesystems lange Zeit warten musste. Aus diesen
Gründen wird sich dieser Artikel nur mit Ext3fs und dessen Konfiguration beschäftigen.
5.4
Memory Mapped Files
Memory Mapped Files sind Dateien, die entweder vollständig oder in Ausschnitten in den virtuellen Adressraum des Prozesses eingeblendet werden. Damit kann auf die Daten der Datei wahlfrei, wie auf Daten im Arbeitspeicher zugegriffen werden.
Benötigte BS-Funktionen:
Map(Dateiname, virtuelle Adresse, Ausschnitt )
Unmap(virtuelle Adresse )
Prof. Dr. Keller
Seite 94 von 102
Bei einem Zugriff auf die virtuelle Seite wird der Inhalt der Datei von Festplatte in den Arbeitsspeicher
gelagert. Lesen und Schreiben kann dann direkt im Programm ohne Dateifunktionen read() und write()
erfolgen. Erst beim Auslagern der Seite aber spätestens beim Terminieren des Prozesses werden alle
Daten im Speicher wieder in die Datei auf die Festplatte geschrieben.
Vorteil:
schneller Zugriff auf Daten
Nachteil:
schreibende Zugriffe erfolgen im Arbeitspeicher und werden nicht sofort auf Platte übertragen. Bei Programmabsturz sind daher die Daten verloren.
Abhilfe: Bei kritischen Daten kann ein Schreiben auf Platte erzwungen werden.
Besteht gleichzeitig ein lesender Zugriff auf die Datei können inkonsistente Zustände entstehen, da schreibende Zugriffe nicht direkt auf Platte erfolgen. Damit kann eine Änderung schon erfolgt sein, der lesende Prozess bekommt diese jedoch nicht mit.
5.5
5.5.1
Inhaltsbezogener Zugriff auf Dateien
Index-Sequentielle Dateien ( ISAM )
Dateisystem
Index-Sequentieller Zugriff ( ISAM )
ISAMDatei
•
Index
Primärbereich
SORTIERT
Direkter,
inhaltsbezogener
Zugriff
Sequentieller
Zugriff
•
•
•
Datensätze im Primärbereich sortiert,
sequentiell abgelegt
Index aufsteigend sortiert
Ein Indexeintrag pro Block
Aufwendiges Einfügen neuer Datensätze
aufsteigend sortierte Datensätze
13
35
42
10
12
Block 0
Suche nach Datenblock
über Schlüsselvergleich
13
17
20
Block 1
35
40
42
Block 2
Sequentielle Suche nach Datensatz
innerhalb Datenblock
Prof. Dr. Keller
Seite 95 von 102
Dateisystem
Index-Sequentieller Zugriff
• Hierarchischer Index
• starre Hierarchiestufen
Gruppe 0
10
12
Block 0
13
Gruppe 1
17
20
35
40
Block 1
42
45
Gruppe 2
48
Block 2
50
53
60
Block 3
Block 4
45
13
35
60
53
35
53
60
Dateisystem
Index-Sequentieller Zugriff - B-Bäume
Aufbau eines Indexeintrages :
B-Baum ( k,h )
Schlüssel
Si
Aufbau eines Knoten :
Zeiger auf
Nachfolger
Datensatz
Di
Zi
Zeiger auf ersten Nachkommen Z0 + n Indexeinträge
Verzweigungsgrad: 2k+1 mit k = n/2
n=4
k=n/2 =2
Verzweigungsgrad= 5
Z0
Sohn 0
8
8
8
8
S1
D1
Z1
Sohn 1
S2
D2
Z2
S3
Sohn 2
D3 Z13 S4
Sohn 3
D4
Z4
Sohn 4
Verweigungsgrad = Maximale Anzahl von Söhnen
Ein Knoten liegt in einem Plattenblock
Schlüssel innerhalb eines Blockes sind aufsteigend sortiert
Knoten muß mindestens halb voll sein und kann maximal voll
belegt sein
Prof. Dr. Keller
Seite 96 von 102
Dateisystem
Index-Sequentieller Zugriff - B-Bäume
B-Baum ( 2,3 ) zu folgenden Schlüssel ( aufsteigend sortiert ) :
2 3 4 16 25 26 29 35 36 41 43 47 51 53 55 58 67 78 86 88 91 95
Mittleres Element
Platten
block
25 D
2 D
3
Wurzel ( teilweise belegt )
47 D
36
67 D
88
91 D
16
Blatt
Schlüssel < 25
26 D
29
78 D
35
Blatt
Schlüssel > 25 und < 36
41 D
43
51 D
Blatt
53
95
Blatt
Schlüssel > 88
86
Blatt
55 D 58
Blatt ( voll belegt )
Dateisystem
Index-Sequentieller Zugriff - B*-Bäume
B*-Baum ( K=3, k*=2, h=2 )
Wurzel
25
36
47
58
78
88
2 D 3 D 16 D 25 D
Blatt
26 D 29
Blatt
35
36
41 D 43
47
Blatt
51 D 53
55 D 58
Blatt
67 D 78
Blatt
86 D 88
Blatt
91 D 95
Prof. Dr. Keller
5.6
Seite 97 von 102
Effizienzsteigerung, Fehlererkennung und Behebung
5.6.1
Effizienzsteigerung
5.6.2
Fehlererkennung und Behebung
5.6.3
RAID
RAID ( Redundant Arrays of Inexpensive
(Independend) Disks
Idee
Vorteile
Zusammenfassung mehrerer Festplatten zu
einem "Platten-Array"
Für den Anwender erscheint das Array
bestehend aus mehreren kleinen Platten als
wäre es nur eine grosse Platte
Höhere Geschwindigkeiten durch zeitlich
verschränktes Schreiben auf mehrere
Platten
Fehlertoleranz
RAID-Level
Beschreibung
Vorteile / Nachteile
0
Keine Redundanz
Verteilung der Daten auf Blockebene über mehrere Festplatten
( Striping )
Höherer Datendurchsatz als bei einer großen Platte
Bei Defekt einer Platte gehen Daten verloren
1 ( Mind. 2 Platten )
Daten werden parallel auf zwei oder mehrere Festplatten geschrieben ( Spiegelung )
Leseoperationen schneller
Schreiboperationen langsamer
Bei Defekt einer Platte entsteht kein Datenverlust
Hohe Kosten, da geringere Speicherkapazität
2
Hamming-Fehlerkorrektur. Wird nicht realisiert
Nicht üblich
3 ( mind. 3 Platten )
Für jeden Datenblock werden Paritätsdaten auf einer zusätzlichen
Platte Gespeichert
( Nur in Hardware realisierbar )
Nicht üblich
4 ( mind. 3 Platten )
Verteilung der Daten blockorientiert über mehrere Platten.
Für jeden Datenblock werden Paritätsdaten auf einer zusätzlichen
Platte Gespeichert
( Stripe Sets )
Die Paritätsdaten ermöglichen ein Wiederherstellen der
Daten nach einem Systemausfall oder einer defekten
Platte
5
Verteilung der Daten blockorientiert über mehrere Platten. Für jeden
Datenblock werden Paritätsdaten über mehrere Platten verteilt.
Wie 4.
Der Flaschenhals nur 1 Paritätsplatte ist allerdings
behoben.
Prof. Dr. Keller
RAID (Redundant Arrays of Inexpensive
(Independend) Disks)
Datensätze
Data Striping
0
1
2
3
Platte 2
0
1
2
3
RAID (Redundant Arrays of Inexpensive
Spiegelung
0
Datensätze
1
2
3
Platte 1
Platte 2
0
0
1
1
2
2
3
3
Seite 98 von 102
Prof. Dr. Keller
Seite 99 von 102
RAID ( Redunant Arrays of Inexpensive
Hardwarelösungen
– Externe RAID-Boxen mit eigenem Controller, Platten, Lüftung und
Stromversorgung
– RAID-Controller im Rechner. Es sind mehrere Platten anschließbar.
Die RAID-Levels werden im Contoller realisiert
Softwarelösungen
– Raid-Levels werden im Betriebssystemkern
implementiert
•
•
5.7
Windows NT Raid 0,1,4,5
LINUX RAID 0,1,4,5
Übungsaufgaben
5.7.1
Aufgabe 20
Sie arbeiten an einem Rechensystem, das zur Abbildung von Dateiblöcken auf Plattenblöcke eine Indextabelle für die gesamte Festplatte benutzt. Die Festplatte hat eine Größe von 20 MByte. Die Blockgröße
ist 1 KByte. Wie breit muss ein Tabelleneintrag sein ? Wie viel Speicherplatz muss des Dateisystem für
die Indextabelle reservieren ?
5.7.2
Aufgabe 21
Sie arbeiten an einem Rechensystem mit hierarchischem Dateisystem. Verzeichnisse werden wie reguläre Dateien gespeichert. Die Beschreibung von Dateien geschieht über Index-Knoten. Folgendes Bild zeigt
den Aufbau eines Index-Knoten.
Indexknoten
Dateiattribute
20 Byte
1 direkter Block
4 Byte
1 indirekter Verweis
4Byte
1 zweifach indirekter Verweis
Sie wollen eine Datei der Größe 1K einlesen.
Ihr Arbeitsverzeichnis ist :
/usr/stud
Der Dateiname :
daten.dat
4Byte
Wie viele Plattenzugriffe benötigen Sie um alle Daten in den Arbeitsspeicher zu kopieren, wenn die
Blockgröße 1K ist, alle Indexknoten in Block 2 liegen, Verzeichnisse maximal 1 KByte Größe haben und
das Stammverzeichnis in Block 1 liegt?
Das Dateisystem benutzt den Arbeitsspeicher zur Reduzierung der Plattenzugriffe.
Prof. Dr. Keller
5.7.3
Seite 100 von 102
Aufgabe 22
Die Festplatte ihres Rechners hat eine Kapazität von 128 KByte mit einer Blockgröße von 512 Byte. Ihr
Dateisystem ist hierarchisch organisiert. Hauptkatalog, Unterkataloge und reguläre Dateien werden
durch Indexknoten verwaltet.
Indexknoten
Dateiattribute
1 direkter Block
1 indirekter Verweis
1 zweifach indirekter Verweis
Ein Indexknoten enthält neben den Dateiattributen die Blocknummer
des ersten logischen Blocks, einen einfach indirekten Verweis auf
weitere Blöcke und einen zweifach indirekten Verweis auf weitere Plattenblöcke bei sehr großen Dateien.
Ein Indexknoten hat eine Größe von insgesamt 8 Byte.
Sie befinden sich in Ihrem Arbeitsverzeichnis mit dem absoluten Pfadnamen /wurzel/stud/test.
Der erste "/" kennzeichnet das Hauptverzeichnis der Platte, alle folgenden "/"dienen als Trennzeichen der Unterverzeichnisse.
Ein Katalogeintrag enthält den Dateinamen und die Nummer des Indexknoten, der die Dateiattribute und
die Abbildung der logischen Plattenblöcke auf physikalische Plattenblöcke enthält. Ein Katalogeintrag hat
eine Länge von 8 Byte.
Ihr Arbeitsverzeichnis enthält insgesamt 64 Dateien. In Ihrem Arbeitsverzeichnis liegt eine Datei mit
Namen FOO. Diese Datei enthält 50 Datensätze mit einer Länge von 25 Byte.
Die Verwaltung freier Plattenblöcke erfolgt über eine Bit Map.
Sie wollen die Datei FOO kopieren in eine neue Datei mit Namen NOT.
Auf der Platte befinden sich vor dem Kopiervorgang insgesamt 190 Dateien ( Verzeichnisse + reguläre
Dateien ).
Das Dateisystem muss für den Kopiervorgang mehrere Plattenblöcke neu belegen, die zu unterschiedlichen Objekten gehören.
Geben Sie an wie viele neue Plattenblöcke belegt werden und zu welchen Objekten diese Plattenblöcke
gehören.
Prof. Dr. Keller
6. Ein-/Ausgabesystem
Ein- /Ausgabe-System
Benutzerprozess
Ein-/Ausgabe-Funktionen
i/O-Auftrag
(Geräteunabhängig )
Rückmeldung
Geräteunabhängige
Auftragsbearbeitung
Aufträge
Gerät
Steuerbefehle
Aktivierung
GeräteGeräteregister
register
Datenübertragung
Geräte-Treiber
Geräte-Treiber
Geräte
beschreibungen
und
I/O-Aufträge
I/O-Puffer
Betriebssystem
Interrupt-Service-Routinen
Seite 101 von 102
Prof. Dr. Keller
Seite 102 von 102
7. Literaturverzeichnis
Tanenbaum, Andrew S.
Moderne Betriebsysteme, 2. Auflage, Prentice Hall 2002,
ISBN 3-8273-7019-1
Tanenbaum, Andrew S.
Modern Operating Systems, Prentice Hall, 1992,
ISBN 0-13-588187-0
Stallings, W.
Betriebssysteme, Prinzipien und Umsetzung, 4. Auflage,
Prentice Hall 2003, ISBN 3-8273-7030-2
Jürgen Nehmer, Peter Sturm
Systemsoftware
Grundlagen moderner Betriebssysteme,
dpunkt Verlag 1998, ISBN 3-920993-74-8
Wolfgang Laun
Konzepte der Betriebssysteme, Springers Angewandte Informatik,
Springer Verlag, 1989, ISBN 3-211-82153-8
AT&T
Unix System V Programmers guide, Prentice Hall, 1987,
ISBN 0-13-940438-4
Gulbins, Jürgen
UNIX, Springer Verlag, 1984
Gulbins, Jürgen, Obermayr, Karl
Linux. Oberflächen, Konzepte, Kommandos. Springer Science + Business
Media, Gebundene Ausgaben, Juli 2003, ISBN 3-540-00815-2
Stephen R. Bourne
Das Unix System V, Addison-Wesley, 1988, ISBN 3-925118-23-3
Stevens, W. Richard
Programmierung von Unix-Netzen, Carl Hanser Verlag, 1992
ISBN 3-446-16-318-2
Regionales Rechenzentrum
für Niedersachsen / Uni Hannover
Windows XP Grundlagen für Anwender
Windows XP Systembetreuer Workstation
Windows Server 2003 AuV Aufbau und Verwaltung eines
Netzwerkes
Windows Server 2003 N Netzwerkadministration
Windows ME Grundlagen für Anwender
Windows ME Systembetreuer
Windows NT 4.0 Anwender
Linux Nutzung mit der grafischen Oberfläche KDE
Unix Eine Einführung
Diese Begleitmaterialen zu Vorlesungen / Kursen sind erhältlich
beim ASTA / Lehrmittelreferat für Preise unter 7 € je Heft.
Eine Liste aller erhältlichen Bücher erhält man unter:
http://www.rrzn.uni-hannover.de/buecher.html

skript2005

Transcrição

Documentos relacionados

Vereinbarung gemäß Beschluss BK6-06-009-GPKE

Technische Anforderungen an eine multimediafähige

158 Gewinde-Kernlochdurchmesser · Thread hole

Titel der Aufgabe - Software

visionapp Platform Management Suite Most Recently Used List

rosenheim

FSD,SD-EG-Konformitätserklärung_de

Profil - Diplom-Informatiker Frank Seitz

Versuch 2: Addierer

Z-Club-Germany e.V. April 2009 Langenburg Historic

Programmverhalten analysieren - VB

C3c | Compact | Betriebssystem

Präsentationsfolien

PWS A - C Flyer A4 2014 DE_ENG_web

Patrizier 4 Tippsammlung

Methoden des Orff-Instituts - Orff Schulwerk Forum Salzburg

Programmierung von Parallelrechnern mit gemeinsamem und