Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen angezeigt.
| Nächste Überarbeitung | Vorhergehende Überarbeitung | ||
| edv:betriebsysteme:start [15 50 2025 19 : 50] – angelegt - Externe Bearbeitung 127.0.0.1 | edv:betriebsysteme:start [29 41 2026 19 : 41] (aktuell) – André Reichert-Creutz | ||
|---|---|---|---|
| Zeile 1: | Zeile 1: | ||
| {{: | {{: | ||
| {{ : | {{ : | ||
| - | < | ||
| - | < | ||
| - | <HTML lang=de xmlns=" | ||
| - | <META content=BOHkCLIlpxR8ACzsNHIJ0oiVOE0mxaTjMKhP2KOewgc | ||
| - | name=google-site-verification>< | ||
| - | href=" | ||
| - | rel=stylesheet>< | ||
| - | href=" | ||
| - | type=text/ | ||
| - | <META http-equiv=content-Type content=" | ||
| - | href=" | ||
| - | type=image/ | ||
| - | <META content=" | ||
| - | <META content=" | ||
| - | <META content=" | ||
| - | <META content=" | ||
| - | <META content=10/ | ||
| - | <META content=" | ||
| - | < | ||
| - | content=" | ||
| - | name=Keywords> | ||
| - | < | ||
| - | content=" | ||
| - | name=Description> | ||
| - | <META content=bildung name=page-topic> | ||
| - | <META content=bericht name=page-topic> | ||
| - | <META content=alle name=Audience> | ||
| - | <META content=de name=Language> | ||
| - | <META content=INDEX, | ||
| - | <STYLE type=text/ | ||
| - | </ | ||
| - | <SCRIPT src="http:// | + | ====== DON'T PANIC: Per Anhalter durch das Betriebssystem ====== |
| - | type=text/ | + | |
| - | <META content=" | + | Willkommen, Anhalter! Dieser zweiwöchige Kurs ist euer Handtuch für die Reise durch die Galaxis |
| - | < | + | |
| - | <TABLE class=FrameTable cellSpacing=0 cellPadding=0 width=950 bgColor=white> | + | |
| - | < | + | |
| - | <TR class=topPageBar> | + | |
| - | <TD style=" | + | |
| - | < | + | |
| - | <TD class=bgunten colSpan=3>& | + | |
| - | < | + | |
| - | <TD class=content style=" | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=pagetitle> | + | |
| - | www.kreissl.info</ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | stellt < | + | |
| - | < | + | |
| - | bereit. Daten oder Virtuelle Maschinen sind kein Teil | + | |
| - | des Betriebssystems sondern des Dienstleistungssystems. | + | |
| - | Die Metasteuerungen sind entscheidend beim Entwurf. | + | |
| - | (z.B. in Bezug auf Uni- oder | + | |
| - | Mehrbenutzersystem)< | + | |
| - | Betriebssystem eine erweiterte Maschine | + | |
| - | (Top-Down-Sicht), um durch Abstraktionen eine für den | + | |
| - | Menschen (Programmierer) überschaubare Form als | + | |
| - | Programmiergrundlage zu bieten.< | + | |
| - | alt=" | + | |
| - | src=" | + | |
| - | border=0> | + | |
| - | < | + | |
| - | Betriebssystem | + | |
| - | Programme</ | + | |
| - | Betriebssteuerung erledigen und die Benutzeraufträgen | + | |
| - | eine zugängliche Umgebung bereitstellen. Betriebsmittel | + | |
| - | sind Komponenten sowohl | + | |
| - | Software (System und Anwendersoftware), | + | |
| - | Prozessor, Speicher, | + | |
| - | Programme etc.< | + | |
| - | z.B. dem Anwender, Programme auf unterschiedlicher | + | |
| - | Hardware laufen zu lassen. D.h. das Betriebssystem | + | |
| - | bietet dem Anwender eine < | + | |
| - | Maschine</ | + | |
| - | " | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | leichter durchschaubare virtuelle Maschine | + | |
| - | < | + | |
| - | verwaltet die Ressourcen </ | + | |
| - | <DIV align=right>< | + | |
| - | Betriebssysteme</ | + | |
| - | < | + | |
| - | Rechners aus? </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Single-Task) | + | |
| - | < | + | |
| - | Linux) | + | |
| - | < | + | |
| - | oder in Echtzeit) </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Virtuelle Maschinen | + | |
| - | < | + | |
| - | Erweiterungen </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | genannten ' | + | |
| - | Mikroprogrammebene und der Anwendungsebene | + | |
| - | < | + | |
| - | < | + | |
| - | Festplatten...) | + | |
| - | < | + | |
| - | Prozessverwaltung und -Kommunikation und Organisation | + | |
| - | des Mehrprogrammbetriebes | + | |
| - | < | + | |
| - | < | + | |
| - | Faults, Division by Zero u.s.w. | + | |
| - | < | + | |
| - | < | + | |
| - | (Datensicherung, | + | |
| - | </ | + | |
| - | < | + | |
| - | Rechnersystems | + | |
| - | Systems</ | + | |
| - | Kriterien, in dem eine formale Beschreibung durch eine | + | |
| - | Theorie in Gesetzen formuliert werden kann. | + | |
| - | < | + | |
| - | BS grundlegend? | + | |
| - | (Betriebszustände)</ | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | </ | + | |
| - | <TD class=""> | + | |
| - | Betriebssystemfunktionen im Kern des Systems, | + | |
| - | welches Sicherheit des Systems erhöht, da diese | + | |
| - | geschützt von Andwenderprogrammen laufen. </ | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=""> | + | |
| - | " | + | |
| - | (wie I/O Funktionen) sind aber nur im Kernelmode | + | |
| - | ausführbar. Diese können über bestimmte Methoden | + | |
| - | gerufen werden. | + | |
| - | </ | + | |
| - | Kern laufen die Systemkritischen Funktionen, wie z.B. | + | |
| - | I/ | + | |
| - | geschützt vor Anwendungen | + | |
| - | Aufrufs von Betriebssystemsdiensten</ | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=""> | + | |
| - | können BS-Funktionen gerufen werden. Die | + | |
| - | Schnittstelle zwischen Usermode | + | |
| - | sogenannte Traps (Einstiegspunkte). Geräte können | + | |
| - | Traps nicht nutzen, sondern können die BS-Dienste | + | |
| - | durch spezielle Interruptsmechanismen erreichen. | + | |
| - | </ | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=""> | + | |
| - | < | + | |
| - | sich User-Mode und Kernel-Mode Nachrichten | + | |
| - | zuschicken. </ | + | |
| - | ist eine Entkopplung von System und Anwendung! Windows | + | |
| - | NT bietet eine API mit mehr als 10.000 Systemaufrufen, | + | |
| - | Unix dagegen ca. 300.< | + | |
| - | alt=" | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | nicht sichtbar | + | |
| - | < | + | |
| - | < | + | |
| - | Äußeren </ | + | |
| - | < | + | |
| - | < | + | |
| - | beschrieben | + | |
| - | < | + | |
| - | (quatradisch) | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | </ | + | |
| - | den Zugriff auf die jeweilige übergeordnete Schicht | + | |
| - | bereit. Somit kann jede Schicht auch die Betriebsmittel | + | |
| - | und Dienste darunterliegender Schichten nutzen. Eine | + | |
| - | Schicht steuert die unmittelbare Schicht über ihr. | + | |
| - | (< | + | |
| - | < | + | Ohne ein Betriebssystem müsstet ihr jede Spannungsänderung im Silizium selbst steuern – eine Aufgabe, die selbst |
| - | < | + | |
| - | < | + | |
| - | Steuerungen bzw. Instanzen) | + | |
| - | < | + | |
| - | < | + | |
| - | Steuerungen </ | + | |
| - | < | + | |
| - | Schichtenmodell? | + | |
| - | < | + | |
| - | < | + | |
| - | gering | + | |
| - | < | + | |
| - | < | + | |
| - | (Steuerung, BM-Transformationen) </ | + | |
| - | < | + | |
| - | ist eine abstrakte Ressource, welche über eine Adresse | + | |
| - | und einen Wert verfügt. Sie wird definiert über | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Betriebsmittels) | + | |
| - | < | + | |
| - | Wert des BM) | + | |
| - | < | + | |
| - | miteinander) </ | + | |
| - | Betriebsmittels ergibt sich aus Wert x Adresse.</ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | nicht wie Dateideskriptor) | + | |
| - | < | + | |
| - | exklusiv wie Prozessor oder Drucker) | + | |
| - | < | + | |
| - | Interrupt oder mehrfach wie Prozessor oder Speicher) | + | |
| - | < | + | |
| - | Betriebsmittel) </ | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | und eine Adresse besitzen | + | |
| - | < | + | |
| - | < | + | |
| - | Elemente ermöglichen </ | + | |
| - | < | + | |
| - | Hauptspeicher! </ | + | |
| - | < | + | |
| - | < | + | |
| - | von-Neumann Rechner nur einen Hauptspeicher hat. | + | |
| - | < | + | |
| - | Speicherzellen mit Adresse und Wert. | + | |
| - | < | + | |
| - | Byte-Orientierten Speicher | + | |
| - | < | + | |
| - | Speicher </ | + | |
| - | < | + | |
| - | Tupel aus id (Betriebsmittel) und einem Aktivitätstoken, | + | |
| - | welches die einzelnen Dienste ruft. Zwischen | + | |
| - | Betriebsmitteln untereinander und zwischen Instanzen | + | |
| - | untereinander bestehen Relationen. | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | hergestellt | + | |
| - | verbinden sich Instanzen. Dabei treten beide immer | + | |
| - | zusammen auf. Eine Schnittstelle kennzeichnet das | + | |
| - | statische Verhalten einer Relation und ein Protokoll das | + | |
| - | dynamische, d.h. die Semantik der Relation.< | + | |
| - | Beispiel nehmen | + | |
| - | Schnittstelle ein Betriebsmittel (Speicherbuffer) und | + | |
| - | das Protokoll (Verhalten) ist als Dienst | + | |
| - | implementiert.< | + | |
| - | Output On Line</ | + | |
| - | steuerungsorientierte Schnittstellen. Datenorientierte | + | |
| - | Schnittstellen arbeiten ohne Synchronisation und | + | |
| - | verbrauchen viel Ressourcen (Busy Waiting). | + | |
| - | Steurerungsorientierte Schnittstellen sind z.B. | + | |
| - | Systemcalls und Interrupts. </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | " | + | |
| - | < | + | |
| - | < | + | |
| - | eigenen virtuellen Steuerwerk des Prozesses geben | + | |
| - | </ | + | |
| - | < | + | |
| - | Prozesse parallel laufen zu lassen. Bei | + | |
| - | Einprozessormaschinen (kooperativ oder preemtiv) wird | + | |
| - | | + | |
| - | verschiedenen Betriebsmittel können von mehreren | + | |
| - | Prozessen mehrfach bzw. parallel genutzt werden. | + | |
| - | < | + | |
| - | sie sich? </ | + | |
| - | <TABLE cellSpacing=2 cellPadding=1 border=0> | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc></ | + | |
| - | <TD class=desc width=80> | + | |
| - | <TD class=desc width=80> | + | |
| - | <TD class=desc> | + | |
| - | <TD class=desc> | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | Eintrittspunkt (kooperatives Multitasking) </ | + | |
| - | <TD class=descsec> | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | behält </ | + | |
| - | <TD class=descsec> | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | <TD class=descsec> | + | |
| - | behält </ | + | |
| - | <TD class=descsec> | + | |
| - | gruppiert und teilen sich dort die Betriebsmittel | + | |
| - | </ | + | |
| - | < | + | |
| - | mindestens? </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Betriebsmittel </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Betriebsmitteln ist diese so nicht mehr gegeben und | + | |
| - | Synchronisation | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Daten zwischen Prozessen) | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | außer den Prozessor) | + | |
| - | < | + | |
| - | Betriebsmittel) | + | |
| - | < | + | |
| - | Betriebsmittel) </ | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Speicherabbild eines schon bestehenden Prozesses | + | |
| - | erzeugt (bei NT wird Prozess mit einem Initialzustand | + | |
| - | erstellt) | + | |
| - | < | + | |
| - | des Vaterprozesses </ | + | |
| - | Schleife nicht unter NT aber unter Unix:< | + | |
| - | </ | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | Speicherabbild des Vaters | + | |
| - | < | + | |
| - | Speicher und Deskriptoren mit Vater teilt | + | |
| - | < | + | |
| - | Kopieren eines Programms in den Speicher | + | |
| - | < | + | |
| - | Sohnprozesses | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | #include sys/ | + | |
| - | #include unistd.h | + | |
| - | #include stdlib.h | + | |
| - | #include stdio.h | + | |
| - | #include string.h | + | |
| - | using namespace std; | + | --- |
| - | int main(void){ | + | ===== Woche 1: Das Fundament der informationstechnischen Existenz ===== |
| - | pid_t pid; //für PID des Sohnes | + | ==== Modul 1: Historie und Architektur (Tag 1) ==== |
| - | char str1[1000]; // | + | Wie strukturieren wir das Chaos aus Nullen und Einsen? Alles begann mechanisch. |
| + | * Konrad Zuse konstruierte mit der Z1 das erste Rechenwerk, das voll auf der Grundlage | ||
| + | * Die Z22 war später der erste Röhrenrechner der Zuse KG, in dem Programme direkt in der Maschine gespeichert werden konnten. | ||
| + | * Die erste Computergeneration (1945-1955) besaß gar kein Betriebssystem, | ||
| + | * Danach kam die Stapelverarbeitung (Batch-Betrieb) der zweiten Generation, bevor die dritte Generation den Dialogbetrieb und Multiprogramming einführte. | ||
| - | while(1){ | + | **Architektur des Kernels: |
| + | * **Die Monolithische Architektur: | ||
| + | * **Die Mikrokern Architektur: | ||
| + | * **Mehrschichtige Architektur: | ||
| - | printf(" | + | {{http:// |
| - | printf("& | + | |
| - | scanf(" | + | ==== Modul 2: Prozesse, Threads und die galaktische Bürokratie (Tag 2) ==== |
| - | if (strcmp(str1,"exit")==0) break; //exit beendet | + | Ein Prozess ist in der Informatik ein Programm, das sich in Befehle (Codebereich) und Programmdaten gliedert. Ein Thread ist eine Erweiterung dieses Modells – ein "leichtes Programm", das sich mit anderen Threads die Betriebsmittel teilt, aber einen eigenen Stapelspeicher (Stack) besitzt. |
| - | if ((pid=fork())<0) //Prozess | + | Damit wir nicht Äonen warten müssen, nutzt das OS ein **Prozessmodell** mit diesen Zuständen: |
| - | { | + | * **WARTEND |
| - | | + | * **LAUFEND |
| - | exit(0); | + | * **UNTERBROCHEN: |
| - | } | + | * **BLOCKIERT: |
| - | if (pid==0) | + | {{http://www.kreissl.info/pics/images/bs_09.gif|Prozessübergänge}} |
| - | { | + | |
| - | char *cmd=strtok(str1," | + | |
| - | | + | |
| - | + | ||
| - | | + | |
| - | | + | |
| - | } // | + | |
| - | else waitpid(pid, | + | |
| - | } | + | |
| - | return 0; | + | Ein **Scheduler** bestimmt, wer rechnen darf. Beim **Round Robin** (Zeitscheibenverfahren) erhält jeder Prozess eine feste Zeitspanne, bevor er verdrängt wird. Beim **Prioritäts-Scheduling** wird einem Prozess eine Priorität zugeordnet, wodurch Prozesse niedrigerer Priorität warten müssen. Bei "First come, first served" |
| - | } | + | |
| - | </ | + | ==== Modul 3: Prozesskommunikation, |
| - | Parameter) und startet danach einen Sohnprozess mit | + | Ein Prozess |
| - | fork() in welchem mit dem Befehl exec das aufzurufende | + | |
| - | Programm in den Speicher kopiert wird. Schlägt exec fehl | + | |
| - | muss mit exit der Sohnprozess manuell beendet werden, da | + | |
| - | dieser sonst nicht terminieren würde.< | + | |
| - | einfach ausprobieren. Den Quellcode eingeben oder | + | |
| - | kopieren und mit dem gcc compilieren:< | + | |
| - | </ | + | |
| - | < | + | |
| - | Betriebssystem verwaltet alle Prozesse. Die Prozesse | + | |
| - | besitzen einen PCB (< | + | |
| - | Block</ | + | |
| - | Informationen gespeichert werden. Das Betriebssystem hat | + | |
| - | nun die Aufgabe alle n Prozesse auf einen oder mehr | + | |
| - | Prozessoren abzubilden. | + | |
| - | < | + | |
| - | < | + | |
| - | Prozessor</ | + | |
| - | ermittelt ein Scheduler den nächst auszuführenden | + | |
| - | Prozess. Ein Task-Switch bzw. Context-Switch bezeichnet | + | |
| - | eine solche Umschaltung zwischen den Prozessen. | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | Eigenschaften dar. Bewerkstelligt wird damit die | + | |
| - | Abstraktion von den Eigenschaften realer Geräte mit dem | + | |
| - | Ziel der Geräteunabhängigkeit. In der Regel stellen | + | |
| - | virtuelle Geräte jedem Prozeß eine synchrone Operation | + | |
| - | zur Verfügung. Dabei kann es erheblich mehr virtuelle | + | |
| - | als reale Geräte geben. Beispiele für virtuelle | + | |
| - | Betriebsmittel sind Druckerspooler oder Dateien. </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | Kritischer Abschnitt ist ein zeitlicher Bereich, in | + | |
| - | welchem mindestens zwei Prozesse auf das gleiche | + | |
| - | Betriebsmittel zugreifen und mindestens eines davon | + | |
| - | schreibt. (Zeitkritischer Ablauf) | + | |
| - | < | + | |
| - | Abschnitt! </ | + | |
| - | < | + | |
| - | < | + | |
| - | <LI>Prozess | + | |
| - | < | + | |
| - | Platznummer liest | + | |
| - | < | + | |
| - | < | + | |
| - | den Druckauftrag von B! </ | + | |
| - | notwendig:</ | + | |
| - | < | + | |
| - | Synchronisation verwendet? </ | + | |
| - | gemeinsame Daten und Ressourcen zugreift, kann nicht | + | |
| - | einfach alle Interrupts abschalten. Dies würde zu keinem | + | |
| - | optimalen Scheduling führen, weil dann jeder Prozeß | + | |
| - | solange die Kontrolle behalten darf wie er will. D.h. | + | |
| - | die wartenden Prozesse sind auf die Kooperation des | + | |
| - | gerade laufenden Prozesses angewiesen (kooperatives | + | |
| - | Multitasking wie Win 3.11) | + | |
| - | < | + | |
| - | gewährleistet werden, daß niemals sich mehr als ein | + | |
| - | Prozess in einem kritischen Abschnitt befinden darf. Die | + | |
| - | Anwendung einer einfachen Sperrvariable ist hier nicht | + | |
| - | möglich, da der Zugriff und das Setzen dieser, selbst | + | |
| - | einen kritischen Abschnitt darstellt. Es müssen | + | |
| - | Algorithmen gefunden werden, welche die Funktionalität | + | |
| - | gefahrlos implementieren. | + | |
| - | < | + | |
| - | kritische Abschnitte erfüllen? </ | + | |
| - | < | + | |
| - | < | + | |
| - | über mutual exclusion | + | |
| - | < | + | |
| - | beide im kritischen Abschnitt | + | |
| - | < | + | |
| - | nicht lang dauern | + | |
| - | < | + | |
| - | Betriebsmittel zugewiesen bekommen | + | |
| - | < | + | |
| - | Fortschreiten der Prozesse </ | + | |
| - | < | + | |
| - | Warten) </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE cellSpacing=2 cellPadding=2 border=0> | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=desc> | + | |
| - | < | + | |
| - | < | + | |
| - | { | + | |
| - | while (turn!=FALSE); | + | |
| - | criticalsection(); | + | |
| - | turn = TRUE; | + | |
| - | notcriticalstuff(); | + | |
| - | } | + | |
| - | </ | + | Prozesse müssen kommunizieren |
| - | < | + | * **Gemeinsamer Speicher:** Prozesse teilen sich Datenbereiche und Variablen. |
| - | { | + | * **Pipes:** Direkte Datenkanäle |
| - | while (turn!=TRUE); | + | * **Signale: |
| - | criticalsection(); | + | * **Prozedurfernaufrufe (RPC):** Ein Prozess |
| - | turn = FALSE; | + | |
| - | notcriticalstuff(); | + | |
| - | } | + | |
| - | </ | + | |
| - | < | + | |
| - | <TD colSpan=2> | + | |
| - | Variable | + | |
| - | geschalten. Nachteil ist das die Abläufe nur | + | |
| - | | + | |
| - | | + | |
| - | arbeitender | + | |
| - | andere diesen wieder verlassen hat. | + | |
| - | </ | + | |
| - | < | + | |
| - | CONST N = 2; // | + | Wenn Prozesse |
| - | INT turn; //Container für aktiven | + | 1. Mutual Exclusion (wechselseitiger Ausschluss). |
| - | INT | + | 2. Belegungs- und Wartebedingung (Prozess |
| + | 3. Unterbrechbarkeitsbedingung (Betriebsmittel können nicht entzogen werden). | ||
| + | 4. Zyklische Wartebedingung (Zyklus im Betriebsmittelgraph). | ||
| - | void P(int process) | + | ==== Modul 4: Speicherverwaltung & Der Unwahrscheinlichkeitsdrive |
| - | { | + | Der Arbeitsspeicher |
| - | int other = 1-process; //Gegenteil des Prozesses | + | |
| - | interested[process] | + | |
| - | turn = process; | + | |
| - | while(( turn==process ) AND (interested[other]==TRUE)); | + | |
| - | } | + | |
| - | void V(int process) | + | |
| - | { | + | |
| - | interested[process]= FALSE; | + | |
| - | } | + | |
| - | </ | + | |
| - | Prozesses, solange ein andere Prozess im K.A. ist. Der | + | |
| - | Hauptnachteil von dezentralen Steuerungen für kritische | + | |
| - | Abschnitte | + | |
| - | bedeutet, dass die Blockierzeit anderer Prozesse nicht | + | |
| - | genutzt werden kann. | + | |
| - | < | + | |
| - | Semaphor ist ein allgemeiner Mechanismus zur | + | |
| - | Synchronisation, ohne aktiv warten zu müssen. Das | + | |
| - | Verfahren wurde von Dijkstra (1965) entwickelt und hat | + | |
| - | sich durchgesetzt. Ein Semaphor arbeitet auf einer | + | |
| - | priviligierten Schicht des Betriebssystems und ist somit | + | |
| - | nicht Teil der Prozesse.< | + | |
| - | einen Kritischen Abschnitt für zwei Prozesse verwalten. | + | |
| - | Falls mehrere Prozesse gleichzeitig auf ein | + | |
| - | Betriebsmittel zugreifen dürfen, reicht | + | |
| - | Semaphor nich aus. Der Semaphor wird dann als Zähler | + | |
| - | implementiert. Falls er 0 ist, ist das Betriebsmittel | + | |
| - | voll ausgelastet. Ist er größer als 0, so sind noch | + | |
| - | Ressourcen vorhanden, d.h. andere Prozesse dürfen | + | |
| - | Kritischen Abschnitt eintreten, solange der Semaphor | + | |
| - | nicht Null ist. Dabei dekrementieren sie diesen und | + | |
| - | blockieren ihn für andere Prozesse, falls der Semaphor | + | |
| - | nun Null ist. Verläßt ein Prozess den Kritischen | + | |
| - | Abschnitt, inkrementiert der Prozess den Semaphor wieder | + | |
| - | und signalisiert damit, dass er seine Arbeit getan hat | + | |
| - | und nun ein anderer eintreten darf. Daher werden die | + | |
| - | beiden Operationen vor und nach dem Kritischen Abschnitt | + | |
| - | oft als Down(sem) und Up(sem) definiert. | + | |
| - | < | + | |
| - | </ | + | |
| - | verwendet, sondern ein Zähler. Für dieses Zähler gibt es | + | |
| - | | + | |
| - | Erhöhen bzw. Dekrementieren des Zählers. Ist nach einem | + | |
| - | down(s) der Zähler null, wird gewartet. Ist er | + | |
| - | irgendwann wieder größer als null werden die Anweisungen | + | |
| - | ausgeführt. Der Semaphor ist nun nichts weiter als | + | |
| - | dieser Zähler, welcher nur durch up und down ansprechbar | + | |
| - | ist! Die beiden Operationen P und V stellen natürlich | + | |
| - | auch kleine kritische Abschnitte dar, welche über | + | |
| - | aktives Warten synchronisiert werden. <PRE class=c# name=" | + | |
| - | { | + | |
| - | if (sem == 0) | + | |
| - | | + | |
| - | sem--; | + | |
| - | } | + | |
| - | V(sem) //Verlasse kritischen Abschnitt | + | |
| - | { | + | |
| - | sem++; //Zugang wieder freigeben | + | |
| - | wakeup(sem); | + | |
| - | } | + | |
| - | </ | + | |
| - | Prozess Schlafenlegen oder Aufwecken.< | + | |
| - | <TABLE cellSpacing=2 cellPadding=2 border=0> | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD class=desc> | + | |
| - | < | + | |
| - | <TD colSpan=2>< | + | |
| - | int sem = 1; //zwei Prozesse | + | |
| - | </ | + | Heute rettet uns der **virtuelle Speicher**: Der Speicheradressraum des Prozessors wird vom realen Adressraum des Arbeitsspeichers getrennt. |
| - | < | + | * Beim **Paging** wird der virtuelle Adressraum in "Seiten" (Pages) unterteilt. Die korrespondierenden Einheiten im physikalischen Speicher heißen Seitenrahmen. |
| - | < | + | * Die Umrechnung erledigt die **Memory Management Unit (MMU)**. |
| - | While (1) | + | |
| - | { | + | * Alternativ (oder ergänzend) gibt es das **Segmentieren**, bei dem der logische Adressraum in Abschnitte variabler Größe |
| - | P(sem); | + | |
| - | // kritischer Abschnitt | + | |
| - | V(sem); | + | |
| - | } | + | |
| - | </ | + | |
| - | < | + | |
| - | { | + | |
| - | P(sem); | + | |
| - | // kritischer Abschnitt | + | |
| - | V(sem); | + | |
| - | } | + | |
| - | </ | + | |
| - | < | + | |
| - | <TD colSpan=2></ | + | |
| - | < | + | |
| - | </ | + | |
| - | | + | |
| - | < | + | |
| - | Gegensatz zu kritischen Abschnitten). Ein Ereignis | + | |
| - | | + | |
| - | < | + | |
| - | Schlafen legen, bis eine bestimmte Bedingung eintreten. | + | |
| - | < | + | |
| - | < | + | |
| - | Ereignis ab. Er wird dann an dem Event-Deskriptor | + | |
| - | | + | |
| - | < | + | |
| - | signalisiert wird, so wird ein dort wartender Prozess | + | |
| - | bereit gesetzt. | + | |
| - | < | + | |
| - | Semaphor-Operationen ergibt sich daraus, dass die | + | |
| - | Signale nicht gespeichert werden, bei Semaphoren wird | + | |
| - | dagegen der Wert bei signal() um 1 erhöht. | + | |
| - | </ | + | |
| - | signal() vor dem wait(): | + | |
| - | wird nicht blockiert.< | + | |
| - | Wert ist nicht vorhanden, kein Prozess wartet. Das | + | |
| - | Ereignis wird vor dem wait()-Aufruf signalisiert: | + | |
| - | wait()-aufrufende Prozess | + | |
| - | weiteres Ereignis eintrifft. Das erste Ereignis wird | + | |
| - | nicht gemerkt. | + | |
| - | < | + | |
| - | funktioniert er? </ | + | |
| - | Prozeduren, Variablen und Datenstrukturen die zu einer | + | |
| - | besonderen Art Modul zusammengefasst werden. Dieses | + | |
| - | Monitormodul verkapselt Semaphore und die Operationen | + | |
| - | auf diesen Semaphoren. Nützlichste Eigenschaft eines | + | |
| - | Monitors ist, daß jeweils nur ein Prozeß zu einer Zeit | + | |
| - | einen Monitor benutzen kann. Ein Monitor ist zwar vielen | + | |
| - | Prozessen zugänglich, | + | |
| - | den Monitor zu einem gegebenen Zeitpunkt benutzen. | + | |
| - | Monitore werden häufig zur Verwaltung von Puffern und | + | |
| - | Geräten eingesetzt. < | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | kritische Abschnitte | + | |
| - | < | + | |
| - | < | + | |
| - | Warten) | + | |
| - | < | + | |
| - | schlafengelegt | + | |
| - | < | + | |
| - | <DIV align=right>< | + | |
| - | Synchronisationsmöglichkeiten</ | + | |
| - | < | + | |
| - | Prozesse nutzen einen Puffer mit N Plätzen zum | + | |
| - | Datenaustausch. Während Prozess A Daten sequentiell in | + | |
| - | den Puffer schreibt, entnimmt Prozess B ein Datum aus | + | |
| - | dem Puffer.< | + | |
| - | < | + | |
| - | < | + | |
| - | Entnehmen synchronisieren? | + | |
| - | < | + | |
| - | Puffer nicht voll ist. | + | |
| - | < | + | |
| - | Platz im Buffer ist. </ | + | |
| - | Problem mit mehreren Semaphoren. | + | |
| - | < | + | |
| - | < | + | |
| - | Abschnittes | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | const N 100 //buffer size | + | |
| - | int mutex = 1 //Für Kritischen Abschnitt | + | ==== Modul 5: Eingabe, Ausgabe und Geräte |
| - | int empty = N //Anfangs leerer Buffer | + | Peripheriegeräte werden |
| - | int full | + | * **Block Devices:** Blockorientierte Geräte wie Festplatten, |
| - | void ErzeugerProzess() | + | * **Character Devices:** Zeichenorientierte Geräte wie Terminals, die einen Datenstrom aus einzelnen Bytes verarbeiten. |
| - | { | + | |
| - | int item; | + | |
| - | | + | |
| - | { | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | } | + | |
| - | } | + | |
| - | void VerbraucherProzess() | + | |
| - | { | + | |
| - | int item; | + | |
| - | | + | |
| - | { | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | } | + | |
| - | } | + | |
| - | </ | + | |
| - | Verbraucher und Erzeuger im kritischen Abschnitt sind. | + | |
| - | Denn falls der Erzeuger gerade eingetreten ist, ist der | + | |
| - | Semaphore mutex null. Versucht nun der Verbraucher | + | |
| - | den kritischen Abschnitt einzutreten, | + | |
| - | P(mutex) warten, da der mutex noch null ist. Um nun zu | + | |
| - | Verhindern | + | |
| - | eine volle geschrieben wird, werden hier elegant zwei | + | |
| - | weitere Semaphoren verwendet, welche das Vorhandensein | + | |
| - | von freien Plätzen (empty) und belegten P lätzen (full) | + | |
| - | zählen. | + | |
| - | < | + | |
| - | Philosophenproblem geht es nicht um Kommunikation | + | |
| - | sondern um Synchronisation. Abstrakt gesehen, gibt es N | + | |
| - | Prozesse und N Betriebsmittel. Ein Prozess benötigt | + | |
| - | mindestens zwei der Betriebsmittel um fortschreiten zu | + | |
| - | können. Ohne Synchronisation, | + | |
| - | alle 5 Prozesse je ein Betriebsmittel bekommen und dann | + | |
| - | unendlich darauf warten, daß ein anderer Prozess eins | + | |
| - | freigibt.< | + | |
| - | Tisch. Sie können entweder Denken oder Essen. Es gibt | + | |
| - | zwar für jeden einen Teller, aber nur fünf Stäbchen. Um | + | |
| - | Essen zu können braucht man aber bekanntermaßen zwei. | + | |
| - | < | + | |
| - | </ | + | |
| - | funktioniert die triviale Lösung mit einem Semaphor pro | + | |
| - | Stäbchen nicht. Es können immer noch alle Philosophen je | + | |
| - | ein Stäbchen gleichzeitig aufnehmen und die Prozesse | + | |
| - | wären allesamt verklemmt. Es muss also irgendwie möglich | + | |
| - | sein, mehr als ein Stäbchen gleichzeitig aufzunehmen. | + | |
| - | Bei den verschiedenen Implementationen ist vor allem | + | |
| - | darauf zu achten, daß dieses Aufnehmen der beiden Stäbe | + | |
| - | eine Atomare Funktion ist. | + | |
| - | < | + | |
| - | wird hier als Signal bezeichnet. Unter Unix gibt es | + | |
| - | vorgegebene durchnummerierte Signale. Unter Unix kann | + | |
| - | mit < | + | |
| - | Prozess ein Ereignis signalisiert werden.< | + | |
| - | Reaktion eines Prozesses auf ein Signal kann verschieden | + | |
| - | ausfallen:< | + | |
| - | < | + | |
| - | < | + | |
| - | vorher für dieses Signal mit der Funktion | + | |
| - | < | + | |
| - | Funktionsadresse)</ | + | |
| - | < | + | |
| - | < | + | |
| - | ignorieren | + | |
| - | < | + | |
| - | < | + | |
| - | festgelegt, dann gibt es Voreinstellungen: | + | |
| - | <TABLE cellSpacing=1 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TD>8 </ | + | |
| - | <TD>/* Floating point trap */ </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TD>4 </ | + | |
| - | <TD>/* Illegal instruction | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TD>2 </ | + | |
| - | <TD>/* voreingestelle Interrupttaste z.B. Ctl -c*/ | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TD>/* Memory access violation | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TD>/* Kill -Kommando ohne Angabe*/ </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TD>9 </ | + | |
| - | <TD>/* unbedingter Prozessabbruch*/ | + | |
| - | </ | + | |
| - | < | + | |
| - | sind nur innerhalb von Prozessgruppen (UNIX) oder | + | |
| - | zwischen Threads eines Prozesses verwendbar, da diese | + | |
| - | nur dort bekannt ist (und eindeutig identifizierbar). | + | |
| - | Diese Einschränkung kann mit der < | + | |
| - | Pipe</ | + | |
| - | mit einem < | + | |
| - | Objekt</ | + | |
| - | | + | |
| - | der Pipe herstellen. Im UNIX erhält eine Named Pipe | + | |
| - | | + | |
| - | alt=" | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | < | + | |
| - | Erweiterungen für Internet und andere Netzdienste. Dabei | + | |
| - | werden ein SocketA und ein SocketB zu einer | + | |
| - | bidirektionalen Pipe verbunden. Identifiziert wird ein | + | |
| - | Socket über Rechneradresse und Portnummer. So | + | |
| - | ermöglichen Sie eine | + | |
| - | Client-Server-Kommunikation:< | + | |
| - | erstellt einen Socket mit < | + | |
| - | dann auf Verbindungswünsche (< | + | |
| - | < | + | |
| - | Synchronistation kennen Sie? | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | asynchron, Empfangen (Lesen) blockierend) | + | |
| - | < | + | |
| - | < | + | |
| - | Nachrichten) | + | |
| - | < | + | |
| - | synchron oder asynchron) | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | verwendet) </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | Scheduling | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | notwendig, wenn die Anzahl der gleichzeitig laufenden | + | |
| - | Prozesse die Anzahl der physikalischen Prozessoren | + | |
| - | übersteigt. Die Verwaltung kann dezentral (Prozesse | + | |
| - | selbst) oder zentral erfolgen. Es gibt zwei grundlegende | + | |
| - | Modelle für zentrale Scheduling-Verwaltung: | + | |
| - | < | + | |
| - | < | + | |
| - | bekannt (Anzahl Prozesse/ | + | |
| - | < | + | |
| - | nicht bekannt) oder geschlossen (Anzahl Prozesse | + | |
| - | bekannt, aber Bedienzeiten nicht) </ | + | |
| - | < | + | |
| - | unterschieden? | + | |
| - | < | + | |
| - | < | + | |
| - | Prozesse pro Zeiteinheit maximieren) | + | |
| - | < | + | |
| - | schnell wie möglich abgearbeitet sein) | + | |
| - | < | + | |
| - | " | + | |
| - | < | + | |
| - | maximal ausnutzen) | + | |
| - | < | + | |
| - | Reaktionszeiten für den Benutzer) | + | |
| - | < | + | |
| - | Prozessorzeit) </ | + | |
| - | CPU-Auslastung und Durchsatz zu maximieren und | + | |
| - | gleichzeitig Warte- und Antwortzeit zu minimieren. | + | |
| - | Deshalb müssen alle Scheduling Algorithmen Kompromisse | + | |
| - | eingehen. | + | |
| - | < | + | |
| - | Verfahren? </ | + | |
| - | Einsatzgebiet des Systems ab: | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Modell werden die Schedules < | + | |
| - | berechnet</ | + | |
| - | interaktiven offenen Systemen, sondern nur in | + | |
| - | geschlossenen Systemen mit fester Prozessanahl und | + | |
| - | vordefinierter Betriebsmittelnutzung mit statischen | + | |
| - | Ablauf. In Dialogsystemen wird deshalb das offene | + | |
| - | probabilistische System verwendet, da hier Anzahl der | + | |
| - | Prozesse und Betriebsmittelnutzung dynamisch erfolgen... | + | |
| - | < | + | Die Gerätesteuerung kann programmgesteuert, unterbrechungsgesteuert |
| - | Entscheidung welcher Prozess den Prozessor bekommt, wird | + | |
| - | dynamisch wärend der Prozessabarbeitung gefällt. Hierbei | + | |
| - | gibt es einige wichtige Größen, welche als stochastische | + | |
| - | Variablen zur Berechnung herangezogen werden können. Die | + | |
| - | Warteschlangentheorie ist wichtiges Mittel für | + | |
| - | Untersuchungen. | + | |
| - | fordern werden in eine Warteschlange | + | |
| - | eingereiht).< | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | Scheduling ohne Prioritäten und ohne Entzug. | + | |
| - | < | + | |
| - | Warteschlange nimmt Prozesse in einem bestimmten Abstand | + | |
| - | | + | |
| - | Wartezeit (W) im Pool einen Prozess und führt diesen in | + | |
| - | einer bestimmten Zeit (B) aus .< | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD align=right colSpan=2>< | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | Warteschlange </ | + | |
| - | <TD>W </ | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD>A </ | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | <TD>B </ | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | Warteschlange </ | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=desc> | + | |
| - | < | + | |
| - | </ | + | |
| - | durchschnittliche Warteschlangellänge oder die | + | |
| - | Wahrscheinlichkeit das sich n Prozesse im System | + | |
| - | befinden, lassen sich mit Poissen-Verteilungen genauso | + | |
| - | wie die oben erwähnte mittlere Verweildauer ermitteln. | + | |
| - | < | + | |
| - | ermittelt werden? </ | + | |
| - | können Erwartungswerte, | + | |
| - | Zwischenankunftsabstände, Bedienwünsche und Auslastung | + | |
| - | berechnet werden. Die Betrachtungen beziehen sich hier | + | |
| - | auf den stationären Fall (t-& | + | |
| - | < | + | |
| - | </ | + | |
| - | eingereiht und sequentiell abgearbeitet. Somit ist | + | |
| - | dieses Modell nicht für Timesharing geeignet, da es eher | + | |
| - | eine Batchverarbeitung ist.< | + | |
| - | Prozess zuerst, müssen andere winzige Prozesse alle auf | + | |
| - | die Beendigung des großen Prozesses warten! Unfair. | + | |
| - | Bessere Implementationen können deshalb das Token | + | |
| - | entziehen.< | + | |
| - | W</ | + | |
| - | Wartezeit(Pn)) / n< | + | |
| - | Prozess als die restlichen, so müssen alle folgenden | + | |
| - | Prozesse auf die Beendigung von P1 warten. Dies läßt die | + | |
| - | durchschnittliche Wartezeit extrem | + | |
| - | steigen.< | + | |
| - | t(P2) = 3 t(P3) = 3< | + | |
| - | von < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Prozess eine Priorität zugewiesen. Ausgewählt wird vom | + | |
| - | Scheduler der ausführbereite Prozess mit der höchsten | + | |
| - | Priorität. Die Prioritäten können statisch definiert und | + | |
| - | dynamisch zugewiesen | + | |
| - | werden.< | + | |
| - | (< | + | |
| - | Priorities</ | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD align=right>< | + | |
| - | src=" | + | |
| - | border=0> | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | möglicherweise nie aktiv werden können, da es immer | + | |
| - | Prozesse höherer Priorität gibt.< | + | |
| - | ist das < | + | |
| - | Priorität der älter werdenden Prozesse)< | + | |
| - | anderes Problem ist die Prioritätenumkehr. Ein | + | |
| - | hochpriorisierter Prozess wartet auf ein Betriebsmittel, | + | |
| - | welches ein niedrigpriorisierter Prozess reserviert hat. | + | |
| - | < | + | --- |
| - | Priorität ohne Entzug)? </ | + | |
| - | zur Verarbeitung ausgewählt. Dabei werden die | + | |
| - | Durchlauflängen der einzelnen Prozesse protokolliert. | + | |
| - | Nach jedem Prozesswechsel wird die | + | |
| - | " | + | |
| - | neu sortiert.< | + | |
| - | First die mittlere Wartezeit. Problem ist hier auch das | + | |
| - | Aushungern von Prozessen, was auch durch Aging (Altern) | + | |
| - | verhindert werden kann.< | + | |
| - | Entzug</ | + | |
| - | ist < | + | |
| - | entzogen, falls ein Prozess in der Warteschlange ist, | + | |
| - | der kürzer als der verbliebene Rest des aktiven | + | |
| - | Prozesses. | + | |
| - | < | + | |
| - | Shortest Elapsed Time (dynamisch mit Entzug)? </ | + | |
| - | beiden Verfahren sind mit Prioritäten und mit Entzug. | + | |
| - | Sie sind daher relativ aufwendig, da ein ständiger | + | |
| - | Abgleich der Prioritätsdaten erfolgen muss. Bei SET wird | + | |
| - | Prozessen, welche schon viel Prozessorzeit zugesprochen | + | |
| - | bekamen, die die Prozessorzeit entzogen. | + | |
| - | < | + | |
| - | </ | + | |
| - | er in seiner Priorität. So wird Aushungern verhindert. | + | |
| - | < | + | |
| - | Prioritäten)? | + | |
| - | Strategie, da sie fair ist und sich auch einfach | + | |
| - | implementieren lässt. Das Prinzip ist einfach. Jeder | + | |
| - | Prozess erhält für eine konstante Zeit t | + | |
| - | (< | + | |
| - | Ablauf des Zeitquantums wird der nächste Prozess aus der | + | |
| - | Warteschlange entnommen und bearbeitet. Der zuvor | + | |
| - | bearbeitete Prozess wird wieder am Anfang der Liste | + | |
| - | eingefügt.< | + | |
| - | Zeitspanne für das Quantum zu finden. Da bei jedem | + | |
| - | Kontextwechsel Register umgeladen müssen, muss ein | + | |
| - | gewisser Zeitraum für Verwaltungsarbeiten eingerechnet | + | |
| - | werden. Dauert das Umladen der Register 5 ms macht ein | + | |
| - | Quantum von 10 ms wenig sinn, da 50% Prozessorzeit | + | |
| - | verschwendet werden würde. Wählt man das Quantum aber zu | + | |
| - | groß (z.B. 500 ms) so ist im Mehrbenutzerbetrieb nur | + | |
| - | bedingte Interaktivität möglich. (RR nähert sich somit | + | |
| - | FCFS an)< | + | |
| - | 100 ms.</ | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Warten) | + | |
| - | < | + | |
| - | schlafengelegt | + | |
| - | < | + | |
| - | <DIV align=right>< | + | |
| - | Algorithmen</ | + | |
| - | < | + | |
| - | Arbeitsspeicher reicht nicht aus, um alle Prozesse | + | |
| - | abzubilden, müssen diese auf einen Tertiärspeicher | + | |
| - | ausgelagert werden. Da das Auslagern bzw. Einlagern | + | |
| - | eines Prozesses sehr viel Zeit in Anspruch nimmt, werden | + | |
| - | zwei Stufen benutzt, um das Scheduling zu realisieren. | + | |
| - | Die erste Stufe arbeitet nur im Hauptspeicher, | + | |
| - | die zweite Stufe für das Ein- oder Auslagern von | + | |
| - | Prozessen verantwortlich ist. Kriterien sind hier | + | |
| - | dieselben wie oben schon erwähnt. | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | genommen? | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | guter Auslastung? </ | + | |
| - | < | + | |
| - | und Stapelbetrieb. Denn ein hoher Durchsatz und eine | + | |
| - | gute Auslastung bedingen viele Prozesse im Rechner, so | + | |
| - | daß jeder Prozeß nur relativ selten aktiv werden kann, | + | |
| - | d.h. das Antwortzeitverhalten schlechter wird. Auch die | + | |
| - | Zuteilungsfairness wird dadurch zunehmend schlechter | + | |
| - | bzw. unfairer. </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | und Buddy | + | |
| - | < | + | |
| - | Segmentierung | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | Freispeicherverwaltung</ | + | |
| - | grundlegende Ansätze zur Verwaltung des freien | + | |
| - | Speichers. Diese werden im folgendem Text erläutert. | + | |
| - | < | + | |
| - | Hauptspeicher in gleich große Einheiten und assoziieren | + | |
| - | zu jedem Eintrag ein Bit in der Bitmap. Ist der Eintrag | + | |
| - | 0, so ist der Speicherbereich noch frei. Bei Nutzung | + | |
| - | eines Speicherbereiches wird in dem assoziierenden | + | |
| - | Bitmapplatz eine eins platziert. Umso kleiner die | + | |
| - | zusammengefassten Einheiten werden, umso größer wird die | + | |
| - | Bitmap. Der größte Nachteil von Bitmaps ist das Suchen | + | |
| - | von freien Speicherbereichen, | + | |
| - | Operation darstellt. | + | |
| - | < | + | |
| - | gibt es? </ | + | |
| - | Löcher und belegte Segmente durch Prozesse | + | |
| - | geführt.< | + | |
| - | Fit</ | + | |
| - | ist wird ausgewählt, | + | |
| - | verschwendet wird (interne | + | |
| - | Fragmentierung).< | + | |
| - | Fit</ | + | |
| - | Liste, sondern vom zuletzt verwendeten | + | |
| - | Listenelement.< | + | |
| - | Fit</ | + | |
| - | auf Speicherausnutzung gesucht. Dadurch das immer Blöcke | + | |
| - | mit der geringsten Speicherplatzverschwendung gesucht | + | |
| - | werden, werden die freien Blöcke irgendwann zu | + | |
| - | klein.< | + | |
| - | mehrere Listen für verschiedene Blockgrößen. | + | |
| - | < | + | |
| - | den Nachteil, daß benachbarte freie oder belegte | + | |
| - | Speicherbereiche sich nicht zusammenlegen lassen. | + | |
| - | Abhilfe schafft hier das Buddy-System. Die Idee beruht | + | |
| - | darauf, dass mehrere Listen geführt werden, welche aber | + | |
| - | nur Blockgrößen von 2^n zulassen. Zweierpotenz deshalb, | + | |
| - | weil ein Rechner Binärzahlen zur Adressierung | + | |
| - | benutzt.< | + | |
| - | maximale Blockgröße beträgt 64 Mbytes und die minimale | + | |
| - | Blockgröße 4 Kbyte. D.h. 226 - 212, also müssen Listen | + | |
| - | für N=12 bis N=26 verwaltet werden. Somit wären für | + | |
| - | diese Blockgrößenwahl mit dem Buddysystem 15 Listen | + | |
| - | notwendig.< | + | |
| - | nächsthöhren Zweierpotenz aufgerundet. D.h. wird eine | + | |
| - | Anfrage an einen 75 Kbyte Block gestellt, muss ein 128 | + | |
| - | Kbyte großer Slot verwendet werden. Anfangs gibt es eine | + | |
| - | Liste für in unserem Beispiel 64 Mbyte Speicher. Der | + | |
| - | Buddymanager würde die Liste rekursiv so oft teilen, bis | + | |
| - | ein 128 Kbyte großer Block in eine der anderen Listen | + | |
| - | frei ist.< | + | |
| - | aussschliesslich Zweierpotenzen wären, würde es zu | + | |
| - | keiner Internen Fragmentierung kommen können. Da dies | + | |
| - | aber nie der Fall ist, wird viel Speicher durch interne | + | |
| - | Fragmentierung verschwendet. | + | |
| - | < | + | |
| - | unterteilen den Speicher in | + | |
| - | < | + | |
| - | gibt es ein Bit im Bitmap. Verknüpfte Listen bieten | + | |
| - | Suchmöglichkeiten mit First Fit, Best Fit oder Quick | + | |
| - | Fit. Quick Fit setzt mehrere Listen bestimmter Lochgößen | + | |
| - | voraus. Das Buddy System verwaltet n Listen von 1,2, 4, | + | |
| - | 8 bis zur Größe des Speichers. D.h. ein 1 MByte großer | + | |
| - | Speicher benötigt 21 Listen und hat Initial nur einen | + | |
| - | einzigen Eintrag in der letzten Liste, der das 1 MByte | + | |
| - | große Loch beschreibt. Alle anderen Listen sind leer. | + | |
| - | Speicher wird nun immer in Abhängigkeit von einer Potenz | + | |
| - | von 2 vergeben, der gerade noch groß genug ist, um die | + | |
| - | Daten aufzunehmen. Dies wird einfach implementiert, | + | |
| - | dem der Große block einfach solange geteilt wird, bis | + | |
| - | der Datenblock in den Freispeicherblock passt. Das | + | |
| - | Buddysystem ist zwar schnell, aber impliziert eine | + | |
| - | < | + | |
| - | immer auf Zweierpotenzen gerundet werden muss. < | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | First-Fit Suche | + | |
| - | < | + | |
| - | Einheiten teilt | + | |
| - | < | + | |
| - | < | + | |
| - | schlafengelegt | + | |
| - | < | + | |
| - | <DIV align=right>< | + | |
| - | Freispeicherverwaltung</ | + | |
| - | < | + | |
| - | Adressräume)? | + | |
| - | Nachteil, daß Programme mit verschieden dynamisch | + | |
| - | wachsenden Programmteilen nur schlecht realisierbar | + | |
| - | sind. Code, Stack und Daten würden hintereinander im | + | |
| - | Speicher liegen. Benötigt ein Programm aber extrem viele | + | |
| - | Variablen, würde der Compiler mit der Fehlermeldung | + | |
| - | abbrechen, daß es nicht genug Speicher gäbe. Um nun | + | |
| - | mehrere Stack, Daten und Codebereiche getrennt | + | |
| - | voneinander adressieren zu können, ohne daß die | + | |
| - | verschiedenen Teile in Konflikt geraten, wurden die | + | |
| - | Segmente eingeführt.< | + | |
| - | wird oft als das Prinzip der < | + | |
| - | Speicherung</ | + | |
| - | einzelnen Seiten nicht nacheinander im Speicher liegen | + | |
| - | müssen, sondern dort eingefügt werden, wo Platz ist. | + | |
| - | Anders als z.B. bei Kontinuierlicher Allokation, wo viel | + | |
| - | Speicher durch externe Fragmentierung verlorengeht, | + | |
| - | tritt bei Segmentation dieses Problem nicht auf. Dafür | + | |
| - | aber interne Fragmentierung... | + | |
| - | < | + | |
| - | Segmenten arbeiten zu können, sind zweiteilige Adressen | + | |
| - | notwendig, bestehend aus < | + | |
| - | < | + | |
| - | Programmierer bewusst sein, da ein Segment nur eine | + | |
| - | logische Einheit darstellt. Besonders einfach gestaltet | + | |
| - | sich das übersetzen von Prozeduren. Angenommen jede | + | |
| - | Prozedur hat ihr eigenes Codesegment, | + | |
| - | die Segmentnummer, | + | |
| - | Eintrittspunkt bei der logischen Adresse 0 dieses | + | |
| - | Segmentes ist.< | + | |
| - | müssen die restlichen Prozeduren nicht neu kompiliert | + | |
| - | werden, da der Eintrittspunkt immer noch der gleiche | + | |
| - | ist. Und zwar 0. Die Segmentnummern werden eh dynamisch | + | |
| - | vergeben. | + | |
| - | < | + | |
| - | Segmenten? </ | + | |
| - | einfach, verschiedene Codesegmente gemeinsam zu nutzen. | + | |
| - | So genannte < | + | |
| - | jedem modernen Betriebssystem notwendig, denn sie | + | |
| - | stellen für viele Programme Frameworks oder API's | + | |
| - | bereit, deren Funktionalität sich jedes Programm | + | |
| - | bedienen kann, soweit es die dafür notwendigen | + | |
| - | Zugriffsrechte hat. Ob ein Segment ausführbar ist oder | + | |
| - | nicht, wird über die Schutzart des Segmentes definiert. | + | |
| - | < | + | |
| - | Speichers durch Paging? </ | + | |
| - | bereitzustellen werden statt echter physikalischer | + | |
| - | Adressen virtuelle benutzt, welche durch die MMU in | + | |
| - | reale Adressen bei Benutzung umgewandelt werden. Durch | + | |
| - | das Paging können Seiten aus- oder eingelagert (nach | + | |
| - | einem Page Fault) werden. Eine < | + | |
| - | Table</ | + | |
| - | Adressen. Swapping ist in Reinform sehr langsam. | + | |
| - | Sinnvollerweise werden Segmente in Seiten geteilt, | + | |
| - | welche durch Paging ein oder ausgelagert werden. | + | |
| - | (Protected Mode) Die MMU kann, muss aber nicht auf der | + | |
| - | CPU liegen. Jede Seitentabelleneintrag hat ein | + | |
| - | Present/ | + | |
| - | eine Seite sich im Speicher befindet oder nicht. Des | + | |
| - | Weiteren vermerkt eine Art < | + | |
| - | ob eine Seite im Speicher geändert wurde, um entscheiden | + | |
| - | zu können, ob ein zurück schreiben notwendig | + | |
| - | wird.< | + | |
| - | Programmablaufes wird < | + | |
| - | genannt. Demand Paging bedeutet, dass Seiten erst dann | + | |
| - | abgefordert werden, wenn sie benötigt | + | |
| - | werden.< | + | |
| - | < | + | |
| - | Contextswitch wird nach der entsprechenden Seitennummer | + | |
| - | in der Page Table gesucht und die zugehörige | + | |
| - | physikalische Adresse errechnet. Es wird meist ein | + | |
| - | n-stufiges Paging angewandt, um die Suche mach den | + | |
| - | Seiten zu beschleunigen (Unix) . Bei i386 gibt es ein so | + | |
| - | genanntes < | + | |
| - | 1024 Zeilen, welche wiederum je auf eine Seitentabelle | + | |
| - | verweisen. Somit enthält eine lineare Adresse beim Intel | + | |
| - | DIR,PAGE und OFFSET Teil. (mehrstufiges | + | |
| - | Paging)< | + | |
| - | Prozesse ausgelagert. < | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | gleichen Prinzip | + | |
| - | < | + | |
| - | < | + | |
| - | Page Faults vom Betriebssystem | + | |
| - | < | + | |
| - | schlafengelegt | + | |
| - | < | + | |
| - | <DIV align=right>< | + | |
| - | Caching</ | + | |
| - | < | + | |
| - | die Zeit der Adressumrechnung zu vermindern, wird in der | + | |
| - | MMU ein < | + | |
| - | nicht mehr als 32 Einträgen verwaltet. Die Einträge | + | |
| - | enthalten die zuletzt verwendeten virtuellen Seiten mit | + | |
| - | der dazugehörigen Seitenrahmennummer im Speicher. | + | |
| - | Gleichzeitig wird dort vermerkt, welche Art von | + | |
| - | Lese/ | + | |
| - | verändert wurde. Kommt eine Anforderung auf eine nicht | + | |
| - | im TLB vorhandene Seite, wird ein Eintrag aus dem TLB | + | |
| - | mit der neu dekodierten Adresse überschrieben, | + | |
| - | bei der nächsten Anfrage die Adressumrechnung entfallen | + | |
| - | kann. < | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | Grund eines zu großen Adressraumes nicht möglich ist | + | |
| - | < | + | |
| - | virtuellen Seitennummern auf physikalische | + | |
| - | Seitenrahmen ab | + | |
| - | < | + | |
| - | (Translation Storage Buffer) verwaltet | + | |
| - | < | + | |
| - | TLB-Miss zuerst untersucht | + | |
| - | < | + | |
| - | in der Translation Table gesucht werden </ | + | |
| - | <DIV align=right>< | + | |
| - | Buffer</ | + | |
| - | < | + | |
| - | Seitentabelle enthält hier einen Eintrag für jeden | + | |
| - | Seitenrahmen des physikalischen Speichers. Der Eintrag | + | |
| - | enthält Informationen über den besitzenden Prozess und | + | |
| - | die virtuelle Seite. So entspricht die Anzahl der | + | |
| - | Einträge der Anzahl der Seitenrahmen im Speicher. Die | + | |
| - | Tabelle verwaltet nur, welche Seite, von welchem Prozess | + | |
| - | in den Seitenrahmen des Arbeitsspeicher geladen wurden. | + | |
| - | < | + | |
| - | effizient, wenn jederzeit genügend Seitenrahmen im | + | |
| - | Speicher frei sind, um diese bei einem Page Fault neuen | + | |
| - | Seiten belegen zu können. Doch wie wird sichergestellt, | + | |
| - | daß der Speicher komplett ausgefüllt werden muss und | + | |
| - | somit bei einem Page Fault erst eine Seite ausgelagert | + | |
| - | werden muss? Viele Betriebssysteme haben dafür einen | + | |
| - | speziellen Dienst vorgesehen. Der Paging Dämon wird in | + | |
| - | zyklischen Abständen aktiviert. Dieser schaut nun nach | + | |
| - | ob genügend < | + | |
| - | Verfügung stehen. Ist dies nicht der Fall, werden so | + | |
| - | viele Seiten wie notwendig mit einem der | + | |
| - | < | + | |
| - | Speicher entfernt und auf die Platte zurückgeschrieben. | + | |
| - | < | + | |
| - | Paging? </ | + | |
| - | virtuellen Speicher) nutzen zu können, werden in fast | + | |
| - | allen modernen Betriebssystemen beide Techniken | + | |
| - | angewandt. Dabei wird das Paging | + | |
| - | < | + | |
| - | nicht sichtbar, hinter die Segmentierung geschalten. Auf | + | |
| - | dieser Basis bauen sich auch die Adressen dieser | + | |
| - | Maschinen auf. Es gibt verschiedene Implementationen von | + | |
| - | Segmentierung und Paging. Aber letztendlich haben sie | + | |
| - | eines gemeinsam. Die logische Adresse besteht aus | + | |
| - | < | + | |
| - | < | + | |
| - | Segmentdeskriptors und | + | |
| - | < | + | |
| - | Segmentes. </ | + | |
| - | sich nun in der Verwaltung der | + | |
| - | < | + | |
| - | die aus Segment + Offset entstandene virtuelle Adresse | + | |
| - | über die Page Table auf den realen Speicher projiziert | + | |
| - | bzw. umgerechnet wird.< | + | |
| - | src=" | + | |
| - | border=0> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | virtuellen Speicher. | + | |
| - | < | + | |
| - | eine Seitentabelle ein. | + | |
| - | < | + | |
| - | als Arbeitsmenge zugeteilt. | + | |
| - | < | + | |
| - | direkt geladen und brauchen nicht zurückgeschrieben | + | |
| - | werden. | + | |
| - | < | + | |
| - | EXE geladen und im Speicher hinterlegt. | + | |
| - | < | + | |
| - | in die Auslagerungsdatei geschrieben. So können | + | |
| - | mehrere Prozesse die selbe EXE im benutzen. (Copy On | + | |
| - | Write) </ | + | |
| - | Listen für: | + | |
| - | < | + | |
| - | < | + | |
| - | (zerofilled) | + | |
| - | < | + | |
| - | Inhalt haben | + | |
| - | < | + | |
| - | nicht modifiziert wurden(standby pages) | + | |
| - | < | + | |
| - | pages) | + | |
| - | < | + | |
| - | referenziert sind (valid pages) | + | |
| - | < | + | |
| - | (unusable pages) </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | festgestellt | + | |
| - | < | + | |
| - | Speicher ist | + | |
| - | < | + | |
| - | auf und es erfolgt ein Trap | + | |
| - | < | + | |
| - | die angefragte Seite überprüft | + | |
| - | < | + | |
| - | < | + | |
| - | Adresse des Seitenursprungs aus dem Pagetableeintrag | + | |
| - | entnommen | + | |
| - | < | + | |
| - | hinzuaddiert und die physikalische Adresse ist | + | |
| - | berechnet. </ | + | |
| - | Tanenbaum)</ | + | |
| - | verwendet, um die letzten paar Umrechnungen ohne | + | |
| - | Verzögerung ausgeben zu können. Ein TLB enthält zwei | + | |
| - | Vergleichsfelder für Segmentnummer und korrespondierende | + | |
| - | virtuelle Seite und einige zusätzliche Attribute, wie | + | |
| - | Schutzattribute, | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | Local Descriptor Tables enthalten die programmeigenen | + | |
| - | Segmente, wie Stack-, Code- und Datensegment der | + | |
| - | verschiedenen Benutzerprogramme. Die Global Descriptor | + | |
| - | Table enthält dagegen die Systemsegmente samt deren des | + | |
| - | Betriebssystems , welche erst geladen werden muss. Wird | + | |
| - | ein Segmentselektor in ein Segmentregister geladen, wird | + | |
| - | der entsprechende Bezeichner aus der LDT oder GDT geholt | + | |
| - | und in MMU Registern gespeichert. Ob L- oder GDT kann | + | |
| - | dem Selektor entnommen werden, da dort ein Bit für diese | + | |
| - | Auswahl reserviert ist. Der Deskriptor besteht nun aus | + | |
| - | der Basisadresse des Segmentes, der Größe des Segmentes | + | |
| - | und verschiedenen Privilegbits. Es wird nun eine | + | |
| - | virtuelle Adresse über Segmenteselektor + Offset | + | |
| - | gebildet. Bei deaktiviertem Paging ist nun diese Adresse | + | |
| - | die lineare physikalische. Ist aber Paging aktiv wird | + | |
| - | die Adresse als virtuell interpretiert und über die | + | |
| - | Seitentabelle auf den realen Speicher abgebildet. | + | |
| - | < | + | |
| - | Segmentverwaltung zu tun? </ | + | |
| - | Deskriptortabelle ist mehrere Byte breit und enthält | + | |
| - | Beschreibungsinformationen für ein Segment aus dem | + | |
| - | linearen Adressraum. Neben der Segment-Basisadresse | + | |
| - | (BASE) enthält er das LIMIT, das die Segmentgröße | + | |
| - | angibt. Dabei wird durch ein Granularitätsbit | + | |
| - | festgelegt, ob das LIMIT direkt als Länge interpretiert | + | |
| - | wird (Segmentgrößen bis 1 MB) oder mit dem Wert 4096 | + | |
| - | multipliziert wird und damit Segmentgrößen bis 4 GB | + | |
| - | unterstützt. Der Descriptor-Privilege-Level gibt an, mit | + | |
| - | welcher Berechtigungsstufe der Zugriff auf das Segment | + | |
| - | erfolgen muss: | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Systemsoftware | + | |
| - | < | + | |
| - | Informationen im Deskriptor zeigen an, ob auf das | + | |
| - | Segment lesend, schreibend oder ausführend zugegriffen | + | |
| - | werden darf und ob es sich um ein System- oder | + | |
| - | Anwendungssegment handelt. Ein Present-Bit gibt an, ob | + | |
| - | das Segment sich derzeit überhaupt im Hauptspeicher | + | |
| - | befindet. | + | |
| - | < | + | |
| - | Segmentierung und Paging </ | + | |
| - | genutzt, um statt einen linearen Adressraum (wie beim | + | |
| - | virtuellen Speicher), mehrere virtuelle Adressräume | + | |
| - | nutzen zu können. Segmentierung wurde entworfen, um | + | |
| - | dynamisch wachsende Tabellen besser Handhaben zu können. | + | |
| - | Somit ist schafft Segmentierung einen mehrdimensionalen | + | |
| - | Adressraum.< | + | |
| - | komplette Ein- und Auslagern von Prozessen. Das Swapping | + | |
| - | des segmentierten Speichers ist vergleichbar mit dem | + | |
| - | Demand-Paging des virtuellen Speichers. Nur das Segmente | + | |
| - | unterschiedlich groß sein können. Aus diesem Grund tritt | + | |
| - | hier das Problem der externen Fragmentierung | + | |
| - | auf.< | + | |
| - | werden die Löcher als verkettete Liste im Speicher | + | |
| - | gehalten. Falls ein Segment geladen werden soll, sucht | + | |
| - | z.B. Best Fit, dass nächst größere Loch unter allen, wo | + | |
| - | das Segment passen würde. First Fit nimmt das Nächste | + | |
| - | Loch, welches für das Segment groß genug | + | |
| - | wäre.< | + | |
| - | Auslagern von Segmenten benutzt werden. Hierbei sind die | + | |
| - | auszulagernden Blöcke gleich groß, da die Segmente in | + | |
| - | gleich große Seiten eingeteilt werden. Zur Auslagerung | + | |
| - | wird das bekannte Demand Paging benutzt. Meist wird eine | + | |
| - | Kombination aus Segmentierung und Paging angewandt, bei | + | |
| - | der die Adresse aus zwei Teilen besteht. (Segmentnummer | + | |
| - | und Offset innerhalb des Segments). Segmente werden also | + | |
| - | in Seiten unterteilt. Zur Leistungsverbesserung werden | + | |
| - | die zuletzt verwendeten Segment-Seiten- Kombinationen in | + | |
| - | einem Assoziativspeicher (TLB) gehalten. Im Gegensatz | + | |
| - | zum Paging ist es beim reinen Swapping nicht möglich, | + | |
| - | Prozesse auszuführen, | + | |
| - | Hauptspeicher passen.< | + | |
| - | Speicher in Allokationseinheiten. Für jede Einheit gibt | + | |
| - | es ein Bit im Bitmap. Verknüpfte Listen bieten | + | |
| - | Suchmöglichkeiten mit First Fit, Best Fit oder Quick | + | |
| - | Fit. Quick Fit setzt mehrere Listen bestimmter Lochgößen | + | |
| - | voraus. Das Buddy System verwaltet n Listen von 1,2, 4, | + | |
| - | 8 bis zur Größe des Speichers. D.h. ein 1 MByte großer | + | |
| - | Speicher benötigt 21 Listen und hat Initial nur einen | + | |
| - | einzigen Eintrag in der letzten Liste, der das 1 MByte | + | |
| - | große Loch beschreibt. Alle anderen Listen sind leer. | + | |
| - | Speicher wird nun immer in Abhängigkeit von einer Potenz | + | |
| - | von 2 vergeben, der gerade noch groß genug ist, um die | + | |
| - | Daten aufzunehmen. Dies wird einfach implementiert, | + | |
| - | dem der Große block einfach solange geteilt wird, bis | + | |
| - | der Datenblock in den Freispeicherblock passt. Das | + | |
| - | Buddysystem ist zwar schnell, aber impliziert eine | + | |
| - | starke interne Fragmentation, | + | |
| - | Zweierpotenzen gerundet werden muss. </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | ===== Woche 2: Dateisysteme, Cluster |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | eine Seite angefordert wird, aber kein Platz für deren | + | |
| - | Einlagerung im Speicher mehr vorhanden ist, so muss eine | + | |
| - | andere Seite entfernt werden. Aber welche? Es gibt nun | + | |
| - | verschiedene Ansätze für dieses Problem... | + | |
| - | < | + | |
| - | Seitenersetzung? | + | |
| - | aber < | + | |
| - | < | + | |
| - | wird ausgelagert. Da in einem Echtzeitsystem nie | + | |
| - | vorhersagbar ist, welcher Prozess wann wie lange aktiv | + | |
| - | sein wird, ist diese Strategie nicht umsetzbar... In | + | |
| - | einem deterministischen Modell wäre er aber durchaus | + | |
| - | denkbar, da dort jeder Schritt eindeutig definiert ist. | + | |
| - | < | + | |
| - | Not-Recently-Used? | + | |
| - | Statusbits zugeordnet. R wird gesetzt, wenn die Seite | + | |
| - | lesend oder schreibend referenziert wurde. M wird | + | |
| - | gesetzt, falls die Seite verändert wird. Diese beiden | + | |
| - | Bits sind in jedem Seitentabelleneintrag enthalten | + | |
| - | müssen bei jeder Seitenreferenzierung aktualisiert | + | |
| - | werden.< | + | |
| - | genutzt werden um einen Paging-Algorithmus zu | + | |
| - | realisieren. | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | wählt zufällig eine Seite aus der kleinstnummerierten | + | |
| - | Klasse zum Entfernen aus. | + | |
| - | < | + | |
| - | First Out? </ | + | |
| - | Seiten enthält. Neue Seiten werden an das Ende der Liste | + | |
| - | angefügt. So ist die Liste nach dem < | + | |
| - | Seiten sortiert</ | + | |
| - | macht nichts weiter, als bei einem Seitenfehler die | + | |
| - | älteste Seite zu entfernen, also die Seite, die am | + | |
| - | Anfang der Liste steht.< | + | |
| - | daß auch extrem häufig referenzierte Seiten ausgelagert | + | |
| - | werden. Um dies zu umgehen wird das oben schon erwähnte | + | |
| - | R (Referenziert) Bit verwendet, um jeder Seite eine | + | |
| - | zweite Chance zu geben, falls das R-Bit nicht null ist. | + | |
| - | < | + | |
| - | </ | + | |
| - | Kopfes nachgeschaut, | + | |
| - | Seite nie referenziert, | + | |
| - | FiFo üblich. Wurde sie aber referenziert, | + | |
| - | Ende der Liste verschoben, als wurde sie neu geladen. | + | |
| - | Das R-Bit wird dabei auf Null gesetzt. So wird | + | |
| - | gewährleistet, | + | |
| - | als nicht referenzierte Seiten ausgelagert werden. | + | |
| - | Second Chance ist ein durchaus guter Paging Algorithmus | + | |
| - | mit einem Nachteil. Es müssen ständig konstante Seiten | + | |
| - | innerhalb der Liste von Anfang zum Ende verschoben | + | |
| - | werden. Diesen Nachteil bügelt der Uhr Algorithmus aus. | + | |
| - | < | + | |
| - | </ | + | |
| - | Second Chance, nur das anstelle einer FiFo Liste eine | + | |
| - | < | + | |
| - | einem Pointer (Zeiger der Uhr) auf den aktuellen Anfang | + | |
| - | der Liste gezeigt. Bei einer Second Chance muss nun | + | |
| - | nicht die Seite verschoben werden, es wird einfach der | + | |
| - | Zeiger auf das nächste Element referenziert.< | + | |
| - | Uhr Algorithmus ist also eine Implementation von Second | + | |
| - | Chance mit einer Ringliste. | + | |
| - | < | + | |
| - | Least-Recently-Used? | + | |
| - | versucht den Optimalen zu approximieren, | + | |
| - | versucht die Seiten zu entfernen, welche am Längsten | + | |
| - | nicht mehr benutzt wurden.< | + | |
| - | trotzdem nicht ganz einfach. Es müsste theoretisch eine | + | |
| - | Liste geführt werden, welche nach dem oben genannten | + | |
| - | Kriterium sortiert ist. Diese Liste müsste nach jeder | + | |
| - | Seiteneinlagerung neu Sortiert werden. Da dies eine zu | + | |
| - | komplexe Operation darstellt, muss dafür eine | + | |
| - | Softwarelösung approximiert werden, welche wesentlich | + | |
| - | schneller arbeitet. | + | |
| - | < | + | |
| - | Matrixumsetzung? | + | |
| - | für alle N Seiten geführt. Diese Matrix wird mit 0 | + | |
| - | initialisiert. Wird eine Seite x referenziert, | + | |
| - | die Zeile x auf 1 gesetzt und danach die Spalte x auf 0. | + | |
| - | In jedem Moment ist die Zeile deren Summe am Kleinsten | + | |
| - | ist, die am wenigsten genutzte und die Zeile mit dem | + | |
| - | größten Wert, die am häufigsten genutzte | + | |
| - | Seite.< | + | |
| - | nicht vorhanden ist, muss ein anderer effizienter Paging | + | |
| - | Algorithmus benutzt werden, der ohne jede Hardware | + | |
| - | auskommt. | + | |
| - | < | + | |
| - | Frequently Used? </ | + | |
| - | das < | + | |
| - | einen Softwarezähler, | + | |
| - | wurde, hinzuaddiert. Es wird also versucht < | + | |
| - | zählen</ | + | |
| - | Das Problem von NFU ist es, dass Spitzen in der | + | |
| - | Referenzierung starke Auswirkungen auf den Zähler haben. | + | |
| - | So kann es vorkommen, daß eine Seite, welche anfangs | + | |
| - | stark genutzt wurde und später nicht mehr, einer | + | |
| - | zyklisch genutzten Seite nicht zur Auslagerung | + | |
| - | vorgezogen wird.< | + | |
| - | versucht LRU zu simulieren und diesen Fehler aufzuheben. | + | |
| - | < | + | ==== Modul 6: Dateisysteme |
| - | durch Softwareemulation? | + | Ein Dateisystem |
| - | < | + | |
| - | < | + | |
| - | Zähler um eins nach rechts geschoben< | + | |
| - | < | + | |
| - | stehende Bit addiert </ | + | |
| - | wird auch hier die Seite mit dem kleinsten Fehler | + | |
| - | entfernt. Durch das Rechtsverschieben verkleinert sich | + | |
| - | der Wert eines Zählers rapide und es wird verhindert, | + | |
| - | daß nur kurzeitig verwendete Seiten fälschlicherweiße | + | |
| - | als oft referenziert angesehen werden... < | + | |
| - | <DIV class=HINT> | + | |
| - | < | + | |
| - | < | + | |
| - | Bits - vier Zustände) | + | |
| - | < | + | |
| - | benutzt worden auslagern) und LRU mit Matrixumsetzung | + | |
| - | < | + | |
| - | Uhr-Seitenersetzungsalgorithmus | + | |
| - | < | + | |
| - | < | + | |
| - | in der Translation Table gesucht werden </ | + | |
| - | <DIV align=right>< | + | |
| - | Seitenersetzungsalgorithmen</ | + | |
| - | < | + | |
| - | der Seitenrahmen im Speicher, also mehr Speicher, heißt | + | |
| - | nicht zwangsläufig eine Verringerung von Seitenfehlern! | + | |
| - | < | + | |
| - | mit der Seitenfehlerrate? | + | |
| - | steigt, da die Übertragungszeit für Seiten sinkt. Die | + | |
| - | Anzahl der gleichzeitig ausführbaren Prozesse steigt, da | + | |
| - | jeder Prozeß nun mit weniger Seitenrahmen - und einer | + | |
| - | höheren Fehlerrate - " | + | |
| - | < | + | |
| - | Seitenaustauschverfahren? | + | |
| - | werden eingesetzt und die Zahl der Seitenfehler weiter | + | |
| - | zu minimieren. Ein Prozess unterliegt auch einer Art | + | |
| - | < | + | |
| - | bestimmte Seiten häufiger und Andere sogut wie nie oder | + | |
| - | gar nicht zur Prozessabarbeitung benötigt. Man nennt | + | |
| - | dies < | + | |
| - | Lokalität</ | + | |
| - | versucht Informationen vor dem Laden eines Prozesses | + | |
| - | auszunutzen, | + | |
| - | zu behandeln. Die Erfassung der für das Working Set | + | |
| - | notwendigen Daten wird auch über eine Art Aging | + | |
| - | Algorithmus umgesetzt. Jede Seite gehört zu einem | + | |
| - | bestimmten Working Set. Wird eine Seite länger als N | + | |
| - | Ticks nicht mehr benutzt, wird sie aus dem Working Set | + | |
| - | entfernt.< | + | |
| - | Sets kann verwendet werden, um den < | + | |
| - | Algorithmus</ | + | |
| - | nur nach einer nichtreferenzierten Seite geschaut, | + | |
| - | sondern auch ob die Seite zu einem Working Set gehört | + | |
| - | oder nicht. Falls sie einem Arbeitsbereich angehört, | + | |
| - | wird sie < | + | |
| - | Moment referenziert oder nicht. | + | |
| - | < | + | |
| - | Arbeitsmengenstrategie auf? </ | + | |
| - | die Seitenauslagerung durch Herausfallen von Seiten aus | + | |
| - | dem Working Set. Seiten können aus dem Working Set | + | |
| - | ausgelagert werden, ohne das ein Seitenfehler vorliegt | + | |
| - | und ohne das für diese Seite eine Neue eingelagert | + | |
| - | wurde. Die aktuelle Lokalität wird eben nur | + | |
| - | approximiert. Die Arbeitsmenge enthält möglicherweise | + | |
| - | auch Seiten die nur einmal benutzt wurden. Der Übergang | + | |
| - | zu einer neuen Lokalität erfolgt nur allmählich. | + | |
| - | < | + | |
| - | </ | + | |
| - | (Trashing). Bei Überlastung mit zu vielen Prozessen die | + | |
| - | entweder zu viele Pagefaults produzieren und/oder | + | |
| - | zuwenig Seitenrahmen zur Verfügung haben, ist der | + | |
| - | Rechner weitgehend mit dem Ein-/und Auslagern von Seiten | + | |
| - | beschäftigt und kann an den eigentlichen Aufgaben der | + | |
| - | Prozesse kaum noch weiterarbeiten. Effektive CPU | + | |
| - | Auslastung sinkt durch viele Seitenfehler. Weitere | + | |
| - | Gefahr besteht dann durch zu einfach konstruierte | + | |
| - | Scheduler, die bei sinkender CPU-Auslastung mit einer | + | |
| - | höheren Prozessintensität reagieren. < | + | |
| - | Damons</ | + | |
| - | Prozesse auslagern, wenn nicht mehr ausreichend | + | |
| - | Seitenrahmen im Speicher zur Verfügung stehen. | + | |
| - | < | + | |
| - | </ | + | |
| - | der gleichzeitig aktiven Prozesse verringert und jedem | + | |
| - | Prozeß stehen mehr Seitenrahmen zur Verfügung. | + | |
| - | < | + | |
| - | Seitengröße ist normalerweise klein. Dies hat | + | |
| - | verschiedene Gründe sie klein zu halten, aber auch einen | + | |
| - | wichtigen Grund, die Größe nicht zu klein zu definieren. | + | |
| - | Im Mittel ist die letzte Seite eines Codestückes nur | + | |
| - | < | + | |
| - | jedes Code, Stack oder Datensegment genau in eine Seite | + | |
| - | passen kann oder sich so auf mehrere verteilt, daß kein | + | |
| - | freier Speicher mehr verbleibt. Des Weiteren muss | + | |
| - | beachtet werden, dass es auch viele kleine Segment gibt. | + | |
| - | Angenommen man legt eine Seitengröße von 32 KB fest, so | + | |
| - | werden bei 4 KB großen Segmenten stets 28 KB | + | |
| - | verschwendet. Andersherum benötigt man mit kleinen | + | |
| - | Seiten eine größere Seitentabelle, | + | |
| - | proportional zur Seitengröße ist. Des Weiteren muss man | + | |
| - | einkalkulieren, | + | |
| - | eine langwierige Operation ist. Es ist trivial das das | + | |
| - | Einlagern von vier 8K-Seiten schneller ist, als das | + | |
| - | Einlagern von 64 512 Byte großen Seiten. Es muss also | + | |
| - | ein Mittelweg gefunden werden, welcher einen optimalen | + | |
| - | Nutzen aus den oben genannten Kriterien | + | |
| - | zieht.< | + | |
| - | Seitentabelleneintragsgöße / Seitengröße + Seitengröße / | + | |
| - | 2< | + | |
| - | Ableitung in Abhängigkeit der Seitengröße ergibt | + | |
| - | :</ | + | |
| - | Wurzel aus 2 * Prozessgröße * Seitentabelleneintragsgöße | + | |
| - | </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | Druckerspooler über Ersatz-BM Buffer aufgelöst) | + | |
| - | < | + | |
| - | (Prozess kann weitere BM anfordern) | + | |
| - | < | + | |
| - | können nicht entzogen werden) | + | |
| - | < | + | |
| - | im Betriebsmittelgraph) </ | + | |
| - | < | + | |
| - | </ | + | |
| - | bestehen. | + | |
| - | < | + | |
| - | Betriebsmittel vergeben, es besteht aber keine | + | |
| - | Verhinderung. Das BM könnte irgendwann wieder | + | |
| - | freigegeben werden, aber der Zeitpunkt | + | |
| - | unbekannt.< | + | |
| - | < | + | |
| - | Prozesse verhungern da benachteiligt) | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Sortierung des BM-Graphs oder Vektoren-Matrix | + | |
| - | Variante) | + | |
| - | < | + | |
| - | prüfen) | + | |
| - | < | + | |
| - | Bedingungen eliminieren) </ | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | Betriebsmittel müssten vor Ausführung bekannt sein. Das | + | |
| - | ist aber in einem offenen System nicht möglich. Das | + | |
| - | Prinzip ist das gleiche wie das | + | |
| - | < | + | |
| - | angeforderten Betriebsmittel verfügbar sind, führt der | + | |
| - | Prozess den nächsten Schritt aus. Algorithmisch wäre | + | |
| - | dies durch zyklische Prüfung (für jeden Prozeß) auf | + | |
| - | Vorhandensein der erforderlichen Betriebsmittel | + | |
| - | erreichbar. | + | |
| - | < | + | |
| - | < | + | |
| - | Freigabe der belegten Betriebsmittel. Siehe | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | Betriebsmittelanforderung geprüft werden, ob diese zu | + | |
| - | einem Deadlock führen würde. Da dies sehr aufwendig ist, | + | |
| - | wird so nicht verfahren.< | + | |
| - | 2:</ | + | |
| - | Betriebsmittel werden alle bisher reservierten | + | |
| - | Betriebsmittel freigegeben und dann zusammen mit den | + | |
| - | zusätzlichen Betriebsmitteln erneut angefordert (Form | + | |
| - | von Preclaiming).< | + | |
| - | 3</ | + | |
| - | Priorität angefordert . Falls schon Betriebsmittel | + | |
| - | reserviert sind, können keine Betriebsmittel, | + | |
| - | wichtiger sind als die schon reservierten, | + | |
| - | werden. Damit wird zyklisches Warten unmöglich (ähnelt | + | |
| - | dem 2-Phasen-Sperrprotokoll). Problem ist aber die | + | |
| - | Vergabe geeigneter Nummerierungen, | + | |
| - | abstrakte Betriebsmittel | + | |
| - | Festplatten) sich nur schwer Ordnen | + | |
| - | lassen.< | + | |
| - | Algorithmus als Verfahren zur Erkennung sicherer | + | |
| - | Systemzustände bei der Verteilung von Ressourcen. | + | |
| - | < | + | |
| - | hat einen bestimmte Menge einer Ressource. Jeder Kunde | + | |
| - | hat ein Limit, bis zu dem er Ressourcen vom Banker | + | |
| - | erhalten kann. Der Banker hat aber so viele Ressourcen, | + | |
| - | daß er das größte vorhandene Limit gerade noch bedienen | + | |
| - | kann. Der Kunde bekommt die Ressource, falls der Banker | + | |
| - | danach noch genügend Ressourcen hat, um mindestens einem | + | |
| - | der Kunden sein komplettes Limit zuteilen zu | + | |
| - | können.< | + | |
| - | Bankieralgorithmus</ | + | |
| - | Einheiten eines Betriebsmittels verfügbar. | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <LI>A hat zur Zeit 5 Einheiten belegt | + | |
| - | < | + | |
| - | nun eine weitere Einheit anfordert, so muss dies | + | |
| - | verweigert werden, da dann der Banker nur noch 2 | + | |
| - | Einheiten übrig hätte, diese aber nicht zur Befriedigung | + | |
| - | einer kompletten Reservierung von A oder B ausreichen | + | |
| - | würde und zu einem Deadlock führen würde. Solch ein | + | |
| - | Zustand heißt unsicherer Zustand. Der Problem ist nun, | + | |
| - | daß jeder Prozeß muß im Voraus wissen muss, wieviele | + | |
| - | Einheiten eines Betriebsmittels er maximal während | + | |
| - | seiner Abarbeitung benötigen wird. | + | |
| - | < | + | |
| - | linearer Ordnung der Betriebsmittel? | + | |
| - | können zwar alle Betriebsmittel anfordern, aber alle | + | |
| - | Anforderungen müssen gemäß der Nummerierungsreihenfolge | + | |
| - | geschehen. Somit ist es von vornherein ausgeschlossen, | + | |
| - | daß ein Prozeß der ein Betriebsmittel höherer Ordnung | + | |
| - | besitzt, ein Betriebsmittel niedrigerer Ordnung, das von | + | |
| - | einem anderen Prozeß belegt ist, anfordern kann. Also | + | |
| - | werden Schlingen im Wartegraph und damit Deadlocks | + | |
| - | vermieden, da nun eine notwendige Voraussetzung für | + | |
| - | Deadlocks eliminiert wurde. Umgesetzt kann das Ganze | + | |
| - | durch eine Nummerierung der Betriebsmittel werden. Das | + | |
| - | Prinzip ähnelt dem Zeitstempelverfahren bei DBMS. </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | <TABLE cellSpacing=0 cellPadding=0 width=" | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE class=tutorialtable cellSpacing=0 cellPadding=0 | + | |
| - | border=0> | + | |
| - | < | + | |
| - | <TR vAlign=top> | + | |
| - | <TD class=tutorial vAlign=top align=left> | + | |
| - | < | + | |
| - | <TABLE width=" | + | |
| - | < | + | |
| - | < | + | |
| - | <TD class=inhaltsliste> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | </ | + | |
| - | Besonderem um Verwaltung, Zugriffsoptimierung und die | + | |
| - | Umsetzung einer für den Menschen vereinfacht nutzbaren | + | |
| - | Abstraktion. Der Zugriff auf Daten erfolgt nicht wie | + | |
| - | beim Hauptspeicher Byte-orientiert, | + | |
| - | Effizienzgründen blockweise, da Platten um ein | + | |
| - | vielfaches langsamer als Arbeitspeicher sind. Des | + | |
| - | Weiteren sind bis auf einige Ausnahmen, wie CD ISO9660, | + | |
| - | die meisten Dateisysteme Betriebssystemspezifisch. | + | |
| - | < | + | |
| - | logisches Betriebsmittel, | + | |
| - | zusammengehöriger Daten beinhaltet. Verzeichnisse sind | + | |
| - | spezielle Dateien, welche zur Strukturierung von | + | |
| - | Dateisystemen eingeführt wurden. | + | |
| - | < | + | |
| - | File Systemem gibt es? </ | + | |
| - | < | + | |
| - | < | + | |
| - | angehangen werden soll | + | |
| - | < | + | |
| - | Zugriff extrem langsam | + | |
| - | < | + | |
| - | erlauben schnellen wahlfreien Zugriff (FAT) | + | |
| - | < | + | |
| - | < | + | |
| - | | + | |
| - | und nach linear aufgefüllt. Vorteil dieser Variante ist | + | |
| - | schneller Zugriff. Nachteil ist die extreme externe | + | |
| - | Fragmentierung bei Änderungen von Dateigrößen. | + | |
| - | < | + | |
| - | </ | + | |
| - | Allokation, bieten nur wahlfreien Zugriff und besitzen | + | |
| - | nur geringe Fehlertoleranz. Dafür werden aber nur sehr | + | |
| - | < | + | |
| - | nur Pointer auf den nächsten belegten Block) Eine | + | |
| - | Verbesserung der Effizienz wird durch das Nutzen doppelt | + | |
| - | verketteter Listen erzielt, wobei sich aber auch der | + | |
| - | Zahl der Verwaltungsdaten verdoppelt. | + | |
| - | < | + | |
| - | Zuordnungstabellen </ | + | |
| - | den Zeigern in eine extra Tabelle ausgelagert. Die | + | |
| - | Dateizuordnungstabelle am Bsp. FAT enthält für jeden | + | |
| - | Block einen Eintrag mit einem Verweis auf den Folgeblock | + | |
| - | oder einen bestimmten Eintrag für EOF. Die Effizient | + | |
| - | wird hier bei großen Tabellen eingeschränkt. | + | |
| - | < | + | |
| - | jede Datei wird hier die Startadresse und die Indexlänge | + | |
| - | gemerkt. So ist zwar schneller wahlfreier Zugriff | + | |
| - | möglich, aber es herrscht das gleiche Problem der | + | |
| - | externen Fragmentierung wie bei kontinuierlicher | + | |
| - | Allokation. Die Geschwindigkeitssteigerung gegenüber | + | |
| - | Zuordnungstabellen kommt daher, dass Zusammenhängende | + | |
| - | | + | |
| - | liegen, sondern verstreut in der Tabelle. Die indizierte | + | |
| - | Speicherung führt sogenannte Indexblöcke ein, in welche | + | |
| - | hintereinander | + | |
| - | eingetragen werden. So muss bei einem Zugriff im Worst | + | |
| - | Case nicht die ganze Zuordnungstabelle nach den | + | |
| - | Blocknummern durchsucht werden.< | + | |
| - | nun aber so ein Indexblock gewählt werden? Variable | + | |
| - | längen sind schlecht realisierbar. Wählt man sie zu | + | |
| - | groß, geht Speicher durch interne Fragmentierung | + | |
| - | verloren. Wählt man sie zu klein, beschränkt man die | + | |
| - | Dateigröße... Deshalb wurde die indirekt indizierte | + | |
| - | Speicherung eingeführt. | + | |
| - | < | + | |
| - | </ | + | |
| - | wieder auf einen oder mehrere Blöcke, die nun die | + | |
| - | Verweise auf die wirklichen Datenblöcke enthalten, oder | + | |
| - | wiederrum auf weitere Indexblöcke. (Dreifach Indirekt) | + | |
| - | So ist auch auf große Dateien der Zugriff gewährleistet. | + | |
| - | < | + | **Linux/Unix:** |
| - | | + | Unix nutzt zur Adressierung **INodes |
| - | Die Dateinamen werden in einer extra Tabelle verwaltet, | + | |
| - | welche die Attribute | + | * Er hat 13 Einträge |
| - | direkte Zeiger auf Blockadressen (einfach, doppelt, | + | |
| - | dreifach indirekt) enthält. | + | |
| - | < | + | |
| - | Sie? </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Suchzeit suchen) | + | |
| - | < | + | |
| - | Anderen und bearbeitet Requests) | + | |
| - | < | + | |
| - | wieder auf Anfang zurückgesetzt - kreisförmig) | + | |
| - | < | + | |
| - | notwendig zurückgesetzt) | + | |
| - | < | + | |
| - | < | + | |
| - | Festplattenalgorithmen gibt es? </ | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Rotationsgeschwindigkeiten moderner Platten | + | |
| - | < | + | |
| - | statt äußeren oder inneren Zylindern sein, da dort die | + | |
| - | mittlere Zugriffszeit am kleinsten ist (im | + | |
| - | Durchschnitt befindet sich der Lesekopf in der Mitte) | + | |
| - | </ | + | |
| - | < | + | |
| - | FAT Dateizuordnungstabelle liegt auf den ersten Spuren | + | |
| - | einer Platte. Sie wird aus Sicherheitsgründen oft | + | |
| - | gesichert. Alle Blöcke einer Platte sind über die FAT | + | |
| - | miteinander verkettet (< | + | |
| - | Allokation</ | + | |
| - | ist für eine Partition statisch, kann sich aber zwischen | + | |
| - | den Partitionen unterscheiden (üblich sind 512, 1024 | + | |
| - | oder 4096 Bytes). FAT bietet weder Schutzmechanismen, | + | |
| - | noch unterstützt es lange Dateinamen (erst ab VFAT). | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Baumstruktur. Für jede Datei enthält die | + | |
| - | Dateizuordnungstabelle eine lineare, gezeigerte Liste, | + | |
| - | mit der die Blöcke der Datei bzw. des | + | |
| - | Unterverzeichnisses bestimmt werden können. Der Index | + | |
| - | der Tabelleneinträge stellt die Blocknummer der | + | |
| - | Festplatte dar. | + | |
| - | < | + | |
| - | File System. NTFS ist mit einem | + | |
| - | < | + | |
| - | auch keine Größenbegrenzung mehr. Ein Logfile wird | + | |
| - | verwendet, um nach einem Systemausfall Daten | + | |
| - | rekonstruieren zu können. NTFS besitzt nur Dateien. | + | |
| - | Analog zu den I-Nodes beim Unix gibt es beim NTFS eine | + | |
| - | < | + | |
| - | Datei einen Eintrag besitzt. Zusammenhängende Bereiche | + | |
| - | (extents) werden als < | + | |
| - | organisiert. | + | |
| - | < | + | |
| - | bzw. Verzeichnissen werden alle Attribute (incl. der | + | |
| - | Daten) innerhalb des MFT-Eintrages abgelegt (bis zu 1 | + | |
| - | bis 4 KB). Ein Eintrag in der MFT benötigt einen oder | + | |
| - | mehrere Sätze der MFT (Satzlänge ist konfigurierbar). | + | |
| - | Bei großen Dateien | + | |
| - | Wurzelknoten eines < | + | |
| - | " | + | |
| - | Dateibereiche (Extent oder Lauf) | + | |
| - | enthalten.< | + | |
| - | UNIX-System stellt die MFT ein flaches Dateisystem dar. | + | |
| - | Über die Verzeichnisse wird darauf die bekannte | + | |
| - | Baumstruktur definiert. | + | |
| - | < | + | |
| - | identifiziert? | + | |
| - | < | + | |
| - | Satznummer ihres Eintrages in der | + | |
| - | < | + | |
| - | wird eine Folgenummer (16 Bit) angehängt, die bei jedem | + | |
| - | Bezug auf den MFT-Eintrag (z.B. beim Öffnen der Datei) | + | |
| - | um 1 erhöht wird (für Konsistenzüberprüfungen) | + | |
| - | < | + | |
| - | </ | + | |
| - | der ID-Nummer der Datei bzw. des Unterverzeichnisses, | + | |
| - | einer Kopie der Update-Zeit | + | |
| - | MFT-Eintrag. Verzeichnisse werden nicht wie bei FAT in | + | |
| - | einer linearen Liste verwaltet, sondern als | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Backup | + | |
| - | < | + | |
| - | Wiederherstellen der Daten- bzw. der | + | |
| - | Dateisystemkonsistenz) | + | |
| - | < | + | |
| - | Datenträgers, | + | |
| - | eventuellen Verdacht auf Inkonsistenz | + | |
| - | < | + | |
| - | < | + | |
| - | des Datenträgers | + | |
| - | < | + | |
| - | < | + | |
| - | Cluster enthält </ | + | |
| - | < | + | |
| - | | + | |
| - | gespeichert. Diese Adressen reichen aber nur für kleine | + | |
| - | Dateien aus. Für größere Dateien, welche nicht durch ein | + | |
| - | I-Node adressierbar sind, gibt es Adressen in dem | + | |
| - | I-Node, die die Adresse eines Plattenblockes enthalten, | + | |
| - | welcher weitere Plattenadressen enthält. Dieser Block | + | |
| - | wird "< | + | |
| - | genannt. " | + | |
| - | Blöcke, die ihrerseits eine Reihe von direkten | + | |
| - | Blocknummern enthalten. Beim Zugriff auf Daten über | + | |
| - | einen indirekten Block muß der Kern zuerst diesen | + | |
| - | indirekten Block lesen, den passenden direkten | + | |
| - | Blockeintrag ermitteln und dann diesen Block lesen. Es | + | |
| - | gibt auch Adressen, die auf Blöcke | + | |
| - | Adressen von einfach indirekten Blöcken enthalten. | + | |
| - | Solche " | + | |
| - | indirekter Blocknummern. Blöcke mit dem Kennzeichen | + | |
| - | " | + | |
| - | indirekten Blocknummern u.s.w.< | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | < | + | |
| - | eine eigene Benutzer-Filedecriptor-Tabelle zugeordnet. | + | |
| - | Ruft ein Prozess < | + | |
| - | der Systemkern einen freien Inode aus der Inode-Tabelle | + | |
| - | und übergibt diesen an die globale Dateitabelle und | + | |
| - | erzeugt einen Eintrag in der | + | |
| - | Benutzer-Filedecriptor-Tabelle. | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | und die < | + | |
| - | Prozeß, der die Datei eröffnet hat. Die | + | |
| - | Benutzer-Filedecriptor-Tabellen enthalten dagegen nur | + | |
| - | die geöffneten Dateien eines Prozesses.< | + | |
| - | alt=Dateideskriptoren | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | solcher Dateien. Blockorientierte Spezialdateien und | + | |
| - | | + | |
| - | < | + | |
| - | </ | + | |
| - | Geräte zu modellieren, | + | |
| - | Blöcken bestehen. ( < | + | |
| - | devices</ | + | |
| - | blockorientierte Spezialdatei geöffnet, so kann ein | + | |
| - | Block gelesen werden, ohne daß man sich um die Struktur | + | |
| - | des Dateisystems, | + | |
| - | müssen. | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | hierfür sind Terminals, Drucker, Netzschnittstellen. Ein | + | |
| - | Programm schreibt auf das entsprechende I/O-Gerät, indem | + | |
| - | es in die korrespondierende zeichenorientierte | + | |
| - | Spezialdatei schreibt. Analoges gilt für das Lesen. | + | |
| - | < | + | |
| - | </ | + | |
| - | src=" | + | |
| - | border=0>< | + | |
| - | Sektor einer Partition. Er enthält den Bootstrap-Code, | + | |
| - | der beim Hochfahren eines UNIX-Rechners in den Speicher | + | |
| - | gelesen wird. Er lädt bzw. initialisiert das | + | |
| - | Betriebssystem.< | + | |
| - | beschreibt den < | + | |
| - | Eine Kopie des Superblocks befindet sich permanent im | + | |
| - | Speicher. Der Kern schreibt periodisch den Superblock | + | |
| - | | + | |
| - | Daten im Dateisystem übereinstimmt. Der Superblock | + | |
| - | enthält folgende Felder: | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Liste </ | + | |
| - | < | + | |
| - | < | + | |
| - | Inodes | + | |
| - | < | + | |
| - | </ | + | |
| - | < | + | |
| - | zugreifen? </ | + | |
| - | < | + | |
| - | < | + | |
| - | verborgen wird, heißt Datei. | + | |
| - | < | + | |
| - | Datei-ID die auf eine Datei-Deskriptor-Tabelle | + | |
| - | verweist. | + | |
| - | < | + | |
| - | < | + | |
| - | Tabelle) werden die Adressen der Blöcke ermittelt | + | |
| - | < | + | |
| - | Hauptspeicher | + | |
| - | < | + | |
| - | SSN | + | |
| - | < | + | |
| - | effizienten Positionierungsstrategie | + | |
| - | < | + | |
| - | teilt der Controller dem BS das Ende der Übertragung | + | |
| - | mit. </ | + | |
| - | < | + | |
| - | identifiziert Dateien | + | |
| - | Pfadnamen, indem es durch diesen den dazugehörigen | + | |
| - | I-Node sucht. Jede Datei wird durch einen oder mehrere | + | |
| - | I-Nodes beschrieben. Die I-Nodes enthalten die | + | |
| - | Blockadressen der Datei. Ein Katalog (Verzeichnis) | + | |
| - | enthält alle im Verzeichnis enthaltenen Datei- bzw. | + | |
| - | Verzeichnisnamen und die dazugehörigen | + | |
| - | I-Nodes.< | + | |
| - | < | + | |
| - | < | + | |
| - | betrachtet werden | + | |
| - | < | + | |
| - | < | + | |
| - | auf der Platte | + | |
| - | < | + | |
| - | Wurzelkatalog (auch eine Datei) gesucht | + | |
| - | < | + | |
| - | < | + | |
| - | den Katalog " | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | globale < | + | |
| - | die lokale Deskriptortabelle des Prozesses geladen | + | |
| - | < | + | |
| - | < | + | |
| - | Datei zugreifen kann | + | |
| - | < | + | |
| - | aus der Dateideskriptorliste wieder entfernt. | + | |
| - | </ | + | |
| - | < | + | |
| - | <TD class=desc vAlign=top></ | + | |
| - | < | + | |
| - | < | + | |
| - | <TABLE cellSpacing=1 cellPadding=1 width=500 border=0> | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | < | + | |
| - | Computerarchitektur< | + | |
| - | Betriebssysteme< | + | |
| - | Design< | + | |
| - | Skript und Vorlesung< | + | |
| - | Seiten< | + | |
| - | link | + | |
| - | http:// | + | |
| - | < | + | |
| - | <TD class=pagefooter>& | + | |
| - | < | + | |
| - | < | + | |
| - | <SCRIPT type=text/ | + | |
| - | <SCRIPT type=text/ | + | {{http:// |
| - | <!-- | + | |
| - | <script src=" | + | |
| - | </ | + | |
| - | <script type=" | + | |
| - | _uacct = " | + | |
| - | urchinTracker(); | + | |
| - | </ | + | |
| - | --> | + | |
| - | <SCRIPT language=javascript | + | |
| - | src="http:// | + | |
| - | type=text/ | + | |
| - | <SCRIPT language=javascript | + | **Windows (NTFS):** |
| - | src=" | + | NTFS nutzt eine **Master File Table (MFT)**. |
| - | type=text/ | + | * Jede Datei besitzt hier einen Eintrag. |
| + | * Bei kleinen Dateien werden alle Attribute (inklusive der Daten) direkt innerhalb des MFT-Eintrags abgelegt. | ||
| + | * Bei großen Dateien enthält der Eintrag den Wurzelknoten eines B-Baums, dessen Blätter auf die Dateibereiche (Extents) verweisen. | ||
| - | <SCRIPT language=javascript | + | Um Dateien von mehreren Orten zugänglich zu machen, nutzt man **Links**. Das "symbolic linking" |
| - | src="http://www.kreissl.info/ | + | |
| - | type=text/ | + | |
| - | <SCRIPT language=javascript type=text/ | + | ==== Modul 7: Linux, GNU und die Open-Source-Galaxis (Tag 7) ==== |
| - | dp.SyntaxHighlighter.ClipboardSwf | + | Historisch stammt Unix aus den 1960er Jahren, hervorgegangen aus dem System Multics. Ken Thompson und Dennis Ritchie entwickelten die erste Unix-Version und schufen dafür die Sprache C. |
| - | dp.SyntaxHighlighter.HighlightAll(' | + | |
| - | </ | + | |
| - | </ | + | |
| - | </ | + | |
| + | 1991 initiierte Linus Torvalds den Kernel für Linux. Ein Großteil der grundlegenden Software in Linux (wie C-Compiler oder Shells) stammt aus dem GNU-Projekt. | ||
| + | **Systemvergleich: | ||
| + | * **Linux:** Extrem ressourcenschonend (eine GUI ist optional), sehr sicheres Multiusersystem, | ||
| + | * **macOS X:** Basiert auf einem Unix-Derivat (Darwin/ | ||
| + | * **Windows: | ||
| + | |||
| + | ==== Modul 8: Verteilte Systeme & Cluster (Tag 8) ==== | ||
| + | Ein verteiltes System ist laut Andrew Tanenbaum ein Zusammenschluss unabhängiger Computer, der sich für den Benutzer als ein einzelnes System präsentiert. | ||
| + | Die bekannteste Architektur ist das **Client-Server-Modell**, | ||
| + | |||
| + | Noch spannender sind **Cluster**, | ||
| + | * **HA Cluster (High Availability): | ||
| + | * **HPC Cluster (High Performance Computing): | ||
| + | * **Load Balancing Cluster:** Clientanfragen werden durch einen Loadbalancer an den Serverknoten mit der voraussichtlich besten Performance verteilt. | ||
| + | |||
| + | ==== Modul 9: Grid & Cloud Computing (Tag 9) ==== | ||
| + | Wenn der lokale Rechner nicht reicht, wandern wir ins Netz. | ||
| + | **Grid Computing** vernetzt Tausende einzelner Computer zu einem komplexen System mit enormer Rechenleistung. Es gibt z. B. Computer Grids für Rechenkapazität, | ||
| + | |||
| + | **Cloud Computing** treibt dies auf die Spitze. Dienste werden On-Demand abgerechnet ("pay per use"). Wir unterscheiden: | ||
| + | * **IaaS (Infrastructure as a Service):** Der Anbieter stellt Speicherplatz, | ||
| + | * **PaaS (Platform as a Service):** Bereitstellung einer transparenten Entwicklungsumgebung (z.B. Webserver) zum Testen und Hosten von Apps. | ||
| + | * **SaaS (Software as a Service):** Der Anbieter hostet eine vollständige Software-Applikation; | ||
| + | |||
| + | Die Bereitstellung erfolgt über **Private Clouds** (nur für interne Unternehmenszwecke), | ||
| + | |||
| + | ==== Modul 10: Embedded Systems & Organic Computing (Tag 10) ==== | ||
| + | Betriebssysteme der Zukunft steuern nicht nur Desktop-PCs. | ||
| + | **Embedded Systems** verrichten unsichtbar ihren Dienst in Waschmaschinen, | ||
| + | |||
| + | Die absolute Spitze der Evolution bildet das **Organic Computing**. Systeme werden künftig so komplex, dass sie lebensähnlich (" | ||
| + | * **selbst-konfigurierend** | ||
| + | * **selbst-optimierend** | ||
| + | * **selbst-heilend** | ||
| + | * **selbst-schützend** | ||
| + | |||
| + | Ein "Smart Network" | ||
| + | |||
| + | ---- | ||
| + | //**Quellen & Materialien**// | ||
| + | //Alle Inhalte dieses Kurses basieren auf dem Skript " | ||