BS KE 1

• Ein Computer besteht aus Anwendungsprogrammen, die Nutzer*innen direkt verwenden.

• Anwendungen sind Programme, mit denen Menschen interagieren.

• Die Hardware bleibt im Hintergrund und wird nicht direkt wahrgenommen.

• Das Betriebssystem ist sichtbar, aber die meisten seiner Aufgaben laufen unbemerkt im Hintergrund.

A system is a set of interconnected components that has an expected behavior observed at the

interface with its environment.

• Welche Komponenten hat ein Computer?

• Wie sind die Komponenten organisiert?

• Wie kommunizieren die einzelnen Komponenten

miteinander?

• Welche Schnittstellen werden angeboten?

• Welche Komponenten hat ein Computer?

• Wie sind die Komponenten organisiert?

• Wie kommunizieren die einzelnen Komponenten

miteinander?

• Welche Schnittstellen werden angeboten?

• Die Architektur eines Computersystems ist ein Schichtenmodell.

• Das Betriebssystem liegt zwischen den Anwendungsprogrammen und der Hardware.

• Es bietet den Anwendungen Systemaufrufe als Schnittstelle.

Was sind die Komponenten eines Computersystems und wie kommunizieren sie?

1. Komponenten:

   • Hardware:

     • CPU: Führt Befehle aus.

     • Hauptspeicher: Speichert Befehle und Daten.

     • Ein-/Ausgabe: Geräte wie Tastatur, Bildschirm, Festplatte zur Interaktion.

   • Betriebssystem: Trennt Anwendungen von der Hardware.

   • Anwendungsprogramme: Ermöglichen die Interaktion zwischen Benutzer*innen und Computersystem.

2. Organisation:

   • Die Komponenten sind in Schichten angeordnet.

3. Kommunikation:

   • Jede Schicht kommuniziert nur mit der direkt darunterliegenden Schicht über eine Schnittstelle.

   • Betriebssystem:

     • Stellt Systemaufrufe als Schnittstelle für die Anwendungen bereit.

     • Anwendungen nutzen diese Aufrufe, um mit dem Betriebssystem zu interagieren.

   • Hardware:

     • Bietet dem Betriebssystem die Instruction Set Architecture (ISA), eine Schnittstelle aus Maschinenbefehlen.

• Eine Architektur vereinfacht das Verstehen eines großen und komplexen Systems, indem es auf einer Abstraktionsebene dargestellt wird.

• Sie zeigt auf, wie ein System entwickelt werden soll:

  • Welche Komponenten es gibt.

  • Wie diese zusammengesetzt sind.

  • Wie sie miteinander interagieren.

• Sie trennt die Funktionalität von der Kommunikation der Komponenten.

  • Dadurch kann der Kommunikationsmechanismus leichter angepasst oder verändert werden.

1. Schichtenmodell:

   • Aufgaben werden auf verschiedene Schichten verteilt.

   • Jede Schicht bietet der darüberliegenden Schicht Dienste über eine Schnittstelle an.

2. Abstraktion:

   • Höhere Schichten müssen die Details der darunterliegenden Schichten nicht kennen.

3. Kapselung (Geheimnisprinzip):

   • Obere Schichten dürfen keinen direkten Zugriff auf die Details der unteren Schichten haben.

1. Transparenz:

   • Versteckt Hardware-Details vor Benutzer*innen und Anwendungen.

   • Interaktion mit dem Rechner erfolgt ausschließlich über Anwendungsprogramme.

2. Koordination der Abläufe:

   • BS entscheidet, welche Anwendung als Nächstes von der CPU ausgeführt wird.

3. Ressourcenverwaltung:

   • Kontrolliert die Nutzung der Hardware-Ressourcen wie CPU, Speicher und Ein-/Ausgabegeräte.

• Es wird eine weitere Schicht als Standardbibliothek über den Systemaufrufen eingefügt.

• Standardbibliothek: Sie übersetzt die einzelnen Systemaufrufe so, dass sie auch von Anwendun-

gen unabhängig von Betriebssystemen verwendet werden können.

• Programmierschnittstelle: Bibliotheksfunktionen (Standard Library)

• Jede Funktion ist einem Systemaufruf zugeordnet.

• Die Funktionen sind unabhängig von Betriebssystemen.

• Beispiel:

· Programmiersprache C:

printf("Hallo, Welt!\n");

· Programmiersprache Java:

System.out.print("Hallo, Welt!\n");

• Benutzerschnittstelle: Dienstprogramme (Standard Utility Programs)

• Tools zur Entwicklung von Programmen.

• Tools für den Dialog mit dem Betriebssystem wie z. B. die Shell.

1. Virtualisierung der CPU:

   • Für jedes Programm wird ein virtueller Prozessor erstellt, als ob es die CPU für sich allein hätte.

   • CPU-Zeit wird auf die Prozesse aufgeteilt.

   • Bereitstellung eines CPU-Schedulers mit Scheduling-Strategien zur Verwaltung der Ausführungsreihenfolge.

2. Virtualisierung des Hauptspeichers:

   • Jedes Programm bekommt einen virtuellen Hauptspeicher, als ob es den Hauptspeicher allein hätte.

   • Programme arbeiten mit logischen Adressen, die auf physische Adressen abgebildet werden.

   • Zuteilung und Verwaltung des Hauptspeichers für Prozesse, inklusive virtueller Speicherverwaltung.

3. Virtualisierung des permanenten Speichers:

   • Informationen werden als Dateien dauerhaft gespeichert.

   • Bereitstellung von Dateisystemen und Zugriffsmethoden.

   • Steuerung der Ein-/Ausgabegeräte und Planung der Auftragsbearbeitung, z. B. für Festplatten.

4. Bereitstellung von Schnittstellen:

   • Bereitstellung von Schnittstellen für Anwendungen und Benutzer, um mit dem Betriebssystem zu interagieren.

5. Synchronisierung von Prozessen:

   • Bereitstellung von Mechanismen zur Synchronisierung von Prozessen, um Kollisionen und Inkonsistenzen zu vermeiden.

Das Betriebssystem muss die Kontrolle

über das Computersystem behalten.

• Das Betriebssystem muss immer wieder

aktiviert werden!

• Das Betriebssystem ist eine Software.

• Das Betriebssystem muss immer wieder

die CPU erhalten, um seine verschie-

denen Aufgaben zu erledigen.

• PC = Programmzähler (Program Counter)

• IR = Befehlsregister (Instruction Register)

• MAR = Speicheradressregister (Memory Address Register)

• MBR = Speicherpufferregister (Memory Buffer Register)

• I/O AR = Eingabe/Ausgabe-Adressregister (Input/Output Address Register)

• I/O BR = Eingabe/Ausgabe-Pufferregister (Input/Output Buffer Register)

• PSW = Programmstatuswort

Der Befehlszähler (PC) ist wie der Dirigent eines Orchesters: Er zeigt immer genau dorthin, wo der nächste Takt – oder in diesem Fall der nächste Befehl – im Speicher liegt. Ohne ihn würde das System den Faden verlieren und nicht wissen, was als Nächstes zu tun ist. Er ist das Gedächtnis, das den nächsten Schritt im Programmablauf festhält.

Einfachste Erklärung:

Der Befehlszähler (PC) speichert, wo im Speicher der nächste Befehl liegt, der ausgeführt werden soll.

Befehlszähler (PC): speichert die Spei-

cheradresse des nächsten auszuführen-

den Befehls.

Das Befehlsregister (IR) ist wie das Kurzzeitgedächtnis des Prozessors: Es hält den Befehl fest, der gerade ausgeführt wird. Es ist die Schaltzentrale, die dem Prozessor sagt: „Hey, das hier ist deine aktuelle Aufgabe – los geht’s!“ Ohne das IR würde der Prozessor im Dunkeln tappen und nicht wissen, was er tun soll.

Einfachste Erklärung:

Das Befehlsregister (IR) speichert den Befehl, der gerade ausgeführt wird.

Das Speicheradressregister (MAR) ist wie der Adressfinder des Computers: Es zeigt genau dorthin, wo im Speicher die nächste Aktion – sei es Lesen oder Schreiben – stattfinden soll. Es ist der Wegweiser, der dem System sagt: „Hier entlang, hier passiert’s!“ Ohne das MAR würde der Computer im Speicherchaos versinken und nicht wissen, wo er Daten holen oder ablegen soll.

Einfachste Erklärung:

Das Speicheradressregister (MAR) speichert die Adresse im Speicher, an der die nächste Lese- oder Schreiboperation durchgeführt wird.

Das Speicherinhaltsregister (MBR) ist wie der Bote des Computers: Es transportiert Daten zwischen dem Prozessor und dem Hauptspeicher hin und her. Beim Schreiben packt es die Daten ein und bringt sie an die richtige Stelle im Speicher. Beim Lesen holt es die Daten ab und liefert sie an den Prozessor. Ohne das MBR wäre die Kommunikation zwischen Prozessor und Speicher wie eine Unterhaltung ohne Worte – unmöglich!

Einfachste Erklärung:

Das Speicherinhaltsregister (MBR) speichert Daten, die in den Hauptspeicher geschrieben werden, oder empfängt Daten, die aus dem Hauptspeicher gelesen werden.

Das Programmstatuswort (PSW) ist wie die Kommandozentrale des Prozessors: Es hält alle wichtigen Informationen darüber, was gerade im System passiert. Es entscheidet, ob der Prozessor im Benutzermodus (für normale Aufgaben) oder im Systemmodus (für kritische, privilegierte Befehle) arbeitet. Außerdem regelt es die Interruptpriorität – wie ein Türsteher, der festlegt, welche Unterbrechungen Vorrang haben. Beim Motorola 68000 gibt es beispielsweise 7 Stufen, die bestimmen, welche Aufgabe dringender ist. Ohne das PSW wäre das System ein chaotisches Durcheinander!

Einfachste Erklärung:

Das Programmstatuswort (PSW) speichert:

1. Ob der Prozessor im Benutzermodus oder Systemmodus arbeitet (nur im Systemmodus dürfen privilegierte Befehle ausgeführt werden).

2. Die Priorität von Interrupts (z. B. beim Motorola 68000 gibt es 7 Prioritätsstufen für Unterbrechungen).

• I/O AR (Input/Output Address Register): Dieses Register ist wie der Adressfinder für Ein- und Ausgabegeräte. Es speichert die genaue Adresse, an der Daten mit einem externen Gerät (z. B. einer Tastatur, Festplatte oder einem Drucker) ausgetauscht werden sollen. Es sagt dem System: „Hier musst du hin, um Daten zu senden oder zu empfangen!“

• I/O BR (Input/Output Buffer Register): Dieses Register ist wie der Zwischenspeicher für Ein- und Ausgabedaten. Es hält die Daten bereit, die gerade von oder zu einem Gerät übertragen werden. Beim Schreiben packt es die Daten ein, und beim Lesen empfängt es sie. Es ist der Vermittler zwischen dem Prozessor und den externen Geräten.

Ohne diese Register wäre die Kommunikation mit externen Geräten wie ein Gespräch ohne Worte – unmöglich!

Einfachste Erklärung:

• I/O AR (Input/Output Address Register): Speichert die Adresse für den Datenaustausch mit Ein- und Ausgabegeräten.

• I/O BR (Input/Output Buffer Register): Speichert die Daten, die zwischen dem Prozessor und Ein- und Ausgabegeräten übertragen werden.

Der Systembus ist wie die Autobahn des Computers – er verbindet alle wichtigen Komponenten und sorgt dafür, dass Daten, Adressen und Steuersignale reibungslos fließen. Er besteht aus drei Hauptspuren:

1. Steuerbus: Er ist wie der Verkehrspolizist, der festlegt, in welche Richtung die Daten fließen. Beim Lesen (read) holt die CPU Daten aus dem Hauptspeicher (CPU ⇐= Hauptspeicher), und beim Schreiben (write) sendet die CPU Daten an den Hauptspeicher (CPU =⇒ Hauptspeicher).

2. Adressbus: Er ist wie der Navigationsassistent, der die genaue Adresse der Speicherzelle auswählt, auf die zugegriffen werden soll. Ohne ihn würde die CPU im Speicherchaos verloren gehen.

3. Datenbus: Er ist wie der Lastwagen, der die Daten zwischen der CPU, dem Hauptspeicher und den Ein-/Ausgabegeräten hin- und hertransportiert. Er sorgt dafür, dass die Informationen dort ankommen, wo sie gebraucht werden.

Ohne den Systembus wäre der Computer wie eine Stadt ohne Straßen – alles würde stillstehen!

Einfachste Erklärung:

Der Systembus besteht aus:

1. Steuerbus: Legt fest, ob Daten von der CPU zum Hauptspeicher (write) oder vom Hauptspeicher zur CPU (read) übertragen werden.

2. Adressbus: Wählt die Adresse der Speicherzelle aus, auf die zugegriffen wird.

3. Datenbus: Überträgt Daten zwischen CPU, Hauptspeicher und Ein-/Ausgabegeräten.

Die CPU arbeitet wie ein unermüdlicher Arbeiter, der in einem ständigen Zyklus aus zwei Phasen arbeitet:

1. Holphase: Hier holt die CPU den nächsten Befehl aus dem Hauptspeicher und lädt ihn in das Befehlsregister (IR). Gleichzeitig wird der Befehlszähler (PC) um eins erhöht, um auf den nächsten Befehl vorzubereiten. Es ist, als würde die CPU sagen: „Was steht als Nächstes auf meiner To-do-Liste?“

2. Ausführungsphase: Jetzt wird der Befehl entschlüsselt und ausgeführt. Dabei kann die CPU verschiedene Aufgaben erledigen:

   • Daten austauschen: Daten werden zwischen dem Prozessor und dem Hauptspeicher hin- und hergeschoben (lesen oder schreiben).

   • Ein-/Ausgabe: Daten werden mit externen Geräten wie Tastaturen, Monitoren oder Festplatten ausgetauscht.

   • Datenoperationen: Die CPU führt Berechnungen oder logische Operationen durch, z. B. Additionen oder Vergleiche.

   • Steuerung: Die CPU springt zu anderen Programmteilen, z. B. bei Verzweigungen oder Schleifen.

Ohne diesen Zyklus wäre die CPU wie ein Auto ohne Räder – es würde nirgendwo hingehen!

Einfachste Erklärung:

Die CPU arbeitet in zwei Phasen:

1. Holphase: Der nächste Befehl wird aus dem Hauptspeicher ins Befehlsregister geladen, und der Befehlszähler wird erhöht.

2. Ausführungsphase: Der Befehl wird dekodiert und ausgeführt. Dabei kann die CPU:

   • Daten mit dem Hauptspeicher austauschen (lesen/schreiben),

   • Daten mit Ein-/Ausgabegeräten austauschen,

   • arithmetische oder logische Operationen durchführen,

   • den Programmablauf steuern (z. B. Verzweigungen).

Die CPU mit Unterbrechung arbeitet wie ein multitaskingfähiger Superheld, der nicht nur seine Aufgaben erledigt, sondern auch immer ein Auge auf dringende Notfälle hat. Ihr Arbeitszyklus besteht aus drei Phasen:

1. Holphase: Die CPU holt den nächsten Befehl aus dem Hauptspeicher und lädt ihn ins Befehlsregister (IR). Gleichzeitig wird der Befehlszähler (PC) erhöht, um auf den nächsten Befehl vorzubereiten. Es ist, als würde sie fragen: „Was steht als Nächstes auf meiner Liste?“

2. Ausführungsphase: Der Befehl wird entschlüsselt und ausgeführt. Hier kann die CPU Daten verarbeiten, Berechnungen durchführen oder mit externen Geräten kommunizieren.

3. Unterbrechungsphase: Jetzt wird es spannend! Die CPU prüft, ob es eine Unterbrechung (Interrupt) gibt – wie ein Notruf, der sofortige Aufmerksamkeit erfordert.

   • Falls nein: Die CPU geht einfach zurück zur Holphase und arbeitet weiter.

   • Falls ja: Die CPU rettet den aktuellen Zustand des laufenden Programms (wie ein Schnappschuss) und kümmert sich um die Unterbrechung. Sobald die Störung behoben ist, kehrt sie zum geretteten Programm zurück.

Ohne diese Unterbrechungsphase wäre die CPU wie ein Arbeiter, der keine Notfälle erkennen kann – und das Chaos wäre vorprogrammiert!

Einfachste Erklärung:

Die CPU mit Unterbrechung arbeitet in drei Phasen:

1. Holphase: Der nächste Befehl wird ins Befehlsregister geladen, und der Befehlszähler wird erhöht.

2. Ausführungsphase: Der Befehl wird dekodiert und ausgeführt.

3. Unterbrechungsphase: Die CPU prüft, ob eine Unterbrechung vorliegt:

   • Nein: Zurück zur Holphase.

   • Ja: Der aktuelle Programmzustand wird gespeichert, und die Unterbrechung wird behandelt.

1. Strategie:

   • Ein Betriebssystem ist wie der Dirigent eines Orchesters – es muss die Kontrolle über das gesamte System behalten, um sicherzustellen, dass alle Programme und Prozesse harmonisch zusammenarbeiten.

   • Da es nicht alle Aufgaben gleichzeitig erledigen kann, muss es immer wieder aktiviert werden, um seine Kontrollfunktionen auszuführen. Es ist wie ein Wachhund, der regelmäßig seine Runden dreht, um Ordnung zu bewahren.

2. Mechanismus:

   • Unterbrechungen (Interrupts) sind wie Notrufe, die das Betriebssystem aufwecken, wenn etwas Wichtiges passiert. Egal, ob ein Programm fertig ist, ein Fehler auftritt oder ein Benutzer eine Eingabe macht – die Unterbrechungen sorgen dafür, dass das Betriebssystem sofort aktiv wird und eingreifen kann.

Ohne diese Strategie und diesen Mechanismus wäre das System wie ein Schiff ohne Kapitän – es würde schnell im Chaos versinken!

Einfachste Erklärung:

1. Strategie:

   • Das Betriebssystem muss die Kontrolle über das System behalten.

   • Es muss regelmäßig aktiviert werden, um seine Aufgaben zu erfüllen.

2. Mechanismus:

   • Das Betriebssystem wird durch Unterbrechungen aktiviert, um auf Ereignisse zu reagieren.

1. Unterbrechung: Unterbrechungen sind wie Weckrufe für das Betriebssystem. Sie sorgen dafür, dass das Betriebssystem aktiviert wird, um auf wichtige Ereignisse zu reagieren – sei es eine Benutzereingabe, ein Hardwarefehler oder ein fertiggestellter Prozess. Ohne Unterbrechungen würde das Betriebssystem schlafen und nicht merken, wenn etwas dringend erledigt werden muss.

2. Zeitgeber: Der Zeitgeber ist wie ein Schiedsrichter, der die CPU-Zeit fair aufteilt. Er stellt sicher, dass kein Programm die CPU zu lange blockiert, indem er regelmäßig „Stopp!“ ruft und den nächsten Prozess an die Reihe kommen lässt. So bleibt das System reaktionsfähig und fair.

3. Speicherschutzmechanismen: Diese Mechanismen sind wie Sicherheitswachen, die den Speicher vor unerlaubtem Zugriff schützen. Sie sorgen dafür, dass Programme nur auf ihren eigenen Speicherbereich zugreifen können und nicht versehentlich (oder absichtlich) den Speicher anderer Programme beschädigen.

4. Privilegierte Befehle: Privilegierte Befehle sind wie geheime Werkzeuge, die nur das Betriebssystem im Systemmodus verwenden darf. Im Benutzermodus haben Programme keinen Zugriff darauf, um das System vor Fehlern oder bösartigen Aktionen zu schützen. Es ist, als ob nur der Chef den Safe öffnen darf!

Einfachste Erklärung:

1. Unterbrechung: Aktiviert das Betriebssystem, um auf Ereignisse zu reagieren.

2. Zeitgeber: Teilt die CPU-Zeit fair zwischen den Programmen auf.

3. Speicherschutzmechanismen: Schützen den Speicher vor unerlaubtem Zugriff.

4. Privilegierte Befehle: Können nur im Systemmodus ausgeführt werden, um das System zu schützen.

Eine Hardware-Unterbrechung ist wie ein unerwarteter Anruf mitten in der Arbeit:

• Sie wird durch ein externes Ereignis ausgelöst, z. B. wenn eine Tastatur eine Eingabe macht, eine Maus bewegt wird oder eine Festplatte Daten bereitstellt. Der laufende Prozess hat damit nichts zu tun.

• Sie ist nicht vorhersehbar, da sie jederzeit und ohne Vorwarnung auftreten kann.

• Sie ist nicht reproduzierbar, weil sie nicht vom Prozess abhängt, sondern von externen Faktoren.

• Sie ist eine asynchrone Unterbrechung, da sie den laufenden Prozess zu jedem beliebigen Zeitpunkt unterbrechen kann – egal, was dieser gerade tut.

Stell dir vor, du arbeitest konzentriert an etwas, und plötzlich klingelt das Telefon. Du musst alles liegen lassen, um den Anruf entgegenzunehmen. Genau so funktioniert eine Hardware-Unterbrechung!

Einfachste Erklärung:

Eine Hardware-Unterbrechung:

• Wird durch ein externes Ereignis (z. B. Ein-/Ausgabegeräte) ausgelöst, nicht durch den laufenden Prozess.

• Ist nicht vorhersehbar und nicht reproduzierbar, da sie unabhängig vom Prozess ist.

• Ist eine asynchrone Unterbrechung, die den Prozess zu jedem Zeitpunkt unterbrechen kann.

Eine Software-Unterbrechung ist wie ein Hilferuf eines Programms an das Betriebssystem:

• Sie wird vom laufenden Prozess selbst verursacht, z. B. wenn das Programm einen Systemaufruf macht (z. B. um Daten zu speichern) oder auf einen Fehler stößt (wie eine Division durch Null oder den Zugriff auf eine unerlaubte Speicheradresse).

• Sie ist reproduzierbar, weil sie durch den Programmcode ausgelöst wird – wenn du denselben Code noch einmal ausführst, passiert dieselbe Unterbrechung wieder.

• Sie ist eine synchrone Unterbrechung, weil der Prozess nicht weiterarbeiten kann, bis das Betriebssystem geantwortet hat. Es ist, als ob du bei einer Frage auf die Antwort warten musst, bevor du weitermachen kannst.

Stell dir vor, du arbeitest an einem Projekt und brauchst die Genehmigung deines Chefs, um weiterzumachen. Du musst warten, bis er antwortet – genauso verhält es sich mit einer Software-Unterbrechung!

Einfachste Erklärung:

Eine Software-Unterbrechung:

• Wird vom laufenden Prozess verursacht, z. B. durch Systemaufrufe oder Fehler wie Division durch Null.

• Ist reproduzierbar, da sie durch den Programmcode ausgelöst wird.

• Ist eine synchrone Unterbrechung, weil der Prozess auf eine Antwort des Betriebssystems warten muss, bevor er fortfährt.

Der Interrupt-Controller ist wie der Vermittler zwischen der CPU und den Geräten, die eine Unterbrechung auslösen wollen. Er sorgt dafür, dass die CPU weiß, was los ist, und priorisiert die eingehenden Anfragen. Hier ist, wie das Ganze funktioniert:

Leitungen zwischen CPU und Interrupt-Controller:

1. INT (INTerrupt): Der Interrupt-Controller aktiviert diese Leitung, um der CPU zu sagen: „Hey, ein Gerät braucht deine Aufmerksamkeit!“

2. INTA (INTerrupt Acknowledge): Die CPU antwortet mit einem Bestätigungssignal: „Okay, ich kümmere mich darum!“

3. D0 bis D07: Über diesen Datenbus sendet der Controller die Unterbrechungsnummer an die CPU, damit sie weiß, welches Gerät die Unterbrechung ausgelöst hat.

Register im Interrupt-Controller:

• Interrupt Service Register (ISR): Hier werden die Unterbrechungen gespeichert, die gerade bearbeitet werden. Es ist wie eine To-do-Liste für die CPU.

• Interrupt Mask Register (IMR): Dieses Register entscheidet, welche Unterbrechungen ignoriert werden sollen. Es ist wie ein Filter, der bestimmte Anfragen blockiert.

• Interrupt Request Register (IRR): Hier werden alle eingehenden Unterbrechungsanforderungen gesammelt, wie in einem Wartezimmer.

• Priority Resolver: Dieser entscheidet, welche Unterbrechung die höchste Priorität hat. Die wichtigste Aufgabe wird ausgewählt, ins ISR geschrieben, und die CPU wird über die INT-Leitung informiert.

Ohne den Interrupt-Controller wäre die CPU wie ein überlasteter Empfangschef, der nicht weiß, wer zuerst dran ist!

Einfachste Erklärung:

Der Interrupt-Controller verbindet die CPU mit den Geräten und verwaltet Unterbrechungen:

Leitungen:

1. INT: Signalisiert der CPU, dass eine Unterbrechung vorliegt.

2. INTA: Die CPU bestätigt, dass sie die Unterbrechung behandeln wird.

3. D0 bis D07: Überträgt die Unterbrechungsnummer an die CPU.

Register:

• ISR: Speichert die aktuell bearbeiteten Unterbrechungen.

• IMR: Maskiert bestimmte Unterbrechungen, um sie zu ignorieren.

• IRR: Sammelt alle eingehenden Unterbrechungsanforderungen.

• Priority Resolver: Wählt die Unterbrechung mit der höchsten Priorität aus und informiert die CPU.

  
  

Der Unterbrechungsvektor des Betriebssystems ist wie ein Telefonbuch für Notfälle:

• Es ist eine Tabelle (z. B. als Array implementiert: array[0 .. n – 1] of address), die für jede Unterbrechung die passende „Notrufnummer“ bereithält.

• Jede Unterbrechung hat eine Unterbrechungsnummer, die wie ein Index in der Tabelle funktioniert.

• Die Einträge in der Tabelle sind die Startadressen der Unterbrechungsroutinen – das sind die speziellen Programme, die das Betriebssystem ausführt, um die Unterbrechung zu behandeln.

Wenn also eine Unterbrechung auftritt, schaut das Betriebssystem in die Tabelle, findet die passende Routine und führt sie aus. Es ist, als ob du im Telefonbuch nachschlägst, um den richtigen Experten für ein Problem anzurufen.

Ohne den Unterbrechungsvektor wäre das Betriebssystem wie ein Arzt ohne Patientenakte – es wüsste nicht, was zu tun ist, wenn ein Notfall eintritt!

Einfachste Erklärung:

Der Unterbrechungsvektor ist eine Tabelle, die:

• Als Array (array[0 .. n – 1] of address) implementiert ist.

• Jede Unterbrechung hat eine Unterbrechungsnummer, die als Index in der Tabelle dient.

• Die Einträge sind die Startadressen der Unterbrechungsroutinen, die das Betriebssystem ausführt, um die Unterbrechung zu behandeln.

Der Unterbrechungsvektor ist wie ein Adressbuch im Hauptspeicher, das dem Betriebssystem sagt, wo es die passenden Unterbrechungsroutinen findet. Hier ist, wie es funktioniert:

• Der Unterbrechungsvektor hat eine Startadresse, z. B. 11100000.

• Jede Unterbrechungsroutine hat ihre eigene Startadresse im Hauptspeicher.

• Jede Unterbrechungsnummer ist wie ein Index in diesem Adressbuch. Um die Startadresse der passenden Routine zu finden, rechnet das Betriebssystem: Unterbrechungsnummer + Startadresse des Unterbrechungsvektors.

Beispiel:

• Die Startadresse des Unterbrechungsvektors ist 11100000.

• Die Unterbrechungsnummer ist 00000001 (für Routine 1).

• Die gesuchte Startadresse der Routine liegt also bei: 00000001 + 11100000 = 11100001.

Das Betriebssystem geht zu dieser Adresse, findet dort die Startadresse der Routine und führt sie aus. Es ist, als ob du in einem Telefonbuch nachschlägst: Du suchst den Namen (Unterbrechungsnummer), addierst die Seitenzahl (Startadresse) und findest die Telefonnummer (Startadresse der Routine).

Ohne diesen Mechanismus wäre das Betriebssystem wie ein Botaniker ohne Herbarium – es wüsste nicht, wo es die richtigen Informationen findet!

Einfachste Erklärung:

• Der Unterbrechungsvektor hat eine Startadresse (z. B. 11100000).

• Jede Unterbrechungsroutine hat eine eigene Startadresse im Hauptspeicher.

• Die Unterbrechungsnummer ist ein Index im Unterbrechungsvektor.

• Die Startadresse der Routine wird berechnet durch: Unterbrechungsnummer + Startadresse des Unterbrechungsvektors.

Beispiel:

• Startadresse: 11100000

• Unterbrechungsnummer: 00000001

• Adresse der Routine: 11100000 + 00000001 = 11100001

1. Gerät löst Unterbrechung aus: Ein Gerät, das eine Unterbrechung auslösen möchte, aktiviert die Leitung zum Interrupt-Controller. Es ist, als ob es sagt: „Hey, ich brauche Hilfe!“

2. Interrupt-Controller wählt Priorität aus: Wenn eine oder mehrere Leitungen aktiviert sind, sucht der Interrupt-Controller die Unterbrechung mit der höchsten Priorität aus und sendet ein Signal über die INT-Leitung an die CPU. Es ist, als ob er sagt: „Hier ist der dringendste Fall!“

3. CPU bestätigt die Unterbrechung: Wenn die CPU bereit ist, die Unterbrechung zu bearbeiten, sendet sie eine Bestätigung über die INTA-Leitung zurück. Es ist, als ob sie antwortet: „Okay, ich kümmere mich darum!“

4. Interrupt-Controller sendet Unterbrechungsnummer: Nach der Bestätigung sendet der Interrupt-Controller die Unterbrechungsnummer an die CPU. Diese Nummer sagt der CPU, welches Gerät die Unterbrechung ausgelöst hat.

5. CPU speichert Unterbrechungsnummer: Die CPU speichert die Unterbrechungsnummer provisorisch, um sie später zu verwenden.

6. CPU sichert den Prozesszustand: Die CPU speichert den Befehlszähler, das Programmstatuswort (PSW) und andere Registerinhalte im Systemstapel (einem speziellen Speicherbereich des Betriebssystems). Warum nicht direkt im Prozesskontrollblock (PCB)? Weil der Systemstapel schneller zugänglich ist und die CPU sofort weiterarbeiten kann, ohne den PCB zu verwalten.

7. CPU sucht die Unterbrechungsroutine: Die CPU verwendet die Unterbrechungsnummer als Index im Unterbrechungsvektor, um die Startadresse der Unterbrechungsroutine zu finden. Es ist, als ob sie im Telefonbuch nachschlägt, um die richtige Nummer zu wählen.

Einfachste Erklärung:

1. Ein Gerät aktiviert die Leitung zum Interrupt-Controller.

2. Der Interrupt-Controller wählt die Unterbrechung mit der höchsten Priorität aus und sendet ein Signal über die INT-Leitung an die CPU.

3. Die CPU bestätigt die Unterbrechung über die INTA-Leitung.

4. Der Interrupt-Controller sendet die Unterbrechungsnummer an die CPU.

5. Die CPU speichert die Unterbrechungsnummer provisorisch.

6. Die CPU speichert den Befehlszähler, das PSW und andere Registerinhalte im Systemstapel (nicht im PCB, da der Systemstapel schneller ist).

7. Die CPU verwendet die Unterbrechungsnummer, um im Unterbrechungsvektor die Startadresse der Unterbrechungsroutine zu finden.

1. TRAP-Instruction und Moduswechsel: Wenn ein C-Programm die Bibliotheksfunktion read aufruft, z. B. count = read(fd, buffer, nbytes);, übersetzt der Compiler diesen Aufruf in eine TRAP-Instruction. Diese löst einen Moduswechsel vom Benutzermodus in den Systemmodus aus, damit das Betriebssystem den Systemaufruf ausführen kann. Gleichzeitig werden die Unterbrechungsnummer (für read) und die Parameter (wie fd, buffer, nbytes) in Registern übergeben. Es ist, als ob du einen Notruf absetzt und alle wichtigen Informationen bereithältst.

2. Unterbrechungsvektor und Startadresse: Die CPU verwendet die Unterbrechungsnummer, um im Unterbrechungsvektor nachzuschlagen. Dort findet sie die Startadresse der Unterbrechungsroutine für den Systemaufruf read. Es ist, als ob du im Telefonbuch die Nummer des richtigen Experten für dein Problem findest.

3. Ausführung und Rückkehr: Die CPU führt die Unterbrechungsroutine aus, die den read-Aufruf behandelt. Sobald die Routine fertig ist, kehrt sie zum aufrufenden Programm zurück, und der Prozeduraufruf ist abgeschlossen. Es ist, als ob der Experte dein Problem gelöst hat und du wieder an deiner Arbeit weitermachen kannst.

Einfachste Erklärung:

1. Der Compiler übersetzt den read-Aufruf in eine TRAP-Instruction, um einen Moduswechsel in den Systemmodus zu ermöglichen. Die Unterbrechungsnummer und Parameter werden in Registern übergeben.

2. Die CPU sucht im Unterbrechungsvektor die Startadresse der Unterbrechungsroutine für read.

3. Nach der Ausführung der Routine kehrt der Prozeduraufruf zurück.

1. Trap-Befehl und Unterbrechungsnummer: Der Trap-Befehl ist wie ein Notruf an die CPU. Er veranlasst die CPU, die Unterbrechungsnummer von read provisorisch zu speichern. Diese Nummer sagt der CPU, welcher Systemaufruf ausgeführt werden soll. Es ist, als ob du eine Notiz machst, um dich später daran zu erinnern.

2. CPU sichert den Prozesszustand: Bevor die CPU die Unterbrechung bearbeitet, sichert sie den aktuellen Zustand des Programms. Dazu speichert sie den Befehlszähler, das Programmstatuswort (PSW) und die anderen Registerinhalte auf dem Systemstapel. Das ist wie ein Schnappschuss, um später genau dort weiterzumachen, wo das Programm unterbrochen wurde.

3. Suche im Unterbrechungsvektor: Die CPU verwendet die Unterbrechungsnummer als Index, um im Unterbrechungsvektor nachzuschlagen. Dort findet sie die Anfangsadresse der Unterbrechungsroutine für read. Es ist, als ob du in einem Adressbuch nachschlägst, um die richtige Telefonnummer zu finden.

Einfachste Erklärung:

1. Der Trap-Befehl veranlasst die CPU, die Unterbrechungsnummer von read provisorisch zu speichern.

2. Die CPU speichert den Befehlszähler, das Programmstatuswort (PSW) und andere Registerinhalte auf dem Systemstapel.

3. Die CPU verwendet die Unterbrechungsnummer als Index, um im Unterbrechungsvektor die Startadresse der Unterbrechungsroutine zu finden.

1. Registerinhalte in den PCB speichern: Die Unterbrechungsroutine veranlasst den Dispatcher, alle Registerinhalte vom Systemstapel in den Prozesskontrollblock (PCB) des unterbrochenen Prozesses zu verschieben. Die Routine weiß genau, wo sich der PCB im Hauptspeicher befindet. Das ist wie ein Umzug: Die Daten werden vom temporären Lager (Systemstapel) in ihr neues Zuhause (PCB) gebracht.

2. Ein-/Ausgabeoperationen durchführen: Die Unterbrechungsroutine ruft den Ein-/Ausgabeteil des Betriebssystems auf, um z. B. Daten von einem Gerät abzuholen oder einen Lese-Befehl an ein Gerät zu senden. Es ist, als ob du einen Boten losschickst, um eine wichtige Nachricht zu überbringen oder abzuholen.

3. Scheduler wählt nächsten Prozess aus: Danach wird der Scheduler aufgerufen, um zu entscheiden, welcher Prozess als Nächstes die CPU nutzen darf. Das ist wie ein Schiedsrichter, der festlegt, wer als Nächstes an der Reihe ist.

4. Zurück zum Benutzermodus: Schließlich wird der Befehl return from interrupt ausgeführt. Der Dispatcher stellt alle Registerinhalte des ausgewählten Prozesses wieder her, und die CPU wechselt vom Systemmodus zurück in den Benutzermodus. Es ist, als ob du nach einer Pause genau dort weitermachst, wo du aufgehört hast.

Einfachste Erklärung:

1. Die Unterbrechungsroutine sorgt dafür, dass der Dispatcher alle Registerinhalte vom Systemstapel in den PCB des Prozesses speichert.

2. Die Routine ruft den Ein-/Ausgabeteil des Betriebssystems auf, um Ein-/Ausgabeoperationen durchzuführen.

3. Der Scheduler wird aufgerufen, um den nächsten Prozess auszuwählen, der die CPU nutzen darf.

4. Der Befehl return from interrupt stellt die Registerinhalte des ausgewählten Prozesses wieder her, und die CPU wechselt zurück in den Benutzermodus.

Das Betriebssystem ist wie ein Zauberer, der die Illusion erzeugt, dass mehrere Programme gleichzeitig laufen. Diese Quasiparallelität wird durch die Virtualisierung der CPU erreicht. Jedes Programm denkt, es hätte die CPU ganz für sich allein – aber in Wirklichkeit teilt sich die CPU die Zeit zwischen allen Programmen auf.

Wie funktioniert das?

1. Prozess-Abstraktion: Das Betriebssystem bietet die grundlegende Abstraktion namens Prozess. Jeder Prozess ist wie ein eigenes kleines Universum, das denkt, es hätte die CPU ganz für sich.

2. Mechanismen auf Betriebssystem-Ebene:

   • CPU-Scheduler: Der Scheduler ist wie ein Schiedsrichter, der entscheidet, welcher Prozess als Nächstes die CPU nutzen darf.

   • Scheduling-Strategien: Das sind die Regeln, nach denen der Scheduler arbeitet, z. B. „Jeder Prozess bekommt gleich viel Zeit“ (Round-Robin) oder „Der Wichtigste zuerst“ (Prioritätsbasiert).

3. Mechanismen auf Hardware-Ebene:

   • Timer-Unterbrechung: Ein Timer sorgt dafür, dass die CPU regelmäßig unterbrochen wird. Das ist wie ein Wecker, der sagt: „Stopp! Jetzt ist ein anderer Prozess dran!“ Ohne den Timer könnte ein Prozess die CPU blockieren und alle anderen warten lassen.

Durch diese Mechanismen entsteht die Illusion, dass alle Programme gleichzeitig laufen – obwohl die CPU eigentlich nur zwischen ihnen hin- und herspringt.

Einfachste Erklärung:

Das Betriebssystem erzeugt die Illusion, dass mehrere Programme gleichzeitig laufen (Quasiparallelität). Dafür nutzt es:

1. Prozess-Abstraktion: Jeder Prozess denkt, er hätte die CPU ganz für sich.

2. CPU-Scheduler: Entscheidet, welcher Prozess als Nächstes die CPU nutzt.

3. Scheduling-Strategien: Regeln für die Auswahl des nächsten Prozesses.

4. Timer-Unterbrechung: Unterbricht die CPU regelmäßig, um Prozesse fair zu behandeln.

Ein Prozess ist wie ein Programm in Aktion – es ist nicht nur das Rezept, sondern das tatsächliche Backen des Kuchens. Hier ist die Analogie:

• Das Programm: Das ist das Rezept. Es enthält alle Anweisungen, die nötig sind, um den Kuchen zu backen, aber es ist nur eine Beschreibung – noch keine Tat.

• Die CPU: Das ist der Mensch, der den Kuchen backt. Die CPU führt die Anweisungen des Programms aus, genau wie der Mensch die Schritte des Rezepts befolgt.

• Der Prozess: Das ist der Backvorgang selbst. Es ist die aktive Ausführung des Rezepts, bei der Zutaten vermischt, der Ofen aufgeheizt und der Kuchen gebacken wird.

Ohne den Prozess wäre das Programm nur ein Stück Papier – und ohne die CPU wäre das Rezept nur eine Idee. Erst durch die Ausführung wird das Programm lebendig!

Einfachste Erklärung:

• Programm: Das Rezept.

• CPU: Der Mensch, der backt.

• Prozess: Der Backvorgang.

Ein Prozess ist ein Programm in Ausführung.

Jeder Prozess bekommt seinen eigenen Adressraum, der in zwei Teile aufgeteilt ist: den Benutzer-Adressraum und den Kern-Adressraum.

Benutzer-Adressraum:

• Programmsegment: Hier liegt der ausführbare Programmcode – das ist wie das Skript, das der Prozess abarbeitet.

• Datensegment: Hier werden die zu bearbeitenden Daten gespeichert – das sind die Zutaten, die der Prozess für seine Arbeit benötigt.

• Stack: Der Stack ist wie ein Notizblock, der Parameter, lokale Variablen und Rücksprungadressen bei Prozeduraufrufen speichert. Er hilft dem Prozess, den Überblick zu behalten, wenn er zwischen verschiedenen Aufgaben hin- und herspringt.

Kern-Adressraum:

• Hier wird der Prozesskontext gespeichert, der im Prozesskontrollblock (PCB) verwaltet wird. Der PCB ist wie die Personalakte des Prozesses und enthält:

  • Prozessidentifikation: Die Prozessnummer, die den Prozess eindeutig identifiziert.

  • Prozessstatus: Die Registerinhalte, insbesondere den Befehlszähler, der zeigt, wo der Prozess in seiner Ausführung steht.

  • Prozesskontrollinformation:

    • Die Grenzen des Adressraums, die festlegen, wie viel Speicher der Prozess nutzen darf.

    • Der Prozesszustand, z. B. ob er gerade läuft, wartet oder beendet ist.

    • Die Priorität für die Planung durch den Scheduler.

Ohne diese Aufteilung wäre der Prozess wie ein Schauspieler ohne Bühne – er hätte keinen Platz, um seine Arbeit zu erledigen!

Einfachste Erklärung:

Jeder Prozess hat einen Adressraum, der in zwei Teile aufgeteilt ist:

Benutzer-Adressraum:

• Programmsegment: Enthält den ausführbaren Code.

• Datensegment: Enthält die zu bearbeitenden Daten.

• Stack: Speichert Parameter, lokale Variablen und Rücksprungadressen.

Kern-Adressraum:

• Enthält den Prozesskontext, gespeichert im Prozesskontrollblock (PCB):

  • Prozessidentifikation: Prozessnummer.

  • Prozessstatus: Registerinhalte, z. B. Befehlszähler.

  • Prozesskontrollinformation: Adressraumgrenzen, Prozesszustand, Priorität usw.

Das Betriebssystem verwaltet alle Prozesse in einer Prozesstabelle. Diese Tabelle ist wie ein Adressbuch, das dem Betriebssystem hilft, schnell auf die Informationen eines Prozesses zuzugreifen.

• Prozessnummer als Index: Jeder Prozess hat eine Prozessnummer, die wie ein Index in der Tabelle funktioniert. Es ist, als ob jeder Prozess eine eigene Seitenzahl im Adressbuch hätte.

• Startadresse des PCBs: Jeder Eintrag in der Tabelle enthält die Startadresse des Prozesskontrollblocks (PCB). Der PCB ist wie die Personalakte des Prozesses und enthält alle wichtigen Informationen über ihn.

• Beispiel: Angenommen, die Prozesstabelle beginnt bei der Adresse 00100000. Um den PCB des Prozesses mit der Nummer 1 zu finden, rechnet das Betriebssystem: Prozessnummer + Startadresse der Tabelle = Adresse des PCB-Eintrags. Also: 00000001 + 00100000 = 00100001.

Das Betriebssystem geht zu dieser Adresse, findet dort die Startadresse des PCBs und kann so auf alle Informationen des Prozesses zugreifen. Es ist, als ob du im Adressbuch nachschlägst, um die Telefonnummer einer Person zu finden.

Einfachste Erklärung:

• Das Betriebssystem hat eine Prozesstabelle.

• Jeder Eintrag enthält die Startadresse des PCBs eines Prozesses.

• Die Prozessnummer wird als Index verwendet, um die Startadresse des PCBs zu finden.

• Beispiel:

  • Startadresse der Tabelle: 00100000

  • Prozessnummer: 1

  • Adresse des PCB-Eintrags: 00000001 + 00100000 = 00100001

Nicht-präemptiv vs. präemptiv:

• Nicht-präemptiv: Hier geben die Prozesse die CPU freiwillig zurück, z. B. wenn sie auf eine Ein-/Ausgabeoperation warten. Es ist, als ob ein Arbeiter sagt: „Ich bin fertig, jetzt ist jemand anderes dran.“

• Präemptiv: Hier entzieht das System einem Prozess die CPU, auch wenn er noch nicht fertig ist. Das ist wie ein Schiedsrichter, der sagt: „Stopp! Deine Zeit ist um, jetzt ist ein anderer dran.“

Scheduler:

Der Scheduler ist wie ein Veranstaltungsplaner. Er wählt den nächsten bereiten Prozess aus, der die CPU nutzen darf, und teilt ihm ein Zeitquantum (Zeitscheibe) zu. Es ist, als ob er sagt: „Du bekommst 5 Minuten auf der Bühne, dann ist der Nächste dran.“

Dispatcher:

Der Dispatcher ist wie ein Assistent, der hinter den Kulissen arbeitet. Er sichert den Zustand des aktuellen Prozesses, fügt ihn in die Warteschlangen (bereit oder blockiert) ein und stellt den ausgewählten Prozess wieder her. Außerdem setzt er den Timerzähler neu, um das nächste Zeitquantum zu starten. Es ist, als ob er die Bühne für den nächsten Auftritt vorbereitet.

Timer (Zeitgeber):

Der Timer ist wie ein Countdown. Er zählt rückwärts und erzeugt eine Unterbrechung, wenn er 0 erreicht. Diese Unterbrechung sorgt dafür, dass der Scheduler den nächsten Prozess auswählen kann. Es ist, als ob ein Wecker klingelt und sagt: „Zeit ist um!“

Einfachste Erklärung:

• Nicht-präemptiv: Prozesse geben die CPU freiwillig zurück.

• Präemptiv: Das System entzieht einem Prozess die CPU.

• Scheduler: Wählt den nächsten Prozess aus und teilt ein Zeitquantum zu.

• Dispatcher:

  • Sichert Prozesse und fügt sie in Warteschlangen ein.

  • Stellt den ausgewählten Prozess wieder her.

  • Setzt den Timerzähler.

• Timer: Zählt rückwärts und erzeugt eine Unterbrechung bei 0.

Ein Prozesswechsel ist wie ein Szenenwechsel im Theater: Alles muss sorgfältig vorbereitet werden, damit die nächste Szene nahtlos beginnen kann. Hier sind die Aufgaben im Detail:

1. Sichern des aktuellen Prozesses: Der Zustand des bisher rechnenden Prozesses wird in seinen Prozesskontrollblock (PCB) gespeichert. Das ist wie ein Schnappschuss, der alles festhält – von den Registerinhalten bis zum Befehlszähler.

2. Einfügen in die Warteschlange: Der PCB wird in die entsprechende Warteschlange eingefügt – entweder bereit (wenn der Prozess weiterlaufen kann) oder blockiert (wenn er auf etwas warten muss, z. B. auf eine Ein-/Ausgabeoperation).

3. Unterbrechung behandeln: Die Unterbrechung, die den Prozesswechsel ausgelöst hat, wird behandelt. Das ist wie das Lösen eines Problems, das den Wechsel notwendig gemacht hat.

4. Nächsten Prozess auswählen: Der Scheduler wählt den nächsten Prozess aus, der die CPU nutzen darf. Es ist, als ob der Regisseur den nächsten Schauspieler auf die Bühne ruft.

5. Return from interrupt: Der Befehl return from interrupt wird ausgeführt:

   • Der alte Zustand des ausgewählten Prozesses wird wiederhergestellt.

   • Die CPU wechselt z. B. vom Systemmodus zurück in den Benutzermodus.

Danach setzt der ausgewählte Prozess genau dort fort, wo er unterbrochen wurde – als ob nichts passiert wäre. Es ist, als ob der Schauspieler genau an der Stelle weitermacht, an der er aufgehört hat.

Einfachste Erklärung:

1. Der Zustand des aktuellen Prozesses wird im PCB gesichert.

2. Der PCB wird in die Warteschlange (bereit oder blockiert) eingefügt.

3. Die Unterbrechung, die den Wechsel verursacht hat, wird behandelt.

4. Der Scheduler wählt den nächsten Prozess aus.

5. Der Befehl return from interrupt wird ausgeführt:

   • Der alte Zustand des Prozesses wird wiederhergestellt.

   • Die CPU wechselt z. B. vom Systemmodus in den Benutzermodus.

Danach setzt der Prozess seine Ausführung genau dort fort, wo er unterbrochen wurde.

Der CPU-Scheduler ist wie ein Schiedsrichter, der entscheidet, welcher Prozess als Nächstes die CPU nutzen darf. Dabei gibt es viele Scheduling-Strategien, die unterschiedliche Ziele verfolgen. Hier sind die wichtigsten Kriterien:

1. Gute Prozessorauslastung: Die CPU soll möglichst wenig Leerlauf haben. Es ist, als ob ein Arbeiter immer beschäftigt sein soll, ohne lange Pausen.

2. Bevorzugung interaktiver Prozesse: Prozesse, die oft Ein-/Ausgabeoperationen durchführen (z. B. Benutzeranwendungen), sollen bevorzugt werden, damit sie schnelle Antwortzeiten liefern. Es ist, als ob ein Kellner den Gästen schnell antwortet, damit sie nicht lange warten müssen.

3. Fairness: Kein Prozess darf „verhungern“, d. h., jeder Prozess soll irgendwann die CPU nutzen dürfen. Es ist, als ob jeder Schüler im Unterricht mal dran kommt.

4. Effizienz: Der Scheduling-Prozess selbst soll wenig Zeit und Ressourcen verbrauchen. Es ist, als ob der Schiedsrichter schnell und ohne viel Aufwand entscheidet, wer als Nächstes spielen darf.

Einfachste Erklärung:

Der CPU-Scheduler wählt den nächsten Prozess aus, der die CPU nutzen darf. Dabei gelten folgende Kriterien:

1. Gute Prozessorauslastung: Die CPU soll wenig Leerlauf haben.

2. Bevorzugung interaktiver Prozesse: Schnelle Antwortzeiten für Ein-/Ausgabe-intensive Prozesse.

3. Fairness: Kein Prozess darf verhungern.

4. Effizienz: Der Scheduling-Prozess soll wenig Zeit und Ressourcen verbrauchen.

First-Come, First-Served (FCFS):

• Prozesse werden in der Reihenfolge ihrer Ankunft abgearbeitet.

• Vorteile: Fair, einfach zu implementieren.

• Nachteile: Nicht geeignet für interaktive Prozesse.

Shortest Job First (SJF):

• Der Prozess mit der kürzesten Bearbeitungszeit bekommt die CPU.

• Vorteile: Minimiert Wartezeit, einfach zu implementieren (wenn Bearbeitungszeit bekannt ist).

• Nachteile: Starvation möglich.

Feste Priorität:

• Der Prozess mit der höchsten Priorität bekommt die CPU.

• Vorteile: Wichtige Prozesse werden bevorzugt, interaktive Prozesse profitieren, einfach zu implementieren.

• Nachteile: Starvation möglich.

Die CPU kommuniziert nicht direkt mit Geräten, sondern über Controller.

Ein Gerät besteht aus drei Teilen, die wie ein Team zusammenarbeiten:

1. Gerätetreiber:

   • Der Gerätetreiber ist die geräteabhängige Software, die oft im Betriebssystemkern sitzt. Er ist wie der Manager, der das Gerät steuert und überwacht.

   • Aufgaben:

     • Initialisierung: Beim Systemstart wird das Gerät initialisiert und überwacht.

     • Auftragsverwaltung: Der Treiber entnimmt einen Auftrag aus der E/A-Auftragsliste und sendet die Befehle an den Controller.

     • Datenübergabe: Die vom Controller gelieferten Daten werden an die geräteunabhängige E/A-Software des Betriebssystems weitergegeben.

2. Controller:

   • Der Controller ist die elektronische Hardware, die die Befehle des Treibers ausführt. Er enthält oft einen Chip, der die eigentliche Steuerung übernimmt. Er ist wie der Techniker, der die Anweisungen des Managers umsetzt.

3. Gerät:

   • Das Gerät selbst ist die elektro-mechanische Hardware, die die eigentliche Arbeit verrichtet, z. B. Daten lesen oder schreiben. Es ist wie die Maschine, die die Befehle des Technikers ausführt.

Ohne diese drei Teile wäre ein Gerät wie ein Orchester ohne Dirigent, Techniker und Instrumente – es würde einfach nicht funktionieren!

Einfachste Erklärung:

Ein Gerät besteht aus drei Teilen:

1. Gerätetreiber:

   • Geräteabhängige Software im Betriebssystemkern.

   • Aufgaben: Initialisierung, Auftragsverwaltung, Datenübergabe.

2. Controller:

   • Elektronische Hardware mit einem Steuerchip.

3. Gerät:

   • Elektro-mechanische Hardware, die die Arbeit ausführt.

Ein Controller ist wie ein Vermittler zwischen dem Betriebssystem und dem Gerät. Um die Kommunikation zu ermöglichen, hat er meistens einen Puffer und vier Register:

1. Data-out-Register:

   • Hier werden Daten vom Treiber an den Controller gesendet. Es ist wie ein Briefkasten, in den das Betriebssystem seine Anweisungen wirft.

2. Data-in-Register:

   • Hier werden Daten vom Controller an den Treiber zurückgesendet. Es ist wie ein Antwortbrief, den der Controller an das Betriebssystem schickt.

3. Status-Register:

   • Dieses Register enthält den aktuellen Status des Controllers. Es ist wie ein Statusbericht, der dem Treiber sagt, ob alles in Ordnung ist oder ob es Probleme gibt.

4. Control-Register:

   • Hier werden Befehle vom Treiber an den Controller gesendet. Es ist wie ein Steuerpult, mit dem das Betriebssystem den Controller steuert.

Puffer:

• Der Puffer ist wie eine Zwischenstation für Daten. Bevor Daten (z. B. ein Block auf der Festplatte) in den Hauptspeicher übertragen werden, landen sie zuerst im Puffer. Dort werden sie auf Fehler überprüft. Nur fehlerfreie Daten werden in den Hauptspeicher geschrieben. Es ist, als ob ein Paket erst auf Schäden überprüft wird, bevor es zugestellt wird.

Einfachste Erklärung:

Ein Controller hat:

1. Data-out-Register: Daten vom Treiber an den Controller.

2. Data-in-Register: Daten vom Controller an den Treiber.

3. Status-Register: Status des Controllers für den Treiber.

4. Control-Register: Befehle vom Treiber an den Controller.

Puffer:

• Daten werden im Puffer zwischengespeichert und auf Fehler überprüft, bevor sie in den Hauptspeicher geschrieben werden.

Die CPU spricht direkt mit dem Controller über den I/O-Adressbus. Jedes Register im Controller hat eine spezielle Adresse – die sogenannte Portnummer.

• Lesen (IN REG, PORT): Die CPU fordert Daten vom Controller an, indem sie eine bestimmte Portnummer angibt. Die Daten aus dem Controller-Register werden dann in ein CPU-Register übertragen.

• Schreiben (OUT PORT, REG): Die CPU sendet Daten an den Controller, indem sie den Wert eines CPU-Registers an eine bestimmte Portnummer übermittelt.

So steuert die CPU den Datenfluss und kommuniziert mit externen Geräten!

Einfache Erklärung:

Die CPU und der Controller tauschen Daten über den I/O-Adressbus aus.

• Mit "IN REG, PORT" holt sich die CPU Daten vom Controller.

• Mit "OUT PORT, REG" sendet die CPU Daten an den Controller.

Dabei gibt die Portnummer an, wohin die Daten gehen oder wo sie herkommen.

Bei der speicherabbildeten Ein-/Ausgabe (Memory-Mapped I/O) werden bestimmte Speicherbereiche im Hauptspeicher für Ein- und Ausgabegeräte reserviert.

• Ab einer bestimmten Speicheradresse (z. B. x + 1) sind keine normalen Daten, sondern die Register der Controller eingeblendet.

• Die CPU kann mit diesen Geräten genauso arbeiten wie mit normalem Speicher – indem sie einfach an diese speziellen Adressen schreibt oder von ihnen liest.

Dadurch verschmelzen Arbeitsspeicher und I/O-Zugriffe zu einem einheitlichen Adressraum!

Einfache Erklärung:

Bestimmte Bereiche des Arbeitsspeichers sind für Ein- und Ausgabegeräte reserviert.

• Die Register der Controller befinden sich an festen Speicheradressen.

• Die CPU kann diese Geräte steuern, indem sie Daten an diese Adressen schreibt oder von dort liest.