DavidS/zusammenfassungen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
David Schirrmeister
2024-12-05 13:53:10 +01:00
parent 2339530e42
commit 73e1392286
57 changed files with 7 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
Writerside/topics/02/BS/03_Betriebssysteme_heute.md Normal file
View File

@ -0,0 +1,29 @@
# Betriebssysteme heute
## Einsatzgebiete
- Desktop / Laptop
- Heim- und Büroanwendungen
- Eingebettete Systeme
- Industrieautomation, Fahrzeuge, etc.
- Mobilgeräte
- Smartphones, Tablets, etc.
- Server
- Datacenter, Großrechner, Cloud- / Grid-Computing
## Vielfältige Peripherie
- WLAN, Bluetooth, 3G/5G/5G
- CD, DVD, HDD, SSD, Flash-Memory, USB-Storage
- LCD-/OLED-Displays, Touchscreens
- Keyboard, Mouse, Touchpad
- Drucker, Scanner
- GPS
- Gyroskop
- ...
## Schnittstellen
Zur Vereinfachung der Programmierung existieren spezielle vom Betriebssystem bereitgestellte Funktionen (Systemaufrufe) bspw. für:
- Prozesse
- Dateisystem
- Ein-/Ausgabe
- ...
Standardisierung ([POSIX](06_prozessstruktur.md#posix-api) ermöglicht Portierung von Anwendungen über Plattform-Grenzen hinweg

75
Writerside/topics/02/BS/04_Betriebssystemkerne.md Normal file
View File

@ -0,0 +1,75 @@
# Betriebssystemkerne
> Gute **Architektur** sagt und _warum_ etwas getan wurde.
> Nicht _wie_ und nicht _wann_ und _wer_.
## Der Betriebssystemkern
- Enthält grundlegende Funktionen des Betriebssystems
- Systemaufrufe
- Benutzerverwaltung
- Prozessverwaltung inklusive Ausführungsreihenfolge ([Scheduling](06_prozessstruktur.md#zeitliche-ausf-hrung-von-prozessen))
- Interprozesskommunikation
- Prozessumschalter ([Dispatcher](06_prozessstruktur.md#zeitliche-ausf-hrung-von-prozessen))
- Gerätetreiber
- [Speicherverwaltung](06_prozessstruktur.md#prozesse-im-speicher)
- Dateisysteme zur Verwaltung von Dateien auf Speicherlaufwerken
- Ist die Schnittstelle zur Hardware des Computers
- Funktionalitäten im BS-Kern haben vollen Hardwarezugriff
- Funktionalitäten laufen als Prozess im Adressraum des Kerns
- Funktionalitäten müssen nicht zwingend im Kern positioniert sein, sie können auch über Dienste bereitgestellt werden (Architektur)
## Übersicht Betriebssystem
![image_17.png](image_17.png)
### Betriebssystemkern
- Der **Kernel-Bereich** ist privilegiert
### Die Anwendungsschicht
- Der **User-Bereich** ist nicht privilegiert, kann aber darauf aufbauende Funktionalitäten bereitstellen
- Zugriff auf die Hardware erfolgt alleinig durch die im _Kernel_ bereitgestellten Funktionalitäten (System-Calls)
## Kernarten
### Monolitische Kerne
Ein Monolith enthält alle Funktionalitäten eines Betriebssystems
| Pro | Con |
|-------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------|
| Bessere **Ausführungsgeschwindigkeit** da weniger _Prozesswechsel_ notwendig sind | Abgestürzte Komponenten des Kerns können nicht separat neu gestartet werden -> können das gesamte BS zum Absturz bringen |
| Durch jahrelange Entwicklungstätigkeit ist eine gewachsene **Stabilität** vorhanden | |
### Minimale Kerne (Microkernel)
Hier befinden sich nur die nötigsten Funktionen im Kernel
| Pro | Con |
|--------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------|
| Alle weiteren Funktionalitäten laufen als _Dienste_ bzw. _Server_ im User-Modus | Abgestürzte Komponenten des Kerns können nicht separat neu gestartet werden -> können das gesamte BS zum Absturz bringen |
| Ausgelagerte Funktionalitäten sind leichter austauschbar, bietet bessere _Stabilität_ und _Sicherheit_ | |
### Hybride Kerne
Enthalten Komponenten, die, aus Geschwindigkeitsgründen, zusätzlich in den Kernel aufgenommen werden
| Pro | Con |
|-------------------------------------------|-----------------------------------------------------------------------------------------------------------------|
| höhere Geschwindigkeit als minimale Kerne | keine klare Definition, was in den Kernel integiert wird |
| höhere Stabilität als monolithische Kerne | Systeme differieren stark -> kann zu einer fehlenden Unterstützung der Hardware- und Software-Hersteller führen |
### Vergleich monolithischer Kern / minimaler Kern
![image_18.png](image_18.png)
## Alternative Architekturen
_Flaschenhals_ alle bestehenden Systeme liegt in ihren Schichtenmodellen
- Anwendung hat _keinen direkten Zugriff auf Hardware_
- _Kommunikation und Datenfluss_ wird über Bibliotheken und deren Kernel abgewickelt
- _Zugangskontrolle_ weiterhin über Bibliotheken und Kernel
## Programmierschnittstellen
**Systemaufruf (System Call)** ist eine API, die es ermöglicht auf Dienste und Ressourcen des BS zuzugreifen
- Implementierung von Systemaufrufen hängt stark von _Hardware_, _Architektur_, _BS_ ab
- ![image_19.png](image_19.png)
- Wann werden die benutzt?
- Berechtigungen, Ressourcenverwaltung, Kommunikation mit Hardware, Prozesssteuerung, Netzwerkkommunikation, Zeitverwaltung
- Nutzung eines direkten Systemaufrufs **nicht empfehlenswert**
- Software ist schlecht portierbar
- Auf Funktionen von Bibliotheken zurückgreifen
- befinden sich mit entsprechenden Wrapper-Funktionen logisch zwischen Benutzer- und BS-Kern

65
Writerside/topics/02/BS/05_prozesszustaende.md Normal file
View File

@ -0,0 +1,65 @@
# Prozesszustände
- Bereit (Ready)
- Laufend (Running)
- Blockiert (Blocked)
- Beendet (Terminated)
## 2-Zustands-Modell
![image.png](image.png)
Prozesse, die untätig werden, werden in einer Warteschlange gespeichert
- Wird nach Priorität / Wartezeit sortiert
![image_1.png](image_1.png)
#### Pro
- Einfach realisierbar
#### Contra
- Annahme, dass Prozesse jederzeit zur Ausführung bereit sind
- Es gibt blockierte Prozesse
- Wartet auf Ein-/Ausgabe
- Wartet auf Ergebnis eines anderen Prozesses
- Wartet auf Reaktion eines Benutzers
## 3-Zustands-Modell
### Ereignisbezogene Warteschlangen
![image_3.png](image_3.png)
- Für jedes Ereignis, auf welches ein Prozess wartet, gibt es eine Warteschlange
- Tritt das Ereignis ein, werden alle Prozesse der WS in die WS mit den *ready* Prozessen überführt
![image_2.png](image_2.png)
## 5-Zustands-Modell
Anzahl der ausführbaren Prozesse *limitieren*, um Speicher zu sparen
- Zwei weitere Zustände:
- **new (new)**
- Prozesse, deren PCB das Betriebssystem bereits erzeugt hat, aber noch nicht in der Warteschlange sind
- **beendet (exit)**
- Abgearbeitete oder abgebrochene Prozesse, deren PCB und Eintrag noch nicht aus der Prozesstabelle entfernt wurden
![image_4.png](image_4.png)
## 6-Zustands-Modell
Falls nicht genügend physischer Hauptspeicher für alle Prozesse:
- **Auslagerungsspeicher (Swap)**
- Zustand: **suspendiert (suspended)**
- dadurch steht den Prozessen in den Zuständen _rechnend_ und _bereit_ mehr Hauptspeicher zur Verfügung
![image_5.png](image_5.png)
## 7-Zustands-Modell
![image_6.png](image_6.png)
## Zustands-Modell von Linux
- ähnlich wie [7-Zustands-Modell](#7-zustands-modell)
- Zustand _rechnend_:
- **benutzer rechnend (user running)**
- Prozesse im Benutzermodus
- **kernel rechnend (kernel running)**
- Prozesse im Kernel-Modus
- Zustand _beendet (exit)_ = _Zombie_
- ist fertig abgearbeitet
- Eintrag in der Prozesstabelle existiert noch bis Elternprozess den Rückgabewert abgefragt hat#
![image_7.png](image_7.png)

75
Writerside/topics/02/BS/06_prozessstruktur.md Normal file
View File

@ -0,0 +1,75 @@
# Prozessstruktur
## Prozessdarstellung
- Umfasst [_Zustände_](05_prozesszustaende.md) und _Struktur_ eines laufenden Programms
- Grundlegende Komponenten, die die _Speicherrepräsentation_ eines Prozesses vorhanden sein können
- Systemumgebung
- Stack
- Heap
- BSS (Block Started by Symbol)
- Datensegment
- Codesegment
- ![image_8.png](image_8.png)
Beispiel: Terminalbefehl **- size**
- ![image_9.png](image_9.png)
## Prozesse im Speicher
- ![image_10.png](image_10.png)
- Ablage im physischen Speicher erfolgt in nicht fortlaufender Weise durch den virtuellen Speicher
- nicht zwangsläufig ständig im Hauptspeicher
## Erzeugung von Prozesskopien
- Systemaufruf **fork** unter Linux/Unix
- Erzeugung einer _identischen Kopie_ eines Prozesses
- aufrufender Prozess: _Elternprozess (Parent Process)_
- neuer Prozess: _Kind-Prozess_ (Child Process)
- hat gleichen _Programmcode_ und _Befehlszähler_
- verweist auf gleiche Zeile im Programmcode
- Speicherbereiche von Kind- und Elternprozess streng getrennt
- ![image_11.png](image_11.png)
## Erzeugung von neuen Prozessen
- Systemaufruf **exec**
- Ersetzt bestehenden Prozess durch einen anderen
- neuer Prozess erbt PID des aufrufenden Prozesses
- ![image_12.png](image_12.png)
- Soll aus einem Prozess (_bspw. Kommandozeilen-Interpreter (Shell)_) heraus ein Programm gestartet werden:
- _fork_ -> _exec_
- ![image_13.png](image_13.png)
## Übersicht Erzeugung/Verkettung/Vergabelung
![image_14.png](image_14.png)
## Beenden von Prozessen
Arten des Beendens:
- Normales Beenden (freiwillig, im Code definiert)
- Beenden aufgrund eines Fehlers (freiwillig, im Code definiert)
- Beenden aufgrund eines schwerwiegenden Fehlers (unfreiwillig, durch BS)
- Beenden durch einen anderen Prozess (unfreiwillig)
Unix Befehl: **kill** erstellt einen Wrapper um BS-Aufruf _kilL()_
- ist auf jedem Unix als alleinstehende Anwendung vorhanden (_/bin/kill_)
## Zeitliche Ausführung von Prozessen
- **Scheduler** ist wichtige Komponente des Betriebssystems
- Zuständig für Zuweisung von CPU-Ressourcen an laufenden Prozessen
- Hauptaufgabe: _Reihenfolge_ festlegen
- **Dispatcher**: Umsetzung der Scheduling-Entscheidungen
- Implementierung der Entscheidung
- Wechsel des _Kontrollflusses_ von einem laufenden Prozess zu einem anderen
- Einleiten des Umschaltens durch einen _Timer-Interrupt_
- Interrupt wird periodisch ausgelöst und startet entsprechende Softwareroutine
- ![image_15.png](image_15.png)
- ![image_16.png](image_16.png)
## POSIX-API
_Portable Operating System Interface_
- Standard, der von der IEE(_Institute of Electrical and Electronics Engineers_) entwickelt wurde
- Definiert Schnittstelle zwischen Anwendung und Betriebssystem
- erleichtert Portabilität von Software zwischen verschiedenen Unix BS
- bspw:
- fork, wait/waitpid, sleep, getpid/getppid/setpgid, execl/execv/execve, kill, ...

161
Writerside/topics/02/BS/07_Prozesssynchronisation.md Normal file
View File

@ -0,0 +1,161 @@
# Prozesssynchronisation
## Warum überhaupt Synchronisation?
- mehrere Prozesse arbeiten in einem System koordiniert und in einer bestimmten Reihenfolge/zeitlichen Abfolge
- Multitasking- /Multiprozessor-System
- mehrere Prozesse gleichzeitig / parallel
- Prozesse interagieren miteinander
- Zugriff auf gemeinsame Ressourcen
- Warten auf Operationen (_Wait and Signal_)
- Kritischer Abschnitt (_Critical Section_)
- Rennbedingungen (_Race Conditions_)
- Mutex (_Mutex Lock_)
- Semaphore
- Deadlocks und Ressourcenkonflikte
- Interprozesskommunikation (_IPC_)
## Signale
- dienen als Mechanismus für die Kommunikation
- zwischen Prozessen
- zwischen Betriebssystem und Prozessen
- Signal ist eine Benachrichtigung and ein Prozess, dass Ereignis aufgetreten ist
### Zweck
- Behandlung von Ausnahmen
- Kommunikation von Ereignissen
- Steuerung von Prozessen
- Ermöglicht
- Implementierung von asynchronen Benachrichtigungen
- Behandlung von außergewöhnlichen Ereignissen
### Beispiel
Terminalbefehl **- man signal**
![image_83.png](image_83.png)
### Signalhandler
- Funktion/Codeabschnitt, welcher _onSignal_ ausgeführt wird
#### Was passiert beim Aufruf eines Signalhandlers
- Prozess wird bei Eintreffen eines Signals angehalten
- Prozesszustand wird gesichert
- Signalhandler wird aufgerufen
- darf beliebige Systemaufrufe veranlassen (_sollte sie aber nicht_)
- Bei Beendigung des Signalhandlers
- Prozess läuft weiter wo er unterbrochen wurde
## Warten
### Aktives Warten (Polling)
- Prozess prüft ob Bedingung erfüllt ist
- _bspw. in Schleifenstrukturen_
```c++
while (!Bedingung){
//aktives Warten
}
```
### Passives Warten
- Prozess wird in Wartezustand versetzt
- wird reaktiviert, wenn Bedingung erfüllt wurde
- währenddessen können andere Prozesse auf der CPU laufen
```c++
wait_for_condition(); //Prozess geht in Wartezustand
//Irgendwann Reaktivierung
resume_execution();
```
## Sperren
- Koordiniert Zugriff auf gemeinsame Ressourcen durch mehrere Prozesse oder Threads
- Nur ein Prozess/Thread gleichzeitig
- Dateninkonsistenzen oder Rennbedingungen werden vermieden
## Mutex (Mutual Exclusion)
- Sperre, welche exklusiven Zugriff auf Ressource steuert
- Prozess sperrt/entsperrt vor/nach Zugriff auf Ressource
### Nutzung
- Dateizugriffe
- Netzwerkkommunikation
- Zugriff auf gemeinsam genutzte Datenstrukturen
- Hardware
## Semaphores
- Ähnlich wie Mutex, nur zusätzlich mit Kommunikation durch [Signale](#signale)
## Mutex vs Semaphore
Befehle mit [POSIX API](06_prozessstruktur.md#posix-api)
### Mutex
- **pthread_mutex_t** _Datentyp für Mutex_
- **pthread_mutex_init** _Erzeugen eines Mutexobjekts_
- **pthread_mutex_unlock** _Entsperren_
- **pthread_mutex_lock** _Sperren_
- **pthread_mutex_trylock** _Versuchendes Sperren_
- **pthread_mutex_destroy** _Löschen des Mutexobjekts_
### Semaphore
- **sem_t** _Datentyp für Semaphor_
- **sem_init** _Initialisieren eines Semaphors (notwendig)_
- **sem_post** _up Operation: Semaphor um 1 erhöhen_
- **sem_wait** _down Operation: Semaphor um 1 vermindern oder blockieren_
- **sem_trywait** _wie sem_wait, aber Aufruf kehrt zurück, falls sem_wait blockieren würde_
- **sem_timedwait** _wie sem_wait, aber mit time-out, falls blockiert_
- **sem_getvalue** _Wert des Semaphors auslesen_
- **sem_destroy** _Löschen eines Semaphors_
### Was nimmt man jetzt?
> Hängt von Anforderungen und Charakteristiken des spezifischen Anwendungsfalls ab
>
> Es ist wichtig, Synchronisationsmechanismen sorgfältig zu verwenden,
> um sicherzustellen, dass kritische Abschnitte effizient und sicher koordiniert werden
- **Praktisches Anwendungsbeispiel: Siehe Praktikum 4**
- Postverteilungszentrum bestückt Verteiler der Post
- Konfliktsituationen:
- wer wird jetzt grad bestückt?
- wie viele kann man gleichzeitig bedienen?
- Wann ist ein Verteiler voll?
- Welcher Postbote darf zuerst an den Briefkasten dran?
- Mutex - Briefkasten freigegeben / gesperrt
- Muss geklingelt werden (bspw. Einschreiben)
- Semaphore - weil es muss benachrichtigt werden
## Deadlock
(Stillstand / Blockade) ist eine Situation, bei der zwei oder mehr Prozesse auf unbestimmte Weise blockiert sind, weil sie auf die Freigabe von Ressourcen warten
### Entstehungsbedingungen von Deadlocks
- **Gegenseitiger Ausschluss**
- Mindestens eine Ressource muss exklusiv für immer nur einen Prozess sein
- **Warte-Zustand**
- Prozess hält eine Ressource und wartet bis er die nächste kriegt
- **Nicht-Preemption**
- Ressourcen können nicht zwangsweise (_sondern nur freiwillig_) von Prozess/Thread entzogen werden
- **Zyklus in den Wartebeziehungen**
- Kette von Prozessen/Threads
- P1 wartet auf Ressource von P2, P2 auf P3, ..., PN auf P1
### Erkennung von Deadlocks
_Betriebsmittelgraf_ (Ressource Allocation Graph)
- Modelliert _Zuteilung und Freigabe_ von Ressourcen zwischen Prozessen
![image_84.png](image_84.png)
- Falls es mehrere Instanzen einer Ressource gibt
- **matrizen-basiertes Verfahren**
- Ressourcenvektor
- Belegungsmatrix
- Anforderungsmatrix
- Ressourcenrestvektor
#### Beispiel Erkennung von Deadlocks
![image_85.png](image_85.png)
![image_86.png](image_86.png)
### Livelock
- Form der Blockierung von 2 oder mehr Prozessen, welche aber ständig zwischen mehreren Zuständen wechseln und ihnen nicht entkommen können
- Bspw.:
- 2 Personen kommen sich auf dem Gang entgegen und weichen die ganze Zeit in die gleiche Richtung aus
- Deadlock:
- Personen stehen gegenüber und warten bis der andere beiseite geht, was nicht passiert

73
Writerside/topics/02/BS/08_Threads.md Normal file
View File

@ -0,0 +1,73 @@
# Threads
- **Kleinste ausführbare Einheit** innerhalb eines Prozesses
- ermöglichen **flexiblere**, **reaktionsschnellere** und **effizientere** Programmierung
- müssen sorgfältig überwacht werden, um Probleme zu vermeiden
- bspw. [Deadlocks](07_Prozesssynchronisation.md#deadlock) oder Rennbedingungen
## Threads vs Prozesse
| **Merkmal** | **Thread** | **Prozess** |
|-------------------------------------------------|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
| Definition | Kleinste ausführbare Einheit innerhalb eines Prozesses | Unabhängiges Programm in Ausführung |
| Ressourcenzuweisung | Teilen denselben Adressraum & Ressourcen innerhalb eines Prozesses | Haben eigenen Adressraum und separate Ressourcen |
| Kommunikation | direkter Zugriff auf gemeinsame Daten<br/>erfordert synchronisierte Mechanismen | erfordert aufwändige Mechanismen wie [IPC](09_Interprozesskommunikation.md) |
| [Synchronisation](07_Prozesssynchronisation.md) | benötigt Synchronisationsmechanismen um Rennbedingungen zu vermeiden | Isoliert voneinander, weniger Rennbedingungen,<br/>aber schwerere Synchronisation zwischen Prozessen |
| Overhead | **geringerer Overhead** | höherer Overhead, da separate Adressräume und Ressourcen |
| Ressourcennutzung | **effiziente Nutzung innerhalb desselben Prozesses** | höherer Ressourcenverbrauch aufgrund separater Adressräume |
| Erstellung und Terminierung | **schnellere Erstellung und Terminierung**<br/>Terminierung beeinflusst nur den spezifischen Thread | Langsamere Erstellung und Terminierung<br/>Beenden eines Prozesses beendet alle seine Threads |
| Fehlerisolierung | Scheitern eines Threads kann gesamten Prozess beeinträchtigen | **Isoliert**, Scheitern beeinflusst keine anderen Prozesse |
- Thread wird auch als _Aktivitätsträger_ oder _leichtgewichtiger Prozess_ benannt
- ist immer Teil eines Prozesses
- Prozess kan viele Threads gleichzeitig enthalten
- werden unabhängig voneinander (_ähnlich Prozesse_) abgearbeitet
- Prozess besteht bei Erzeugung aus einem Thread
- wird impliziert mit dem Prozess erzeugt
| **Thread** | **Prozess** |
|-----------------------------------------|-------------------------------------|
| Leichter Prozess | Programm in Ausführung |
| Gehört zu Prozess | Vollständig isoliert |
| gemeinsamer Speicher | eigener Speicher |
| geringer Ressourcenverbrauch | hoher Ressourcenverbrauch |
| niedriger Zeitbedarf bei Kontextwechsel | hoher Zeitbedarf bei Kontextwechsel |
> Abarbeitung von Threads ist ca. 10-100 mal schneller im Vergleich zur Verarbeitung
> von Prozessen.
>
> Threads nutzen den gleichen Adressraum, was die Kommunikation erleichtert
## Erzeugung von neuen Threads
- Sehr einfach
- Code eines Threads ist eine **normal definierte Funktion**, die wieder andere Funktionen aufrufen kann
- werden von Systemaufrufen gestartet
- Systemaufruf bekommt die Threadfunktion als Parameter übergeben
## Threads implementieren
- Threads sind i.d.R. im Kern implementiert, ähnlich wie Prozesse
- Threads haben dieselben Zustände wie Prozesse, Bedeutung der Zustände ist identisch
- Kann in vielen Programmiersprachen und Systemen realisiert werden
- bspw. _C, C++, C#, Java, Python, Swift, ..._
### Befehle mit [POSIX API](06_prozessstruktur.md#posix-api)
- **pthread_create** - Erzeugen eines Threads
- **pthread_exit** - Beenden eines Threads
- **pthread_join** - Warten auf Ende eines Threads
- **pthread_yield** - Aufgaben der CPU
## Fork-Join-Modell
- Paradigma für die parallele Programmierung
- Erstellen von Threads (**fork**) und Zusammenführen von Threads (**join**)
- wird gerne in rekursiven Algorithmen verwendet
- große Aufgabe kann in kleinere Teilaufgaben zerlegt werden
- Jeder Thread kann sich auf eine Teilaufgabe konzentrieren
- Ergebnisse werden die Ergebnisse kombiniert
![image_157.png](image_157.png)
## FORK
> Durch den Aufruf der Funktion **fork()** in einem Programm werden Threads ebenso wie der
> gesamte Adressraum des Prozesses kopiert
>
> Es entsteht eine exakte Kopie des aufrufenden Prozesses, einschließlich aller Threads und deren Zustände

151
Writerside/topics/02/BS/09_Interprozesskommunikation.md Normal file
View File

@ -0,0 +1,151 @@
# Interprozesskommunikation (IPC)
- Mechanismen und Techniken, die es Prozessen ermöglichen miteinander zu kommunizieren
- auf demselben Computer / über ein Netzwerk hinweg
- Ist grundsätzlich wichtig, wenn Prozesse
- zusammenarbeiten
- Daten austauschen
- miteinander interagieren
- Wahl der Methodik hängt von Anforderung der Anwendung ab
- Effizienz
- Datenvolumen
- Sicherheit
- Komplexität
## Synchrone IPC
- Prozess, bei dem der Absender eines [Signals](07_Prozesssynchronisation.md#signale)/Nachricht auf eine Bestätigung oder eine Antwort vom Empfänger wartet
- stellt sicher, dass
- Absender und Empfänger synchronisiert sind
- Ereignisse/Aufgaben sind abgeschlossen bevor andere anfangen
- ![image_158.png](image_158.png)
## Asynchrone IPC
- Prozesse, bei dem der Absender nicht auf sofortige Antwort wartet
- Absender setzt Ausführung fort, während Empfänger verarbeitet und ggf. später antwortet
- ![image_159.png](image_159.png)
## Mechanismen
- [Shared Memory](#shared-memory)
- [Dateien](#dateien)
- [Message Queues](#message-queues)
- [Pipes](#pipes)
- [Promises (Futures)](#promises-futures)
- [Sockets](#sockets)
- [Semaphoren](07_Prozesssynchronisation.md#semaphores)
- [Mutexe](07_Prozesssynchronisation.md#mutex-mutual-exclusion)
- [Condition Variables](#condition-variables)
- [Remote Procedure Call (RPC)](#remote-procedure-call-rpc)
### Shared Memory
- ermöglicht mehreren Prozessen auf denselben _physischen Speicherbereich_ zuzugreifen
- Austausch von Daten effizient ohne explizite Kommunikation
- Speicherbereich wird im RAM erstellt
- Kann von beteiligten Systemen gelesen und beschrieben werden
- müssen sich selbst koordinieren
#### Linux-Systemaufrufe Shared Memory
- **shmget** - Segment erzeugen oder auf bestehendes Zugreifen
- **shmat** - Segment an anderen Prozess anhängen
- **shmdt** - Segment von Prozess lösen/freigeben
- **shmctl** - Status eines Segments abfragen/ändern/löschen
### Dateien
- Prozesse können auf gemeinsame Dateien zugreifen
- Zugriff kann langsamer als andere [IPC-Mechanismen](#mechanismen) sein
- Darauf muss man achten:
- Zugriffsrechte korrekt setzen um Sicherheit zu gewährleisten
- geeignete [Synchronisationsmechanismen](07_Prozesssynchronisation.md#mutex-vs-semaphore) nutzen
### Message Queues
- besonders nützlich, wenn strukturierte Daten zwischen Prozessen ausgetauscht werden
- Struktur muss zwischen Prozessen vereinbart werden
- Verwendung von [Semaphoren](07_Prozesssynchronisation.md#semaphores) kann erforderlich sein, damit Zugriff auf Queue ordnungsgemäß funktioniert
#### Linux-Systemaufrufe Message Queues
- **msgget** - MQ erzeugen / auf bestehende zugreifen
- **msgsnd** - Nachricht in MQ schicken
- **msgrcv** - Nachricht aus MQ empfangen
- **msgctl** - Status einer MQ abfragen/ändern/löschen
### Pipes
- ermöglichen, dass Output eines Prozesses direkt als Input eines anderen Prozesses dient
- sind unidirektional
- gibt Möglichkeiten 2 Pipes zu erstellen → bidirektionale Kommunikation
- haben begrenzte Puffergröße
- zu viele Daten in der Pipe
- blockieren des Schreibprozesses
- arbeiten nach FIFO Prinzip (_First In First Out_)
#### Erstellung von Pipes mit [POSIX API](06_prozessstruktur.md#posix-api)
- **pipe** - Pipe mit zwei Endpunkten erzeugen
- **popen** - Prozess starten (benutzt [fork](08_Threads.md#fork)) und Pipe zum Prozess öffnen
- **pclose** - Mit popen geöffnete Pipe schließen
- **mkfifo** - Named Pipe erzeugen
- **open** - Named Pipe öffnen
- **close** - (Named) Pipe schließen
- **read** - aus (Named) Pipe lesen
- **write** - in (Named) Pipe schreiben
#### Pipes in der Shell
- werden verwendet um 2 oder mehr Befehle zu kombinieren
- Ausgabe eines Befehls fungiert als Eingabe für anderen Befehl
- Ausgabe dessen = Eingabe für den nächsten ...
- Kann temporäre Verbindung zwischen 2 oder mehr Befehlen/Programmen/Prozessen sein
- _Filter_
- Kommandozeilenprogramme, die weitere Verarbeitung übernehmen
- "I" - anonyme Pipe
- bspw. _ps ax | less_
- ">" - benannte Pipe
- bspw. _mkfifo myPipe ls > myPipe_
### Promises (Futures)
- Konzept für _asynchrone Programmierung_
- Programm wartet auf Ergebnis/Rückmeldung einer asynchronen Operation
- blockiert dabei NICHT Haupt-Thread
- Wird oft verwendet in
- _JavaScript, Python, Frameworks wie Javas CompletableFuture_
- ![image_160.png](image_160.png)
### Sockets
- Verwendung geeignet, wenn
- Kommunikation zwischen verschiedenen Rechnern erforderlich ist
- verbindungsorientierte Kommunikation (_bspw. TCP_) erwünscht ist
- Falls über Internet
- Sicherheitsaspekte müssen berücksichtigt werden
- bspw. Verschlüsselung
#### Erstellung von Sockets mit [POSIX API](06_prozessstruktur.md#posix-api)
- **socket** - Socket erzeugen
- **socketpair** - Zwei Sockets erzeugen, ähnlich [pipe](#pipes)
- **read, recv** - Aus Socket lesen
- **write, send** - In Socket schreiben
- **close** - Socket schließen
- **select** - warten auf Socketaktivität
- **poll** - warten auf Socketaktivität
- _send_ und _recv_ können beliebig lange dauern
- können Prozesse/Threads blockieren
→ Einsetzen von _select_
- Dient als [Multiplexer](MU0Rechner.md#multiplexer) für mehrere Sockets (_File-Descriptors: fdts_)
[![How one thread listens to many sockets with select in C](http://i3.ytimg.com/vi/Y6pFtgRdUts/hqdefault.jpg)](https://www.youtube.com/watch?v=Y6pFtgRdUts)
### Condition Variables
- Dienen Synchronisation von Threads in einem Multithreading-Kontext
- Threads werden informiert, dass Bedingung erfüllt / Ressource verfügbar ist
- Normalerweise auf Threads innerhalb desselben Prozesses beschränkt
- nicht direkt für IPC zwischen verschiedenen Prozessen nutzbar
### Remote Procedure Call (RPC)
- Programm kann Funktion/Prozedur auf einem entfernten Rechner/Adressraum ausführen, als wäre sie lokal vorhanden
- abstrahiert Netzwerkkommunikation
- ermöglicht Entwicklern sich auf Logik ihrer eigenen Anwendungen zu konzentrieren
- Verschiedene Implementierungen von TPC existieren für verschiedene Plattformen / Programmiersprachen

145
Writerside/topics/02/BS/10_Scheduling.md Normal file
View File

@ -0,0 +1,145 @@
# Scheduling
Prozess, wie das Betriebssystem die Ausführung von Aufgaben (Prozessen, Threads, ...) plant und verwaltet
- Hauptziel: Effiziente Nutzung der Systems
- Erfüllung der Anforderungen des Systems und des Benutzers
- Kritisches Element im BS-Design
- direkter Einfluss auf Leistung, Benutzererfahrung
## Aufgaben eines Schedulers
- **Prozessorzuweisung**
- welcher Prozess als nächstes?
- **Prozessorwechsel**
- Wechsel von einem laufenden Prozess zu einem anderen
- **Prioritätszuweisung**
- Bestimmt Priorität von Prozessen → wichtige Aufgaben werden bevorzugt behandelt
- **Warteschlangenmanagement**
- Verwaltung der Warteschlangen mit Prozessen
## Entscheidungsverfahren
- **CPU-Auslastung**
- Maximierung der CPU-Auslastung
- **Durchsatz**
- Anzahl abgeschlossene Aufgaben pro Zeit
- **Wartezeit**
- Minimierung der Wartezeit der Prozesse in der Warteschlange
- **Umlaufzeit**
- Gesamtzeit die ein Prozess benötigt um abgeschlossen zu werden
- **Antwortzeit**
- Zeit zwischen der Anforderung eines Benutzers und der ersten Reaktion des Systems
## Nicht präemptives Scheduling
- Art von Prozessorscheduling beo dem der laufende Prozess nicht unterbrochen werden kann
- bis CPU-Zeitscheibe vollständig oder andere Blockierungsbedingung
- Eingesetz in
- einfache Systeme, Batch-Verarbeitung-Umgebungen
- Vorhersagbarkeit, einfache Implementierung wichtiger als schnelle Reaktion auf Benutzerinteraktion
## Präemptives Scheduling
- Betriebssystemkern kann Kontrolle über CPU von einem laufenden Prozess übernehmen
- kann anderem Prozess CPU-Zeit zuweisen, _falls best. Bedingungen erfüllt_
## Prioritätengesteuertes Scheduling
- Ausführungsreihenfolge der Prozesse hängt von deren Priorität ab
- Jeder Prozess kriegt bestimmte Prio
- Scheduler nimmt Prozess mit höchster Prio
- es gibt präemptive und nicht präemptive Ansätze
- Wird in Echtzeitsystemen und vielen anderen verwendet
- wichtige oder zeitkritische Aufgaben werden bevorzugt behandelt
## Zeitscheiben-Scheduling
- spezielle Form des [präemptiven Schedulings](#pr-emptives-scheduling)
- Jeder Prozess wird für eine festgelegte Zeitscheibe auf dem Prozessor ausgeführt
- sobald abgelaufen → nächster Prozess
- wiederholt sich zyklisch
- Wird verwendet in
- _Mehrbenutzersystemen_
## Weitere Scheduling-Strategien
- First Come First Served
- Shortest / Longest Process next
- Shortest / Longest Remaining Time next
- Highest Response Ratio next
- Earliest Deadline next
- [Fair-Share-Scheduling](#scheduling-unter-linux)
- Multilevel-Scheduling
- ...
## Scheduling unter Linux
![image_161.png](image_161.png)
[![Youtube: Linux Completely Fair Scheduler](http://i3.ytimg.com/vi/2UYuWWX3SMc/hqdefault.jpg)](https://www.youtube.com/watch?v=2UYuWWX3SMc)
### Completely Fair Scheduler (CFS)
- faire Verteilung der CPU-Ressourcen zwischen verschiedenen Prozessen oder Threads
- erstmals in Linux im Kernel 2.6.23
- Bemühung **bessere Leistung** und **Gerechtigkeit** bei Verteilung von Ressourcen in Mehrbenutzersystemen
- Implementierungen und genutzte Algorithmen können variieren
### Grundprinzipien des CFS
- **Fairness**
- jeder ausführbare Prozess sollte proportional zur Anzahl der CPU-Ressourcen, die er benötigt, bedient werden
- **Keine festen Zeitscheiben**
- Ausführungszeit wird dynamisch an Prozesse angepasst
- **Gewichtungen**
- Prozesse mit höherem "Gewicht" erhalten größere Zeiteinteilung an CPU
- **Virtual Runtime**
- Gewicht und Ausführungszeit → vRuntime
- Prozesse mit kürzerer vRuntime priorisiert
- Entscheidungsstruktur: [Rot-Schwarz-Baum](https://de.wikipedia.org/wiki/Rot-Schwarz-Baum)
- ![image_162.png](image_162.png)
### Beispiel Funktionsweise des CFS
![image_163.png](image_163.png)
- Neue Prozesse können während Latenz des Schedulers eingefügt werden
- **vruntime** wird initialisiert mit minimaler Laufzeit (**min_vruntime**)der bereits vorhanden Tasks
- weil jetzt ein zusätzlicher Task da ist, wird allen vorhandenen Tasks automatisch anteilig weniger Laufzeit zugeteilt
- ![image_164.png](image_164.png)
> Manchmal möchte man die Priorität eines Prozesses verändern. Sie kann mit **nice** gesetzt werden
> und mit **renice** angepasst werden
>
> Jeder Prozess kann einen [nice-Wert](#nicewert) von -20 bis 19(20) haben. Standard ist 0
### Berechnung der Gewichtung (CFS)
- **1024/1,25<sup>[niceWert](#nicewert)</sup>**
- Falls [niceWert](#nicewert) abnimmt, steigt Gewicht an
- Zeitscheibe ist proportional zur Gewichtung dividiert durch Gesamtgewichtung aller Prozesse
- ![image_165.png](image_165.png)
#### Beispiel
- 131 Tasks (nice = 0) → Gewicht w = 1024
- 20 Tasks (nice = -20) → Gewicht w = 88817,84
- Alle Tasks mit nice=0 belegen ca. 7% der CPU
- $131*1024 / (131*1024 + 20*88817,84) → ca. 7%$
- tun i.d.R nichts → genug runtime
- Alle Tasks mit $nice = -20$ belegen ca. 93% der CPU
### niceWert
Befehle mit [POSIX-API](06_prozessstruktur.md#posix-api)
- **setpriority** - niceLevel eines Prozesses setzen
- **getpriority** - niceLevel eines Prozesses lesen
## Real-Time Scheduling
- zielt darauf ab, dass Prozesse oder Aufgaben spezifische zeitliche Anforderungen erfüllen
- Bsp.:
- Dekodierung von Bildern eines Videostreams
- 30 Bilder / Sekunde
- Jedes Bild muss in 1/30s dekodiert und angezeigt werden
- in **harten Echtzeitsystemen** müssen Aufgaben ihre zeitlichen Anforderungen strikt und zuverlässig erfüllen
- bspw. Flugzeug, medizinische Geräte, ...
- _Scheduling-Algorithmen_
- Rate Monotonic Scheduling (RMS)
- Earliest Deadline First (EDF)
- in **weichen Echtzeitsystemen** sind zeitliche Anforderung auch wichtig, aber Versäumnis ist nicht katastrophal
- bspw. Multimediale Anwendungen, Spiele
- _Scheduling-Algorithmen_
- Weighted Fair Queuing (WFQ)
- Proportional Share Scheduling

62
Writerside/topics/02/BS/11_Energieeffizienz.md Normal file
View File

@ -0,0 +1,62 @@
# Energieeffizienz
## Energieverwaltung
- Frequenzskalierung der CPU
- Spannungs- und Frequenzanpassung
- [Stromsparmodi](#stromsparmodi-und-profile)
- Bildschirmhelligkeit und -abschaltung
- [Energieeffizientes Scheduling](#energieeffizientes-scheduling)
- [I/O Effizienz](#i-o-effizienz)
- Wärme- und Lüftermanagement
- [Netzwerkmanagement](#netzwerkmanagement)
- Energieprofile und -richtlinien
- Advanced Configuration and Power Interface (ACPI)
## Prozessor- und Gerätesteuerung
- Strategien und Mechanismen, um _Leistung und Energieeffizienz_
- von CPUs und anderen Hardwarekomponenten zu optimieren
- Moderne Betriebssysteme
- integrierte Mechanismen zur Steuerung von Hardwarekomponenten
## Energieeffizientes Scheduling
- CPU-Energieeffizienz maximieren durch Verteilung von Prozessen auf CPU-Kernen
- Kernzusammenlegung
- Dynamisches Kernabschalten
- Aufgabenplanung basierend auf Prozessoreigenschaften
- Scheduling basierend auf Workload Charakteristiken
- Adaptive Scheduling-Richtlinien
- Anpassung an Hardware-Topologie
## I/O-Effizienz
- Optimierung von Ein- und Ausgabeoperationen
- Effiziente Nutzung von Ressourcen und Reduzierung des Energieverbrauchs
- Batching von I/O-Operationen
- Asynchrone I/O
- Pufferung von Daten
- Intelligente Catching-Strategien
- Effizientes Dateisystem-Layout
- Adaptive Datenkompression
## Leistungsüberwachung und -profiling
- Bewertung und Analyse der Leistung eines Computers
- Engpässe identifizieren
- Ressourcennutzung optimieren
- Effizienz steigern
- Im Wesentlichen Werkzeuge für SysAdmins, Entwickler, Ingenieure
- Leistung von Computern und Anwendungen verstehen
- Bottlenecks beheben
## Netzwerkmanagement
- Planung, Implementierung, Überwachung, Optimierung von Netzwerkinfrastrukturen
- zusätzlich: Lastenausgleich, Netzwerkprotokolle & -standards
## Optimierung von Hintergrundprozessen
- Gewährleistung von Gesamtleistung, Stabilität, Effizienz
- Priorisierung
- Ressourcenzuweisung
- Zeitgesteuerte Ausführung
- Intelligente Aktivierung
- Parallelisierung
- Caching
## Stromsparmodi und -profile
- Funktionen müssen entsprechend der Anforderungen und Nutzungsmuster angepasst werden.

90
Writerside/topics/02/BS/12_Virtualisierung.md Normal file
View File

@ -0,0 +1,90 @@
# Virtualisierung
> Technologie, die es ermöglicht mehrere virtuelle Instanzen auf einem einzigen
> physischen System auszuführen
>
> Spielt eine entscheidende Rolle bei der effizienten Nutzung von Ressourcen, der Erhöhung von
> Flexibilität und Skalierbarkeit sowie der Verbesserung der Verfügbarkeit von Anwendungen und Daten
## Vorteile der Virtualisierung
- **Ressourceneffizienz**
- mehrere VMs können auf einem physischen Server laufen
- **Isolation**
- VMs sind voneinander isoliert
- verbessert Stabilität und Sicherheit
- **Snapshot- und Wiederherstellungsfunktion**
- **Portabilität**
- VMs können auf verschiedenen physischen Servern verschoben und ausgeführt werden
## Virtualisierungstypen
### Hypervisor-basierte Virtualisierung
- [Hypervisor](https://www.youtube.com/watch?v=LMAEbB2a50M) (~Virtual Machine Monitor)
- wird direkt auf Hardware ausgeführt
- ermöglicht Ausführung mehrerer Betriebssysteme als VMs
#### Typ 1 (Bare-Metal-Hypervisor)
- direkte auf Hardware installiert
- benötigt kein Host-Betriebssystem
- _bspw.: VMware ESXi, Microsoft Hyper-V_
#### Typ 2 (Hosted-Hypervisor)
- Läuft auf Host-Betriebssystem
- _bspw: VMware Workstation, Oracle VirtualBox_
### Container-Virtualisierung
- Container teilen sich Kernel des Host-Betriebssystems
- bieten leichtgewichtige Möglichkeit Anwendungen zu isolieren und auszuführen
## Partitionierung von VMs
- Aufteilung einer _physischen oder virtuellen Ressource_ in mehrere logische Einheiten (Partitionen)
- ![image_248.png](image_248.png)
- können unterschiedliche Betriebssysteminstanzen/Anwendungen beherbergen
- Vorteile u.a. Ressourcenisolierung, verbesserte Sicherheit, bessere Verwaltbarkeit
## Hardware-Emulation
- Nachbildung oder Simulation von Hardware auf einer anderen Hardware- oder Softwareplattform
- Replikation von Hardware-Komponenten, Geräten oder ganzen Systemen auf einer virtuellen Ebene
- ![image_249.png](image_249.png)
- **Entwicklung neuer Hardware**
- Simulation von Hardware-Designs bevor tatsächliche Hardware erstellt wird
- **Fehlerbehebung und Debugging**
- Identifizierung von Fehlern in Hardware-Komponenten oder -Systemen
- **Testen von Software**
### Hardware-Emulator vs. Simulator
| **Emulator** | **Simulator** |
|-----------------------------------------------------------------------------|----------------------------------------------------------------------------------------|
| Reproduziert Verhalten der tatsächlichen Hardware genau | Ahmt Verhalten von Hardware nach |
| arbeitet auf niedriger Ebene, indem er Hardwarekomponenten genau nachbildet | Arbeitet auf höherer Ebene, Konzentration auf Funktionalität statt exakter Nachbildung |
## Anwendungsvirtualisierung
- Einzelne anwendung in virtueller Umgebung ausführen, die alle benötigten Komponenten bereitstellt
- ![image_250.png](image_250.png)
- virtuelle Maschine befindet sich zwischen Anwendung und Betriebssystem
- _bspw.: Java Virtual Machine (JVM)_
## Betriebssystem-Virtualisierung
- [Container](https://www.youtube.com/watch?v=TvnZTi_gaNc) laufen unter ein und demselben BS-Kern
- mehrere abgeschottete, identische Systemumgebungen
- ![image_251.png](image_251.png)
- bei Start einer VM wird im Gegensatz kein zusätzliches BS gestartet
- Erzeugung isolierte Laufzeitumgebung
## Vollständige Virtualisierung
- Hypervisor bietet einer VM eine komplette virtuelle PC-Umgebung inkl. eigenem BIOS
- ![image_252.png](image_252.png)
- Gast-BS erhält eigene VM mit virtuellen Ressourcen
- Prozessor(en)
- Hauptspeicher
- Laufwerke
- Netzwerkkarten
- etc.
- Kern der Lösung ist Virtueller Maschinen-Monitor (VMM)
- Aufgabe ist Zuweisung der Hardwareressourcen an VMs
## Virtualisierungslösungen
- [docker](https://www.docker.com)
- [vmware](https://www.vmware.com)
- [virtualbox](https://www.virtualbox.org)
- [getutm (mac)](https://mac.getutm.app)

96
Writerside/topics/02/BS/13_Speicherverwaltung.md Normal file
View File

@ -0,0 +1,96 @@
# Speicherverwaltung
## Speicherhierarchie
### Registers
- schnellste und kleinste Form des Speichers
- direkt in Prozessor
- Speicherung temporärer Daten und Zwischenergebnisse
### Cache
- kleinerer, schnellerer Speicher
- zwischen Register und RAM
### Hauptspeicher (RAM)
- physischer Speicher
- Prozessor kann direkt zugreifen
### Virtueller Speicher
- langsamerer Speicher
- Erweiterung des RAMs
## Speicheradressierung
- Prozess, durch den ein Computer auf den physischen/virtuellen Speicher zugreift
| **Physische Adressierung** | **Logische Adressierung** |
|---------------------------------------------------------------|----------------------------------------------|
| direkter Zugriff auf bestimmten Speicherort im physischen RAM | Adresse von Prozess generiert |
| physische Adresse = tatsächliche Adresse des Speicherorts | wird später in physische Adresse umgewandelt |
| | **Virtuelle Adressierung** |
## Speicherpartitionierung
- Aufteilung des physischen Speichers in logische Abschnitte
- können von verschiedenen Teilen des Systems genutzt werden
- Mögliche Zwecke:
- Betriebssystemcode
- Anwendungsdaten
- Temporäre Variablen
- ...
### Statische Partitionierung
![image_281.png](image_281.png)
- Aufteilung in Partitionen gleicher / unterschiedlicher Größe
- im Idealfall möglichst passgenau
- möglichst wenig interne Fragmentierung
- Falls unterschiedliche Größe
- BS verwaltet Warteschlange
- | eigene für jede Partition | eine für alle |
|--------------------------------------------------------|---------------|
| :( bestimmte Partitionen werden seltener/nie verwendet | |
- Nachteil:
- zwangsläufig interne Fragmentierung
- sehr ineffizient
![image_282.png](image_282.png)
## Dynamische Partitionierung
- BS weist jedem Prozess eine zusammenhängende Partition zu
- mit exakt benötigter Größe
- dabei auch Fragmentierung
- Darstellung des Speichers durch BS als verkettete Liste
- Kennzeichnung, ob frei/belegt
- Startadresse
- Länge
- Zeiger auf nächsten Eintrag
- Unterschiedliche Zuteilungskonzepte
- wie sucht/findet das BS einen freien Speicherbereich
- **First Fit**
- sucht bei jeder Anforderung ab Anfang des Adressraums
- **Next Fit**
- sucht ab letzter Zuweisung
- **Best Fit**
- Sucht immer den freien Bereich, der am besten zur Anforderung passt
- am wenigsten Fragmentierung
- ![image_450.png](image_450.png)
## Buddy-Speicherverwaltung
- Ziel: Fragmentierung von Speicherblöcken minimieren
- wird oft in BS und in der Verwaltung von Speicher-Pools verwendet
- basiert auf
- Blöcke gleicher Größe als Buddies zusammenfassen
- effizienter Speicherzugriff/-freigabe ermöglichen
### Erstellung
- Am Anfang ein Bereich, der gesamten Speicher abdeckt
- Sobald ein Prozess Speicherplatz anfordert
- Speicherkapazität zur nächsthöheren Zweierpotenz aufrunden
- entsprechenden, freien Bereich suchen
- Falls nicht existent
- Nach Bereich doppelter Größe suchen
- in zwei Teile teilen (Buddies)
- eine Hälfte wird anfordernden Prozess zugewiesen
- ![image_283.png](image_283.png)
- Linux verwendet für Zuweisung von Speicherseiten zu Prozessen
- Informationen in _/proc/buddyinfo_
- ![image_284.png](image_284.png)

109
Writerside/topics/02/BS/14_Speicherabstraktion.md Normal file
View File

@ -0,0 +1,109 @@
# Speicherabstraktion
> Idee, dass Anwendungen und Benutzer nicht direkt mit physischem Speicher interagieren müssen.
> Sie können stattdessen auf einer höheren, abstrakten Ebene arbeiten
>
> Ermöglicht einfachere, flexiblere Verwendung des Speichers, da Details der physischen Speicherhardware
> vor Benutzer und Anwendung verborgen werden.
## Adressräume
- Gesamter Bereich von Speicheradressen, welcher durch System/Prozess verwendet werden kann
- ermöglicht Beschränkung des Zugriffs auf bestimmte Speicherbereiche
- Sicherheit & Integrität gewährleisten
- unautorisierten Speicherzugriff verhindern
## Relokation
- Jede Anwendung bekommt eigenen Adressraum des physischen Speichers
- Dafür Spezialregister in der CPU
- ermöglichen laden von Programmen in den Speicher ohne Relokation
- **Basisregister**
- Startadresse des Programms
- **Limitregister**
- Länge des Programms
- **Nachteil:**
- Bei jedem Speicherzugriff Addition und Vergleich ausführen
- Addition benötigt wegen Carry-Bit lange
- _Vergleich ist fine_
> In der Praxis ist die benötigte RAM-Menge oft größer als der physische Speicher
## Swapping
- Prozesse zwischen primären Speicher(RAM) und sekundären Speicher (Festplatte) austauschen
- Entlastung des RAM durch Auslagerung nicht benötigter Prozesse
- Kann Leistung beeinträchtigen
- Zugriff auf sekundären Speicher dauert länger
- ![image_285.png](image_285.png)
> Sehr erfolgversprechend, da normale SATA nur Max-Übertragungsgeschwindigkeit von einigen 100MB/s hat
>
> → es dauert Sekunden, um ein 1GB-Programm aus-/einzulagern
## Virtual Memory
- Virtueller Speicher ermöglicht mehr Speicher zu verwenden als vorhanden ist
- Physischer Speicher und ein Teil der Festplatte werden als virtueller Speicher behandelt
- BS kann effizienten Gebrauch von begrenzten RAM machen
- Prozesse und Daten dynamisch zwischen physischem Speicher und sekundärem Speicher verschieben
- Gesamtleistung optimieren :)
-
## Dynamischer Speicher
- Speicherplatz, der zur Laufzeit eines Programms dynamisch angefordert, freigegeben wird
- Speicherplatz während Laufzeit variieren
- bietet Flexibilität
- Programme können während Ausführung an sich ändernde Anforderungen reagieren
- müssen nicht im Voraus Speicherplatz reservieren
- Wird oft im Heap reserviert
- Heap wird meist für lokale Variablen, Funktionsaufrufe verwendet
- ermöglicht Heap dynamische Zuweisung von Speicherplatz
- Programmierer ist für Freigabe von Speicherplatz verantwortlich
- vernachlässigte Freigabe kann zu Speicherlecks führen
- einige Programmiersprachen haben eine automatische Speicherverwaltung (_Garbage Collection_)
- ![image_286.png](image_286.png)
## Paging
- Speicherverwaltungstechnik
- Virtueller Speicher wird in kleine, gleichgroße Blöcke (_Seiten_) unterteilt
- Können dann in physischem Speicher / Festplatte ausgelagert werden ([Swapping](#swapping))
- Adressen werden mithilfe von Indizierung, Basisregistern und Segmentregistern generiert
- = virtuelle Adresse, bildet virtuellen [Adressraum](#adressr-ume)
- virtueller Adressraum besteht aus Einheiten fester Größe
- werden _Seitenrahmen (page frame)_ genannt
- Beispiel:
- ![image_287.png](image_287.png)
- Seiten und Seitenrahmen sind hier 4KB
- normalerweise von 512 Byte - 1GB
- Present-/Absent-Bit zeigt an, ob Seiten physisch im Speicher vorhanden sind
- Greift Programm auf einen Speicherbereich zu, der noch nicht in den Speicher geladen wurde
- Seitenfehler (_page fault_) wird ausgelöst
- BS gibt einen Seitenrahmen im Speicher frei
- BS lädt entsprechende Seite in jetzt freien Seitenrahmen
- Befehl wird nochmal ausgeführt
- ![image_288.png](image_288.png)
- Muss schnell gehen, da es sonst zu Engpass wird
- Meist < 0,2 ns
- Jeder Prozess hat eigenen Adressraum
- benötigt eigene Seitentabelle
## Memory Management Unit (MMU)
- virtuelle Adresse, die von Prozessen/Programmen verwendet werden in physische Adressen umwandeln
- mithilfe von Seitentabellen oder anderen Mechanismen
- Schlüsselelement des Speichermanagements
- zentrale Rolle bei Implementierung von Funktionen
- wie virtuellem Speicher und Paging
- ![image_289.png](image_289.png)
- 16Bit Adresse wird in 4-Bit-Seitennummer und 12Bit Offset zerlegt
- 4 Bit → 16 Seiten
- 12 Bit → 4096 Byte adressierbar
- ![image_290.png](image_290.png)
- [YouTube: _Virtuelle Speicherverwaltung mit MMU_](https://www.youtube.com/watch?v=QPL-xJ6ePqQ)
## Translation Lookaside Buffer
- Assoziativer Speicher (TLB) für schnellere Adressumwandlung der MMU
- Puffert Seitenzugriffe
- ermöglicht direkteren Zugriff auf wichtige Informationen der Speichertabelle
- ohne Zugriff auf Seitentabelle
- enthält nur wenige Einträge
- Schnelle Suche
- Arbeitet als Cache für MMU

29
Writerside/topics/02/BS/15_Bibliotheken.md Normal file
View File

@ -0,0 +1,29 @@
# Bibliotheken
## Gemeinsame Bibliotheken
- In jedem modernen System vorhanden
- bspw. I/O-, Grafikbibliotheken
- Statt an jedes Programm statisch binden
- _shared libraries_
- Bsp.:
- normales Programm benutzt 20-50MB an Grafik- und Benutzungsschnittstellenfunktionen
- hunderte solcher Programme
- viel Speicher, RAM verschwendet
- BS hat keine Möglichkeit um zu schauen, ob eine gemeinsame Nutzung infrage käme
- Falls Programm mit gemeinsamen Bibliotheken verbunden
- **Binder (_Linker_)** schließt _Stub-Routine_ ein
- statt aktueller Funktionsaufrufe
- Gemeinsame Bibliotheken gleichzeitig wie Programm / beim ersten Aufruf ihrer Funktion laden
- abhängig vom System
- Falls durch anderes Programm bereits geladen
- Muss nicht nochmal! :)
- Wird nicht auf einmal in den Speicher eingelesen
- Bei Bedarf Seite für Seite
- Keine Funktionen im RAM, die nicht gebraucht werden
- Ausführbare Dateien bleiben klein
- Falls Fehler in Bibliothek
- Beheben
- Nicht alle Programme neu übersetzen

310
Writerside/topics/02/BS/16_Dateisysteme.md Normal file
View File

@ -0,0 +1,310 @@
# Dateisysteme
## Warum Dateisysteme
- Neben Verwaltung des Hauptspeichers und Cache
- Verwaltung des Massenspeichers (bspw. SSD, Festplatte)
- Organisation der Ablage von Dateien
- Dateisysteme verwalten die Namen und Attribute (Metadaten) der Dateien
- Bilden einen Namensraum
- Hierarchie von Verzeichnissen und Dateien
## Dateien
- Datei dient der Abstraktion
- Bietet Möglichkeit Informationen auf einer Platte zu speichern/lesen
- Nutzer müssen Details der Speicherung verborgen bleiben
- _Wo_ und _Wie_
- Wichtigstes Merkmal ist Art und Weise wie verwaltete Objekte benannt werden
- Wenn Prozess Datei erzeugt, vergibt er ihr einen Namen
- Bei einigen Systemen (bspw UNIX)
- Dateiendungen lediglich Konventionen, die vom Betriebssystem nicht erzwungen
- Datei _file.txt_ kann Textdatei sein, Name dient mehr dazu den User zu erinnern
- Andererseits könnte ein C-Compiler darauf bestehen, dass Eingabedateien Endung ".c" haben
- Für BS ist das egal
- Dateien können in verschiedenster Art und Weise strukturiert sein
- **Bytefolge**
- **Datensätze**
- **Baumstrukturen**
- In den meisten Fällen werden Dateien als Bytefolgen angesehen
- Maximum an Flexibilität
- Interpretation der Inhalte erfolgt auf Anwendungsebene
## Sequenzieller Dateizugriff
- Prozess kann alle Bytes oder Datensätze einer Datei nacheinander lesen
- Überspringen oder Zugriffe außerhalb der Reihenfolge nicht möglich
- Sequenzielle Dateien konnten zurückgespult werden
- können so oft wie nötig gelesen werden
## Wahlfreier Dateizugriff
- Mit Einführung der Platte als Speichermedium
- Möglichkeit die Bytes oder Datensätze in beliebiger Reihenfolge auslesen
- über Schlüssel statt Positionsangabe zugreifen
- Dateien, bei denen das geht = Dateien mit _wahlfreiem Zugriff_ (random access file)
- sind heute Voraussetzung für viele Anwendungen
- bspw. für Datenbanksysteme
## Dateiattribute
- Eigenschaften / Metadaten
- Können von BS / Dateisystem verwaltet werden
- enthalten Größe, Erstellungsdatum, Zugriffsrechte ...
## Dateioperationen
### Create
- Datei wird ohne Datum erzeugt
- Entstehung der Datei ankündigen und eigene Attribute festlegen
### Delete
- Wird eine Datei nicht länger benötigt, muss sie gelöscht werden
### Open
- Bevor eine Datei benutzt werden kann, muss ein Prozess sie öffnen
- Open ermöglicht Laden in Arbeitsspeicher
### Close
- Freigeben des internen Tabellenspeichers
### Read
- Daten werden aus Datei gelesen
- Bytes von der aktuellen Position
- Aufrufer muss angeben wie viele Daten benötigt werden
- Puffer für Daten zur Verfügung stellen
### Write
- Wenn aktuelle Position an Ende der Datei
- Dateigröße erhöht sich
- Befindet sich Position in der Mitte der Datei
- vorhandene Daten werden überschrieben
### Append
- Eingeschränkte Form von [Write](#write)
### Seek
- Bei Dateien mit wahlfreiem Zugriff
- Von wo Daten holen?
- Seek positioniert Dateizeiger an einer bestimmten Stelle in der Datei
- Danach lesen/schreiben an Position
### Rename
- Name der Datei ändern
- nicht zwingend notwendig
- normalerweise in eine neue Datei mit anderem Namen umkopieren
- alte löschen
### Get attributes
### Set attributes
## Verzeichnisse
- Verzeichnissystem mit nur einer Ebene ist angemessen für sehr einfache Anwendungen
- ![image_338.png](image_338.png)
- **absolute Pfadnamen**
- Gesamter Pfad von Wurzel bis Datei
- **relative Pfadnamen**
- In Verbindung mit dem Konzept des Arbeitsverzeichnisses
- ./
- aktuelles Verzeichnis
- ../
- übergeordnetes Verzeichnis
- ![image_339.png](image_339.png)
## Verzeichnisoperationen
### Create (Verzeichnis)
### Delete (Verzeichnis)
- Es kann immer nur ein leeres Verzeichnis gelöscht werden
- (., .. dürfen enthalten sein)
### Opendir
- Um beispielsweise alle Dateien in einem Verzeichnis aufzulisten
### Closedir
### Readdir
- Aufruf gibt nächsten Eintrag eines geöffneten Verzeichnisses zurück
### Rename (Verzeichnis)
### Link
- Durch Technik des Verlinkens können Dateien in mehr als einem Verzeichnis vorkommen
- Spezifiziert eine vorhandene Datei und erzeugt Verbindung von dieser Datei zu dem Namen
### Unlink
- Verzeichniseintrag wird entfernt
- Falls nur in einem Verzeichnis → [löschen](#delete)
## Implementierung
- BIOS liest MBR ein, führt aus
- MBR-Programm
- lokalisiert aktive Partition
- liest ersten Block (Boot-Block)
- führt aus
- lädt BS, das in Partition gespeichert ist
- Dateisystem enthält häufig noch Superblock
- enthält alle _Schlüsselparameter_ des Dateisystems
- **Magische Zahl**
- identifiziert Typ des DS
- **Anzahl der Blöcke**
- **Weitere administrative Schlüsselinformationen**
- wird bei Start in den Speicher geladen
- Danach
- **Freie Blöcke**
- Bitmap oder Liste von Zeigern
- **I-Nodes**
- Feld von Datenstrukturen
- Jede beinhaltet Informationen über je eine Datei
- **Wurzelverzeichnis**
- Spitze des Dateibaums
- ![image_340.png](image_340.png)
## Methoden zur Belegungsverkettung
### Zusammenhängende Belegung
- Einfachstes Belegungsschema
- Speicherung als zusammenhängende Menge von Plattenblöcken
- Jede Datei beginnt mit neuem Block
- ![image_351.png](image_351.png)
- | Vorteile | Nachteile |
|-----------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
| Einfach zu implementieren<br/>Lokalisierung der Dateiblöcke basiert auf zwei Zahlen | Im Laufe der Zeit wird die Platte fragmentiert |
| hervorragende Leseleistung<br/>Gesamte Datei kann mit einer Operation von der Platte gelesen werden | ![image_352.png](image_352.png) |
- In manchen Situationen praktikabel
- CD-ROM
- alle Dateigrößen sind bekannt, werden sich niemals während Gebrauch ändern
- DVD
- Kann als eine Datei gespeichert werden
- meistens ~4 1GB Dateien
### Verkettete Listen
- Jede Datei ist verkettete Liste von Plattenblöcken
- Erstes Wort = Zeiger auf den nächsten
- Rest = Daten
- ![image_353.png](image_353.png)
- | Vorteile | Nachteile |
|-------------------------------------------------------------------------|--------------------------------------------------------------------|
| Kein verlorener Speicherplatz durch Fragmentierung | sequenzielles Lesen zwar schnell, wahlfreier Zugriff sehr langsam |
| | Für Verzeichniseintrag ist Plattenadresse des ersten Blocks ausreichend | Um Auf Block n zuzugreifen müssen n-1 Blöcke vorher gelesen werden |
### File Allocation Table (FAT)
- Zeiger jedes Plattenblocks in einer Tabelle im Arbeitsspeicher
- | Vorteile | Nachteile |
|------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
| Gesamter Block steht für Daten zur Verfügung | Gesamte Tabelle muss durchgehend im Speicher sein |
| Obwohl Kette verfolgt werden muss, kann das im RAM ohne Zugriffe auf Platte geschehen | Bei einer !TB Festplatte mit einer Blockgröße von 1KB benötigt die Tabelle 1Mia*3Byte ~ 3GB des RAM |
| Es reicht für Verzeichniseintrag einen einzigen ganzzahligen Wert des Startblocks zu speichern | |
### I-Nodes (Index Node)
- Datenstruktur, die Informationen über eine Datei oder ein Verzeichnis auf einem Dateisystem enthält
- Jede/s Datei/Verzeichnis ist durch einen eindeutigen I-Node identifiziert
- | Vorteile | Nachteile |
|--------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| I-Node muss nur im Speicher sein, solange Datei geöffnet ist | Jeder Node kann nur begrenzte Anzahl von Plattenadressen<br/>Sobald das Limit erreicht ist, müsste man die letzte Adresse als Zeiger auf den nächsten Node nehmen |
| Feld, das die I-Nodes enthält benötigt nur n*k Byte | |
- ![image_354.png](image_354.png)
## Dateinamen
- Keine festgelegte Länge
- variable Dateinamenlängen verwalten?
- ![image_355.png](image_355.png)
- Nachteil:
- Lücke variabler Länge
- entsteht, wenn eine Datei entfernt wird und nächste Lücke nicht genau passt
- Es ist möglich Verzeichniseinträge zu verschieben
- ![image_356.png](image_356.png)
- Für alle Dateinamen nur feste Längen zulassen
- Gemeinsam auf einem Heap am Ende des Verzeichnisses speichern
- Vorteil:
- nach Entfernen einer Datei passt nächste immer rein
- Heap muss mitverwaltet werden :/
- Lineare Suche → sehr langsam
- Verwendung einer Hashtabelle in jedem Verzeichnis
- Vorteil einer viel schnelleren Suche
- Nachteil: komplizierte Verwaltung
- Zwischenspeichern der Resultate vorangegangener Suchen
## Gemeinsam genutzte Dateien
- ![image_357.png](image_357.png)
- Probleme:
- ![image_358.png](image_358.png)
- Enthält Verzeichnis Plattenadressen, dann muss Kopie der Adressen im Verzeichnis B angelegt werden
- Wenn B/C Daten an Datei anhängen
- neue Blöcke werden nur im Verzeichnis, in dem Änderung stattfand, aufgelistet
- Zweck gemeinsamer Verwendung verfehlt
### Symbolische Links
- Enthält Pfadnamen zur gewünschten Datei
- Wenn B Datei liest, sucht BS direkt im angegebenen Pfad
- | Vorteil | Nachteile |
|--------------------------------------------------------|--------------------------------------------------------------------------------------------|
| Dateien auf entfernten, vernetzten Maschinen verlinken | zusätzlicher Aufwand<br/>eigener Plattenblock für Pfad |
| | Datei mit Pfadnamen muss gelesen werden, Pfad analysieren, Komponente bis I-Node verfolgen |
| | Falls in Unterverzeichnissen wird Datei evtl. mehrfach gefunden |
| | Bei Einspielung auf anderen Computer → Link wird zur Kopie der selben Datei |
## Log-basiertes Dateisystem (LFS)
- Schreibzugriffe sind effizienter als Lesezugriffe
- Schreibleistungs- und Fragmentierungsprobleme überwinden
- Schreibvorgänge werden protokolliert
- Mit schnelleren CPUs, größerem RAM wächst Platten-Cache schneller
- Viele Lesezugriffe direkt aus Platten-Cache
- Ohne Festplattenzugriffe
- Meiste Plattenzugriffe = Schreibzugriffe :)
- Probleme
- Schreibzugriffe meist in Stückchen → ineffektiv
- Abhängig von
- Spurwechselzeit ([seek](#seek) time)
- Latenzzeit (latency)
- Kommando-Latenz (controller overhead)
- Inkonsistenzen bei Systemabstürzen
- Lösungsansatz
- Alle noch ausstehenden im Speicher gepufferten Schreibaufträge regelmäßig sammeln
- An Ende des Logs schreiben
- Einzelnes Segment kann in beliebiger Reihenfolge I-Nodes, Verzeichnisblöcke und Datenblöcke enthalten
- Am Anfang Zusammenfassung über Inhalt
- Probleme Lösungsansatz
- Log wird ohne Reorganisation immer größer
- Bereinigungsvorgang wird benötigt
- Über alle Vorgänge Protokoll zu führen erfordert logistischen Aufwand
- LFS sind hochgradig inkompatibel zu bestehenden Dateisystemen
- können Inkonsistenz bei Systemabstürzen nicht abfangen
## Journaling
- mit Grundgedanken von [LFS](#log-basiertes-dateisystem-lfs) Robustheit DS erhöhen
- Log ist Protokoll über geplante Aktionen
- Bei Systemabsturz vor Beendigung einer geplanten Arbeit
- Bei Neustart im Log nachschauen, was gerade vor sich ging
- Vorgang sauber beenden
- Beispiel:
- _NTFS_, _ext3_, _macOS Extended_
- Für zusätzliche Zuverlässigkeit
- Datenbankkonzept der atomaren Transaktion
- Gruppe von Aktionen klammern
- Anfangstransaktion (begin transaction)
- Endtransaktion (end transaction)
- Dateisystem weiß, das es alle eingeklammerten oder keine ausführen muss
- ACID-Eigenschaften
- **Atomarität (Atomicity)**
- Transaktion wird als Ganzes behandelt
- alle oder keine Operationen in Transaktion ausführen
- Wenn eine fehlschlägt Rest rückgängig machen
- **Konsistenz (Consistency)**
- Transaktionen werden von einem in einen andern konsistenten Zustand überführt
- Nach Abschluss einer erfolgreichen Transaktion
- DB in Zusatnd, der Integritätsregeln entspricht
- **Isolation (Isolation)**
- mehrere gleichzeitige Transaktionen unabhängig, gleichzeitig ausführen
- **Dauerhaftigkeit (Durability)**
- einmal abgeschlossene Transaktion dauerhaft in DB gespeichert
- Änderung auch nach Systemabsturz / Neustart erhalten
## Virtuelle Dateisysteme (VFS)
- ![image_359.png](image_359.png)
- Abstraktionsschicht im BS
- dient zur Vereinheitlichung der Dateisysteme und deren Zugriffsmethoden
- Anwendungen können auf Dateien zugreifen
- ohne auf Details der zugrunde liegenden physischen Dateisysteme zu achten
- erleichtert Portabilität, flexiblere Verwaltung der Dateisystemressourcen
- Wenn System hochgefahren
- Wurzeldateisystem beim VFS registrieren
- Liste der Adressen von Funktionen dem VFS zur Verfügung stellen
- Entweder lange Aufruftabelle oder eine Tabelle pro VFS-Objekt
- VFS legt im RAM V-Nodes an
- weitere Dateisysteme jetzt oder während Ausführung

65
Writerside/topics/02/BS/17_Plattenspeicherverwaltung.md Normal file
View File

@ -0,0 +1,65 @@
# Plattenspeicherverwaltung
## Mögliche Strategien
**Speicherung von einer Datei mit n Byte**
- n aufeinanderfolgende Byte auf der Platte reservieren
- Problem
- Datei muss möglicherweise auf Platte verschoben werden, wenn sich Größe ändert
- **Datei wird in eine bestimmte Anzahl von (nicht unbedingt) zusammenhängenden Blöcken aufgeteilt**
- Verschiebung relativ schnell
### Wie groß die Blöcke?
- Sektoren, Spuren und Zylinder Kandidaten
- geräteabhängig
- große Blockgröße → Platzverschwendung
- kleine Datei braucht trotzdem viel Platz
- kleine Blockgröße → Zeitverschwendung
- mehr Plattenzugriffe, rotationsbedingte Wartezeiten
- Reduzierung Performanz
### Überblick über Anzahl freier Blöcke?
#### Verkettete Liste von Plattenblöcken
![image_360.png](image_360.png)
#### Bitmap
![image_361.png](image_361.png)
- Was macht man jetzt?
- man benötigt Daten über Verwendung, um besten Algorithmus zu finden
- Falls viele freie Blöcke aufeinanderfolgen
- In der Liste statt Blöcken Folgen von Blöcken
- Jeder Block bekommt 8/16/32 Bit Zähler über nachfolgende freie Blöcke
- leere Platte definiert durch 2 Zahlen
- Adresse erster freier Block
- Anzahl der folgenden freien Blöcke
- Immer ein Block von Zeigern im Speicher
- Beim Löschen einer Datei
- Blöcke werden freigegeben
- ![image_362.png](image_362.png)
- Um Anwender davon abzuhalten, zu viel Speicher in Beschlag zu nehmen
- disk quota
- SysAdmin weist jedem Benutzer einen max. Anteil an Dateien und Blöcken zu
- BS behält Kontrolle
- ![image_363.png](image_363.png)
- Wenn sich Benutzer anmeldet
- Soft-Limit übertreten?
- Warnung
- Sobald Warnung einmal zu oft ignoriert
- Sperre, SysAdmin muss entsperren
## Sicherung von Dateisystemen
- Wiederherstellung meist sehr schwierig, zeitintensiv / unmöglich
- Sicherheitskopie braucht lange, viel Platz
- Alles oder nur einen Teil sichern?
- Nochmal sichern, wenn sich seit letztem Mal nix geändert hat?
- Daten komprimieren?
### Ansätze
#### Physische Sicherung (physical dump)
- Beginnt mit Block 0 der Festplatte
- Alle Blöcke der Reihe nach auf das Medium
- Programm sehr einfach
### Logische Sicherung (logical dump)
- Beginnt mit einem oder mehreren Verzeichnissen
- vorher festgelegt
- sichert rekursiv alle dort vorhandenen Daten
- die sich seit gewissem Bezugsdatum geändert haben

63
Writerside/topics/02/BS/Klausurthemen.md Normal file
View File

@ -0,0 +1,63 @@
# Klausur
## Themenbereiche
- 4 Stück mit je 20 Punkten
**1. Kernel**
- Was ist ein Kernel
- Was für Varianten
- Warum ist das so
**2. Prozesse**
- Wie funktionieren die
- Wie sind sie aufgebaut
- Wer verwaltet sie
- Wie werden sie verwaltet
**3. Interprozesskommunikation / Scheduling**
- IPC
- Scheduling
- Was ist das
- Was macht das
**4. Speicherverwaltung / Virtualisierung**
- VM / Container
- Virtueller Speicher
- Wie funktioniert das
- Was macht Speicherverwaltung generell
- Konzepte
- Was wird da so gemacht
### Keine Spickzettel :/
## Kommt nicht dran
- Energieeffizienz
- Dateisysteme
- Plattenspeicherverwaltung
- Und alles was da oben nicht steht :)
## Altklausur WiSe 2324
**Aufgabe1:**
1. Beschreiben Sie Betriebssysteme
2. Grundlegende Funktionalitäten von Kernel
3. Unterschied von monolithische und minimale Kernel grafisch darstellen.
4. Grundsätzlich m.. Bottleneck von verschiedenen Betriebssystem-Varianten
**Aufgabe2:**
1. Beschreiben Sie die Kontrollstruktur von Prozessen blah blah, welche Informationen bekommt man blah blah
2. Unterschied zwischen Thread und Fork() im Zusammenhang mit nebenläufigen Programme
3. 8-Zustandsdiagramm von Linux
4. Beschreiben Sie die Funktion von Signalen im BS/Prozess?
**Aufgabe3:**
1. Beschreiben Sie Interprozesskommunikation thingy
2. Nenne Sie 3 Methoden davon und beschreiben Sie diese
3. Beschreiben Sie die Funktionen von verdrängende und kooperative Scheduling
4. Warum Priorisierung Scheduling und Wie
**Aufgabe4:**
1. verschiedene Partionierungsverfahren beschreiben
2. Speicherabstraktion und Funktion von Adressenräumen
3. Paging erklären
4. Virtueller Speicherraum vs Container