2021-02-09 13:29:13 +00:00
\documentclass [a4paper] { article}
2021-02-02 12:00:49 +00:00
\usepackage [ngerman] { babel}
\usepackage { multicol}
\usepackage { calc}
\usepackage { ifthen}
\usepackage [landscape,left=1cm,top=1cm,right=1cm,nohead,nofoot] { geometry}
\usepackage { amsmath,amsthm,amsfonts,amssymb}
\usepackage { color,graphicx,overpic}
\usepackage { listings}
\usepackage [compact] { titlesec} %less space for headers
\usepackage { mdwlist} %less space for lists
2021-01-08 11:52:10 +00:00
\usepackage [utf8] { inputenc}
\usepackage { tikz}
\usepackage { pdflscape}
2021-01-12 12:06:23 +00:00
\usepackage { verbatim}
2021-02-09 13:29:13 +00:00
\usetikzlibrary { mindmap, arrows,shapes,positioning,shadows,trees}
\tikzstyle { every node} =[draw=black,thin,anchor=west, minimum height=2em]
2021-01-12 12:06:23 +00:00
\usepackage [hidelinks,pdfencoding=auto] { hyperref}
2021-02-02 12:00:49 +00:00
\pdfinfo {
/Title (Betriebssysteme - Cheatsheet)
/Creator (TeX)
/Producer (pdfTeX 1.40.0)
/Author (Robert Jeutter)
/Subject ()
}
2021-01-12 12:06:23 +00:00
% Information boxes
\newcommand * { \info } [4][16.3]{
\node [ annotation, #3, scale=0.65, text width = #1em, inner sep = 2mm ] at (#2) {
\list { $ \bullet $ } { \topsep =0pt\itemsep =0pt\parsep =0pt
\parskip =0pt\labelwidth =8pt\leftmargin =8pt
\itemindent =0pt\labelsep =2pt}
#4
\endlist
} ;
}
2021-01-08 11:52:10 +00:00
2021-02-02 12:00:49 +00:00
% This sets page margins to .5 inch if using letter paper, and to 1cm
% if using A4 paper. (This probably isn't strictly necessary.)
% If using another size paper, use default 1cm margins.
\ifthenelse { \lengthtest { \paperwidth = 11in} }
{ \geometry { top=.5in,left=.5in,right=.5in,bottom=.5in} }
{ \ifthenelse { \lengthtest { \paperwidth = 297mm} }
{ \geometry { top=1cm,left=1cm,right=1cm,bottom=1cm} }
{ \geometry { top=1cm,left=1cm,right=1cm,bottom=1cm} }
}
% Redefine section commands to use less space
\makeatletter
\renewcommand { \section } { \@ startsection{ section} { 1} { 0mm} %
{ -1ex plus -.5ex minus -.2ex} %
{ 0.5ex plus .2ex} %x
{ \normalfont \large \bfseries } }
\renewcommand { \subsection } { \@ startsection{ subsection} { 2} { 0mm} %
{ -1explus -.5ex minus -.2ex} %
{ 0.5ex plus .2ex} %
{ \normalfont \normalsize \bfseries } }
\renewcommand { \subsubsection } { \@ startsection{ subsubsection} { 3} { 0mm} %
{ -1ex plus -.5ex minus -.2ex} %
{ 1ex plus .2ex} %
{ \normalfont \small \bfseries } }
\makeatother
% Define BibTeX command
\def \BibTeX { { \rm B\kern -.05em{ \sc i\kern -.025em b} \kern -.08em
T\kern -.1667em\lower .7ex\hbox { E} \kern -.125emX} }
% Don't print section numbers
\setcounter { secnumdepth} { 0}
\setlength { \parindent } { 0pt}
\setlength { \parskip } { 0pt plus 0.5ex}
% compress space
\setlength \abovedisplayskip { 0pt}
\setlength { \parskip } { 0pt}
\setlength { \parsep } { 0pt}
\setlength { \topskip } { 0pt}
\setlength { \topsep } { 0pt}
\setlength { \partopsep } { 0pt}
\linespread { 0.5}
\titlespacing { \section } { 0pt} { *0} { *0}
\titlespacing { \subsection } { 0pt} { *0} { *0}
\titlespacing { \subsubsection } { 0pt} { *0} { *0}
%My Environments
\newtheorem { example} [section]{ Example}
2021-01-08 11:52:10 +00:00
2021-02-11 11:22:53 +00:00
% Turn off header and footer
2021-01-08 11:52:10 +00:00
\pagestyle { empty}
\begin { document}
2021-02-02 12:00:49 +00:00
\raggedright
\begin { multicols} { 3} \scriptsize
% multicol parameters
% These lengths are set only within the two main columns
%\setlength{\columnseprule}{0.25pt}
\setlength { \premulticols } { 1pt}
\setlength { \postmulticols } { 1pt}
\setlength { \multicolsep } { 1pt}
\setlength { \columnsep } { 2pt}
2021-02-09 13:29:13 +00:00
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ Uebersicht.png}
}
2021-02-02 12:00:49 +00:00
\paragraph { Prozesse}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item BS-Abstraktionen zur Ausführung von Programmen
2021-02-02 12:00:49 +00:00
\item Eigentümer von Ressourcen
\item differenzierte Prozessmodelle: definieren konkrete Prozesseigenschaften
\end { itemize*}
\paragraph { Prozessmanagement}
\begin { itemize*}
\item Komponente eines Betriebssystems, die Prozessmodell dieses Betriebssystems implementiert
2021-02-09 13:29:13 +00:00
\item Aufgaben: Prozesserzeugung u. -beendigung (u. Scheduling)
\item Datenstrukturen: Prozessdeskriptor, -deskriptortabelle
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { Prozessdeskriptor}
2021-02-02 12:00:49 +00:00
Buchführung über sämtliche zum Management eines Prozesses notwendigen Informationen
\begin { itemize*}
\item Prozessidentifikation
\item Rechtemanagement
\item Speichermanagement
\item Prozessormanagement
\item Kommunikationsmanagement
\end { itemize*}
\paragraph { Prozessdeskriptortabelle}
enthält: Prozessdeskriptoren aller momentan existierenden Prozesse
\paragraph { Threads}
2021-02-09 13:29:13 +00:00
BS-Abstraktionen für sequentielle, nebenläufige Aktivitäten; sind Gegenstand des Schedulings
2021-02-02 12:00:49 +00:00
\paragraph { Multithread-Prozessmodell}
2021-02-09 13:29:13 +00:00
vollständige Beschreibung einer ablaufenden Aktivität. Dazu gehören insbesondere
\begin { enumerate*}
\item das ablaufende Programm
\item zugeordnete Betriebsmittel (Prozessor/Speicher/Kommunikation)
\item Rechte
\item prozessinterne parallele Aktivitäten (Threads) und deren Bearbeitungszustände
\end { enumerate*}
\paragraph { Threaddeskriptor}
ein TCB enthält lediglich:
\begin { enumerate*}
\item Threadzustand (aktiv, bereit, blockiert, ...)
\item Ablaufkontext, falls nicht aktiv (Programmzähler, Stackpointer, Prozessorregister)
\end { enumerate*}
enthält nicht: Beschreibung der Ressourcen (Speicherlayout, Rechte)
2021-02-02 12:00:49 +00:00
\paragraph { Thread-Typen}
\begin { itemize*}
\item Kernel Level Threads (KLTs): Kenntnis über Threads: hat Betriebssystem, genauer: der Betriebssystem-Kern(el)
\item User Level Threads (ULTs): Kenntnis über Threads: existiert nur auf Benutzer-Ebene (user level)
2021-02-09 13:29:13 +00:00
\item der Betriebssystem-Kern(el) weiß nicht, dass Threads existieren
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { Scheduling}
Entscheidung: Welche Threads erhalten wann und wie lange einen Prozessor/Prozessorkern zugeteilt?
2021-02-02 12:00:49 +00:00
\paragraph { Zustandsmodelle}
2021-02-09 13:29:13 +00:00
Threads können verschiedene Zustände annehmen\\
Beispiel 3/5-Zustandsmodell)
2021-02-02 12:00:49 +00:00
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ Zustandsmodell.png}
}
\paragraph { Scheduling: Notwendigkeit u. Sinn}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item allg: Anzahl Aktivitäten $ >> $ Anzahl Prozessoren
2021-02-02 12:00:49 +00:00
\item nicht alle können gleichzeitig arbeiten
\item eine Auswahl muss getroffen werden
2021-02-09 13:29:13 +00:00
\item Auswahlstrategie: Schedulingstrategie, -Algorithmus
2021-02-02 12:00:49 +00:00
\end { itemize*}
\paragraph { Scheduling-Strategien}
\begin { itemize*}
\item abhängig vom Einsatzfeld eines Betriebssystems
\begin { itemize*}
\item Echtzeitsysteme: Einhaltung von Fristen
\item interaktive Systeme: Reaktivität
\end { itemize*}
\item wichtige Strategien:
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item FCFS (First Come, First Served)
\item SRTN (Shortest Remaining Time Next)
\item Round Robin (ohne und mit Prioritäten)
\item EDF (earliest deadline first)
2021-02-02 12:00:49 +00:00
\item ratenmonotones Scheduling
\end { itemize*}
\end { itemize*}
\paragraph { Privilegierungsebenen}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item sind typischerweise 'kernel mode' und 'user mode'
\item steuern Rechte
2021-02-02 12:00:49 +00:00
\begin { itemize*}
\item zur Ausführung privilegierter Prozessorinstruktionen
\item zur Konfiguration des Arbeitsspeicherlayouts
\item zum Zugriff auf Arbeitsspeicherbereiche
\item zum Zugriff auf E/A-Geräte
\end { itemize*}
2021-02-09 13:29:13 +00:00
\item Durchsetzung von Regeln: "Nur ein im 'kernel mode' ablaufender Prozess hat Zugriff auf ..."
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { Kommunikation und Synchronisation}
2021-02-02 12:00:49 +00:00
\begin { itemize*}
\item Austausch von Daten zwischen Prozessen = Kommunikation (Inter-Prozess-Kommunikation, IPC)
\item Abweichende Geschwindigkeiten von Sender und Empfänger: behandelt durch Synchronisation
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { kritischer Abschnitt}
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item in kritischen Abschnitt darf stets nur ein Thread sein
2021-02-02 12:00:49 +00:00
\item notwendig: wechselseitiger (gegenseitiger) Ausschluss
2021-02-09 13:29:13 +00:00
\item realisiert durch Entry- und Exit-Code z.B. die Semaphor-Operationen belegen (P) und freigeben (V)
2021-02-02 12:00:49 +00:00
\end { itemize*}
\paragraph { Mechanismen zur Synchronisation}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item binäre Semaphore und mehrwertige Semaphore
2021-02-02 12:00:49 +00:00
\item (Hoar‘
\end { itemize*}
\paragraph { Mechanismen zur Kommunikation}
\begin { itemize*}
\item Shared Memory (gemeinsamer Speicher)
\item Botschaften
\item Fernaufrufe
\item Systemaufrufe
\end { itemize*}
\paragraph { Notwendigkeit des Ereignismanagement}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item in BS laufen sehr viele Aktivitäten parallel ab
2021-02-02 12:00:49 +00:00
\item dabei entstehen immer wieder Situationen, in denen auf unterschiedlichste Ereignisse reagiert werden muss, z.B.
\begin { itemize*}
\item Timerablauf
\item Benutzereingaben (Maus, Tastatur)
\item Eintreffen von Daten von Netzwerken, Festplatten, ...
2021-02-09 13:29:13 +00:00
\item Einlegen/-stecken von Datenträgern
2021-02-02 12:00:49 +00:00
\item Aufruf von Systemdiensten
\item Fehlersituationen
\end { itemize*}
\end { itemize*}
\paragraph { Umgangsformen mit Ereignissen}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item 'busy waiting'
\item 'periodic testing'
\item Unterbrechungen ('Interrupts')
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { Programmiermodelle für Interrupts}
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Prozeduren ($ \rightarrow $ inline Prozeduraufrufmodell)
\item IPC-Operationen ($ \rightarrow $ IPC-Modell)
\item Threads ($ \rightarrow $ pop-up Thread Modell)
2021-02-02 12:00:49 +00:00
\end { itemize*}
\paragraph { Interrupts auf Anwendungsebene}
\begin { itemize*}
\item notwendig: Event Service Routines (ESRs)
\item Beispiel: UNIX/Linux-Signalbehandlung
\end { itemize*}
\paragraph { Virtuelle Prozessadressräume und physischer Adressraum, Abbildungen}
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ Adressräume.png}
}
\paragraph { Seitenabbildungstabellen}
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ Seitenabbildungstabellen.png}
}
\paragraph { Seitentabelleneinträge}
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ Seitentabelleneinträge.png}
}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item anwesend: liegt Seite im Arbeitsspeicher? ('present'-Bit)
\item benutzt: wurde auf die Seite zugegriffen? ('used'-Bit)
\item verändert: ist Seite 'schmutzig'? ('dirty/modified'-Bit)
\item Schutz: erlaubte Zugriffsart je Privilegierungsebene ('access control list')
\item Caching: darf Inhalt der Seite gecached werden?
2021-02-02 12:00:49 +00:00
\end { itemize*}
\paragraph { Seitenaustauschalgorithmen}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Optimal: Auslagern der Arbeitsspeicherseite, deren
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item nächster Gebrauch am weitesten in der Zukunft liegt
\item Auslagerung nichts kostet
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\item einige Algorithmen, die sich diesem Optimum annähern:
2021-02-02 12:00:49 +00:00
\begin { itemize*}
\item First-In, First-Out (FIFO)
\item Second-Chance
\item Least Recently Used (LRU)
\item Working Set / WSClock
\end { itemize*}
\end { itemize*}
\paragraph { i-Node}
2021-02-09 13:29:13 +00:00
Metainformationen über genau eine Datei
2021-02-02 12:00:49 +00:00
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ i-Node.png}
}
\paragraph { Verzeichnis}
2021-02-09 13:29:13 +00:00
= Menge von Paaren (Name, i-Node-Index)
2021-02-02 12:00:49 +00:00
2021-02-09 13:29:13 +00:00
\paragraph { Superblock} = Einstiegspunkt eines Dateisystems. Enthält Schlüsselparameter:
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Name des Dateisystems
\item Typ (NTFS, Ext * , HFS, ...) → Layout der Metadaten
\item Größe und Anzahl Sektoren
\item Ort und Größe der i-Node-Tabelle
\item Ort und Größe der Freiliste
\item i-Node-Nummer des Wurzelverzeichnisses
2021-02-02 12:00:49 +00:00
\end { itemize*}
\paragraph { Hardware-Prinzipien}
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Controller-Register
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item in E/A-Adressräumen
2021-02-02 12:00:49 +00:00
\item im Arbeitsspeicher (Memory Mapped E/A)
\item Isolation, Robustheit, Sicherheit
\end { itemize*}
\item Interruptsystem: asynchrone Benachrichtigungen
\end { itemize*}
\paragraph { Software-Prinzipien}
Gerätemanager (Treiber)
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Auftragsmanagement
2021-02-02 12:00:49 +00:00
\item ISRs
\end { itemize*}
\paragraph { Betriebssystem-Architekturen}
\centering {
\includegraphics [width=\textwidth/4] { Assets/Betriebssysteme_ Architekturen.png}
}
2021-02-09 13:29:13 +00:00
\paragraph { SELinux-Ansatz} neue Betriebssystem-Abstraktion
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item absolute Kontrolle über kritische Funktionen des Betriebssystems
\item spezifiziert durch Regelmenge
\item implementiert durch die SELinux-Sicherheitsarchitektur
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { Robustheit} Tolerierung unvorhergesehener Fehler und Ausfälle
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Mikrokernarchitekturen (Robuster als Makrokern)
\item Fehlerisolation
\item Möglichkeiten zur Fehlerbehebung (z.B. Micro-Reboot)
\end { itemize*}
\paragraph { Funktionale Eigenschaften}
\begin { itemize*}
\item Authentisierung, Verschlüsselung
\item Informations-management
\item Kommunikations-management
\item Ressourcen-management
\end { itemize*}
\paragraph { Nichtfunktionale Eigenschaften}
\begin { itemize*}
\item Sicherheit
\item Korrektheit
\item Echtzeitfähigkeit
\item Skalierbarkeit
\item Offenheit
\item Sparsamkeit
\item Verfügbarkeit
\item Robustheit
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\paragraph { Betriebssysteme}
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item Mainframe
2021-02-02 12:00:49 +00:00
\begin { itemize*}
2021-02-09 13:29:13 +00:00
\item performante E/A
\item Massen-daten-verarbeitung
2021-02-02 12:00:49 +00:00
\end { itemize*}
2021-02-09 13:29:13 +00:00
\item Server (Web Server, Fileshare)
\item Parallelrechner
\begin { itemize*}
\item parallele Algorithmen, hoher Rechenbedarf
\item schnelle IPC
\end { itemize*}
\item Desktop/Laptop
\item Echtzeit
\item Eingebettete
2021-02-02 12:00:49 +00:00
\end { itemize*}
\end { multicols}
2021-01-08 11:52:10 +00:00
2021-02-09 13:29:13 +00:00
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Überblick
\begin { tikzpicture} [
topic/.style={
minimum height=8mm,
text depth = 0pt,
text centered,
text width=5cm,
level distance=1mm,
sibling distance=5mm,
rounded corners=2pt} ,
subtopic/.style={
yshift=1.5cm,
text centered,
text width=3cm,
rounded corners=2pt,
fill=gray!10} ,
theme/.style={
grow=down,
xshift=-0.6cm,
text centered,
text width=3cm,
edge from parent path={ (\tikzparentnode .205) |- (\tikzchildnode .west)} } ,
level1/.style ={ level distance=1cm} ,
level2/.style ={ level distance=2cm} ,
level3/.style ={ level distance=3cm} ,
level4/.style ={ level distance=4cm} ,
level5/.style ={ level distance=5cm} ,
level6/.style ={ level distance=6cm} ,
level 1/.style={ sibling distance=4cm} ,
level 1/.append style={ level distance=3cm} ,
]
% Topic
\node [topic] { Betriebssysteme}
% Subtopic and Themes
child{ node [subtopic] { Prozessor-management}
child[theme,level1]{ node { Prozesserzeugung} }
child[theme,level2]{ node { Prozess-terminierung} }
child[theme,level3]{ node { Threads} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child{ node [subtopic] { Scheduling}
child[theme,level1]{ node { Scheduler-aktivierung} }
child[theme,level2]{ node { Scheduling Strategien} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child{ node [subtopic] { Privilegierungs-ebenen} }
child{ node [subtopic] { Kommunikation \& Synchronisation}
child[theme,level1]{ node { Elementare Konzepte} }
child[theme,level2]{ node { wechselseitiger Ausschluss} }
child[theme,level3]{ node { Mechanismen} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child{ node [subtopic] { Speicher-management}
child[theme,level1]{ node { Speicher-technologien} }
child[theme,level2]{ node { Speicher-klassen} }
child[theme,level3]{ node { Relokation} }
child[theme,level4]{ node { Swapping} }
child[theme,level5]{ node { Virtueller Speicher} }
child[theme,level6]{ node { Segmentierung} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child{ node [subtopic] { Dateisystem}
child[theme,level1]{ node { Dateimodelle} }
child[theme,level2]{ node { Dateisysteme} }
child[theme,level3]{ node { Datenstrukturen \& Algorithmen} }
2021-01-08 11:52:10 +00:00
} ;
\end { tikzpicture}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Prozessormanagement
2021-02-09 13:29:13 +00:00
\begin { tikzpicture} [
topic/.style={
text centered,
text width=5cm,
level distance=1mm,
sibling distance=5mm,
rounded corners=2pt
} ,
subtopic/.style={
yshift=1.5cm,
text centered,
text width=3cm,
rounded corners=2pt,
fill=gray!10
} ,
theme/.style={
grow=down,
xshift=-0.6cm,
text centered,
text width=3cm,
edge from parent path={ (\tikzparentnode .205) |- (\tikzchildnode .west)}
} ,
description/.style={
grow=down,
xshift=-0.5cm,
right,
text centered,
edge from parent path={ (\tikzparentnode .200) |- (\tikzchildnode .west)}
} ,
level1/.style ={ level distance=1cm} ,
level2/.style ={ level distance=2cm} ,
level3/.style ={ level distance=3cm} ,
level4/.style ={ level distance=4cm} ,
level5/.style ={ level distance=5cm} ,
level6/.style ={ level distance=6cm} ,
level7/.style ={ level distance=7cm} ,
level8/.style ={ level distance=8cm} ,
level9/.style ={ level distance=9cm} ,
level 1/.style={ sibling distance=5.5cm} ,
level 1/.append style={ level distance=2.5cm} ,
]
% Topic
\node [topic] { Prozessormanagement}
% Subtopic and Themes
child{ node [subtopic] { Aufgaben}
child[theme, level1]{ node{ Prozess-identifikation} }
child[theme, level2]{ node{ Scheduling} }
child[theme, level3]{ node{ Ereignis-management} }
child[theme, level4]{ node{ Rechte-management} }
child[theme, level5]{ node{ Speicher-management} }
child[theme, level6]{ node{ Prozessor-management} }
child[theme, level7]{ node{ Kommunikations-management} }
child[theme, level8]{ node{ Virtueller Adressraum} }
child[theme, level9]{ node{ allg Ressourcen Management} }
}
child{ node [subtopic] { Prozesserzeugung}
child[theme,level1]{ node { Vorraussetzungen}
child[description,level distance=1cm]{ node { Rechte} }
child[description,level distance=2cm]{ node { Ressourcen Verfügbar} }
child[description,level distance=3cm]{ node { Sicherheit} }
child[description,level distance=4cm]{ node{ Fariness} }
child[description,level distance=5cm]{ node{ Robustheit / Überlastvermeidung} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child [theme,level distance=7cm]{ node { Namens-vergabe}
child[description,level distance=1cm]{ node{ eindeutig bzgl allen existierenden} }
child[description,level distance=2cm]{ node{ nicht eindeutig bzgl allen} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child [theme,level distance=10cm]{ node { Stammbaumpflege}
child[description,level distance=1cm]{ node{ erzeugt Kinder} }
child[description,level distance=2cm]{ node{ baumartige Hierarchie} }
child[description,level distance=3cm]{ node{ Verwaiste Prozesse $ - > $ Adoption} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child [theme,level distance=14cm]{ node { Allokation (von Ressourcen)}
child[description,level distance=1cm]{ node{ Arbeits-speicher Größe} }
child[description,level distance=2cm]{ node{ Zeitpunkt} }
child[description,level distance=3cm]{ node{ Prozessorzeit} }
child[description,level distance=4cm]{ node{ Format} }
2021-01-08 11:52:10 +00:00
}
}
2021-02-09 13:29:13 +00:00
child{ node [subtopic] { Prozessterminierung}
child[theme,level distance=1cm]{ node{ durch}
child[description,level distance=1cm]{ node{ Aufgabe erledigt} }
child[description,level distance=2cm]{ node{ Fehler aufgetreten} }
child[description,level distance=3cm]{ node{ durch Nutzer geschlossen} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child[theme,level distance=5cm]{ node{ Folgen}
child[description,level distance=1cm]{ node{ Freigabe der Ressourcen} }
child[description,level distance=2cm]{ node{ Benachrichtigung der 'Parents'} }
child[description,level distance=3cm]{ node{ Adoption der 'Children'} }
2021-01-08 11:52:10 +00:00
}
}
2021-02-09 13:29:13 +00:00
child{ node [subtopic] { Threads}
child[theme,level distance=1cm]{ node{ sequenziell innerhalb eines Prozesses} }
child[theme,level distance=3cm]{ node{ Kernel Level Thread}
child[description,level distance=1cm]{ node{ Implementiert im Betriebssystem} }
child[description,level distance=2cm]{ node{ Betriebssystem hat Kenntnis über Thread} }
child[description,level distance=3cm]{ node{ Multi-Thread-modell} }
child[description,level distance=4cm]{ node{ Performance durch Parallelität} }
child[description,level distance=5cm]{ node{ Nutzung von Mehrkern-architektur} }
2021-01-08 11:52:10 +00:00
}
2021-02-09 13:29:13 +00:00
child[theme,level distance=10cm]{ node{ User Level Thread}
child[description,level distance=1cm]{ node{ Implementiert auf Anwendungsebene} }
child[description,level distance=2cm]{ node{ Kenntnis nur bei Endbenutzer} }
child[description,level distance=3cm]{ node{ Single-Thread-Modell} }
child[description,level distance=4cm]{ node{ Performance durch geringen Overhead} }
child[description,level distance=5cm]{ node{ management ohne systemaufrufe} }
child[description,level distance=6cm]{ node{ Individualität} }
child[description,level distance=7cm]{ node{ Portabilität} }
2021-01-08 11:52:10 +00:00
}
2021-02-02 12:00:49 +00:00
} ;
2021-01-08 11:52:10 +00:00
\end { tikzpicture}
2021-02-09 13:29:13 +00:00
\end { document}
2021-01-08 11:52:10 +00:00
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Scheduling
\begin { tikzpicture} [ mindmap, grow cyclic, every node/.style=concept, concept color=green!40,
level 1/.append style={ level distance=4cm} ,
level 2/.append style={ level distance=3cm, sibling angle=30} ,
every node/.append style={ scale=0.8} ]
\node { Scheduling}
2021-01-12 12:06:23 +00:00
child { node { Aktivierung}
child{ node{ Threadzustände im 3/5 Modell}
child{ node{ bereit: kann aktiv werden} }
child{ node{ aktiv: arbeitet} }
child{ node{ blockiert: wartet auf Ereignis} }
child{ node{ frisch: erzeugt, Rechte fehlen} }
child{ node{ beendet: in Freigabephase} }
}
child{ node{ Entscheidung Überprüfen bei}
child{ node{ Prozess/Thread Erzeugung/Terminierung} }
child{ node{ Ereignis eintritt} }
child{ node{ Wechsel von Prioritäten} }
child{ node{ periodisch} }
}
}
child{ node{ Ziele}
child{ node{ abhängig von Einsatz des Betriebssystems} }
child{ node{ ergänzt durch allg Ziele} }
child{ node{ Einhaltung von Fristen} }
child{ node{ Minimieren der Thread/Prozess-wechsel} }
}
2021-01-08 11:52:10 +00:00
child { node { Scheduling Strategien}
2021-01-12 12:06:23 +00:00
child { node { Batch-System}
child{ node{ Auslastung teurer Betriebsmittel (CPU)} }
child{ node{ Minimierung der Scheduling Kosten (wenig Wechsel, kurze Laufzeiten)} }
child{ node{ Maximierung des Durchsatzes (erledigte Arbeit/Zeit)} }
child{ node{ First Come First Served}
child{ node{ in Reihenfolge der rechenbereiten} }
child{ node{ sehr einfach, guter durchsatz} }
child{ node{ nicht immer klug} }
}
child{ node{ Shortest Remaining Time Next}
child{ node{ Thread mit vorr. kürzester Restrechenzeit} }
child{ node{ preemtiv; konkurrrierende Threads verdrängen} }
child{ node{ Restlaufzeit muss vorliegen} }
}
}
child { node { Interaktives System}
child{ node{ Benutzer kann eingreifen} }
child{ node{ Minimierung von Reaktionszeiten} }
child{ node{ Fairness (mehrere Benutzer)} }
child{ node{ Round Robin Varianten}
child{ node{ jeder Thread gleicher Teil der Zeitscheibe} }
child{ node{ einfach zu implementieren} }
child{ node{ geringe Algorithmuskosten} }
child{ node{ schnelle Entscheidungen} }
child{ node{ geringes Wissen notwendig} }
}
}
}
child{ node{ Prioritäten}
child{ node{ jeder Thread erhält indv. Priorität} }
child{ node{ höchste Prioritäten erhalten Prozessor} }
child{ node{ gleiche Priorität: Round Robin} }
}
child{ node{ in Echtzeitsystemen}
child{ node{ EDF: earliest deadline first}
child{ node{ dynamische Lasten; adaptiv} }
child{ node{ Threads nennen Deadline/Frist} }
child{ node{ kausale und zeitliche Unabhängigkeit} }
child{ node{ Priorität setzt kürzere Fristen} }
}
child{ node{ RMS: rate-monotonic scheduling}
child{ node{ periodische Lasten} }
child{ node{ Threads nennen Periodendauer} }
child{ node{ kürzeste Periodendauer aktiv} }
child{ node{ statische Prioritäten} }
}
2021-01-08 11:52:10 +00:00
} ;
\end { tikzpicture}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Privilegierungsebenen
\begin { tikzpicture} [ mindmap, grow cyclic, every node/.style=concept, concept color=blue!40,
level 1/.append style={ level distance=4cm} ,
level 2/.append style={ level distance=3cm, sibling angle=30} ,
every node/.append style={ scale=0.8} ]
2021-01-12 12:06:23 +00:00
\node { Privilegierungsebenen}
child{ node{ Konzepte}
child{ node{ private Adressräume} }
child{ node{ Zugriffsschutz auf Arbeitsspeicherbereiche} }
}
child{ node{ kritische Operationen}
child{ node{ Abschalten der Uhr} }
child{ node{ Abschalten des Ereignismanagement} }
child{ node{ Veränderung des Speicherlayouts} }
child{ node{ Veränderng kritischer Prozessorkontrollregister} }
child{ node{ Zugriff auf E/A Geräte} }
}
child{ node{ P. Ebenen}
child{ node{ steuern Rechte}
child{ node{ zur Ausführung privilegierter Prozessorinstruktionen} }
child{ node{ zur Konfiguration des Arbeitsspeicher-Layouts} }
child{ node{ zum Zugriff auf Arbeitsspeicherbereiche} }
child{ node{ zum Zugriff auf E/A-Geräte} }
}
child{ node{ realisiert in Ringen (0-3)} }
}
child{ node{ Implementierung}
child{ node{ Hardware Unterstützung} }
child{ node{ Teil "Current Privilege Level" (CPL)} }
child{ node{ permantente Überwachung} }
child{ node{ Änderung der CPL beschränken} }
}
child{ node{ Botschaften}
child{ node{ P.E. < 3 ablaufende Aktivität hat Zugriff auf kritische Ressourcen} }
child{ node{ P.E. 0 ablaufende Aktivität hat Zugriff auf}
child{ node{ Ressourcen eines Prozessors} }
child{ node{ MMU-Register zur Arbeitsspeicherkonfiguration} }
child{ node{ Register der E/A-Peripherie} }
}
} ;
2021-01-08 11:52:10 +00:00
\end { tikzpicture}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Kommunikation und Synchronisation
\begin { tikzpicture} [ mindmap, grow cyclic, every node/.style=concept, concept color=yellow!40,
level 1/.append style={ level distance=4cm} ,
level 2/.append style={ level distance=3cm, sibling angle=30} ,
every node/.append style={ scale=0.8} ]
\node { Kommunikation und \\ Synchronisation}
2021-01-12 12:06:23 +00:00
child { node { Elementare Konzepte}
child{ node{ Ziel}
child{ node{ nur 1 Thread darf zu einem Zeitpunkt mit best. Speicherbereich arbeiten} }
child{ node{ erst nach beendigung, darf ein anderer Thread damit arbeiten} }
}
child{ node{ Austausch von Daten zwischen Prozessen $ \rightarrow $ Kommunikation} }
child{ node{ Abweichende Geschwindigkeiten von Sender und Empfänger $ \rightarrow $ Synchronisation} }
child{ node{ Eine Phase, in der ein Thread eine exklusive Operation auf einer Ressource ausführt, heißt kritischer Abschnitt.} }
child{ node{ Kritische Abschnitte erfordern den wechselseitigen Ausschluss (die Isolation) konkurrierender Threads bzw. Prozesse.} }
}
child { node { wechselseitiger Ausschluss}
child{ node{ Korrektheit: in kritischen Abschnitt höchstens ein Thread} }
child{ node{ Lebendigkeit: Falls ein Thread einen kritischen Abschnitt betreten möchte, dann betritt (irgendwann) ein Thread diesen Abschnitt.} }
child{ node{ Verhungerungsfreiheit: Kein Thread wartet für immer vor einem kritischen Abschnitt} }
}
2021-01-08 11:52:10 +00:00
child { node { Mechanismen}
2021-01-12 12:06:23 +00:00
child { node { (binäre) Semaphore}
child{ node{ 2 Zustände: frei, belegt} }
child{ node{ 2 atomare Operationen}
child{ node{ belegen: P} }
child{ node{ freigeben: V} }
}
child{ node{ Sämtliche Nutzer dieses kritischen Abschnitts müssen diese semaphore verwenden} }
child{ node{ Unterstützung durch Hardware: die TSL-Operation (TestAndSetLock)} }
child{ node{ Implementierung im Ressourcenmanagement} }
child{ node{ Mehrwertiger Semaphor (oder Zählsemaphor) mit mehreren Semaphoren; maximaler Sem-Wert = n, bestimmt maximale Anzahl von Threads, die gleichzeitig aktiv sein können} }
}
child { node { Hoare'sche Monitore}
child{ node{ Zusammenfassen von Daten/Operationen/Zugriff zu abstrakten Datentyp} }
child{ node{ Zugriff auf Daten über implizit synchronisierende Operation} }
child{ node{ kritischer Abschnitt und Daten in durch Monitor geschütztem Bereich} }
child{ node{ wechselseitiger Ausschluss}
child{ node{ Türsteher an Eingang \& Ausgang} }
child{ node{ Betreten nur mit Monitor Zustimmung} }
child{ node{ falls Thread in Monitor aktiv, kein weiterer rein (P)} }
child{ node{ falls Thread Monitor verlässt, Wartenden rein (V)} }
child{ node{ Threads Verlassen statt Warten im Monitor} }
}
child{ node{ je Monitor eine Semaphor} }
child{ node{ am Eingang eine P-Operation} }
child{ node{ am Ausgang eine V-Operation} }
}
2021-01-08 11:52:10 +00:00
}
child { node { weitere}
2021-01-12 12:06:23 +00:00
child { node { Trans-aktionaler Speicher}
child{ node{ keine Sperre bei Ausschluss $ \rightarrow $ Parallelität} }
child{ node{ nach Operation untersuchen auf Fehler und Korrektur} }
child{ node{ Kombination mit Transaktionen} }
}
child { node { Botschaften}
child{ node{ für Kommunikation zwischen} }
child{ node{ Prozessen innerhalb eines Systems} }
child{ node{ Anwendungsprozessen} }
child{ node{ Senden/Empfangen von Botschaften} }
child{ node{ Kommunikationsparadigma} }
}
2021-01-08 11:52:10 +00:00
child { node { Fernaufrufe (Remote Procedure Calls)} }
child { node { System-aufrufe} }
child { node { Ereignis-management} }
child { node { IPC Modell} }
child { node { pop-up-Thread-Modell} }
} ;
\end { tikzpicture}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Speichermanagement
\begin { tikzpicture} [ mindmap, grow cyclic, every node/.style=concept, concept color=orange!40,
level 1/.append style={ level distance=4cm} ,
level 2/.append style={ level distance=3cm, sibling angle=30} ,
every node/.append style={ scale=0.8} ]
2021-02-09 13:29:13 +00:00
\node { Virtueller Speicher}
child { node { Virtuelles Speichermanagement} }
child { node { Begriffe} }
child { node { Abbildung} }
child { node { Memory Management Units} }
child { node { Seiten-abbildungs-tabellen} }
child { node { Seitenaustausch-Algorithmen}
child { node { FIFO} }
child { node { Second Chance} }
child { node { Least Recently Used} }
child { node { Working Set} }
child { node { WSClock} }
2021-01-08 11:52:10 +00:00
}
;
\end { tikzpicture}
\end { document}
