diff --git a/BS Spicker.tex b/BS Spicker.tex index 60be432a95f2aeb6524a085da5a8e85e4a026090..d8982ca52bc41c7d822ff138eab8b760f5fb1514 100644 --- a/BS Spicker.tex +++ b/BS Spicker.tex @@ -71,7 +71,6 @@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands. \usepackage{lastpage} -\usepackage[cache=false]{minted} %\usemintedstyle{vs} \title{Zusammenfassung Betriebssysteme (Zapf) - SS 2021} @@ -90,6 +89,13 @@ \makeatother +\usepackage{minted} +\setminted{tabsize=2} +\addto\captionsenglish{\renewcommand{\listingscaption}{Listing}} +\addto\captionsfrench{\renewcommand{\listingscaption}{Listing}} +\addto\captionsngerman{\renewcommand{\listingscaption}{Listing}} +\renewcommand{\listingscaption}{Listing} + \begin{document} \lhead{Zusammenfassung Betriebssysteme (Zapf) - SS 2021} @@ -163,17 +169,17 @@ Prozesszustände: u.A. Infos über Prozess-Identifikation (Prozess-ID etc.), Prozesssteuerung, Prozesskontext (z.B. Registerinhalte, Speicherbereiche, Prozess-Zustand). Befindet sich in einem Bereich des Speichers der nur vom Kernmodus -angesprochen werden darf. Bsp: \mintinline{bash}{ps} bzw. Windows +angesprochen werden darf. Bsp: \mintinline{bash}!ps! bzw. Windows Task-Manager \item [{Prozesstabelle:}] Liste aller Prozesse und zugehöriger PCBs \item [{Kontextwechsel:}] Wechsel des Prozesskontexts, z.B. bei Multitasking, Interrupts, Systemaufruf \end{description} -Prozesserzeugung in Unix: \mintinline{c}|fork()| klont den aktuellen +Prozesserzeugung in Unix: \mintinline{c}!fork()! klont den aktuellen Prozess. Rückgabewert: PID des Kinds im Elternprozess, 0 im Kindprozess. -\mintinline{c}|wait(int* status)| wartet auf Beendigung eines Kindprozesses, -\mintinline{c}|waitpid(int pid, int* status, int options)| wartet +\mintinline{c}!wait(int* status)! wartet auf Beendigung eines Kindprozesses, +\mintinline{c}!waitpid(int pid, int* status, int options)! wartet auf Beendigung eines spezifischen Kindprozesses. \paragraph{Waisen und Zombies} @@ -260,19 +266,19 @@ Kommandos). \textbf{Expansionen:} {*} für 0 bis n Zeichen, ? für 1 Zeichen. -Shellskript mit \mintinline{bash}{#!/bin/bash} beginnen (hash-bang +Shellskript mit \mintinline{bash}*#!/bin/bash* beginnen (hash-bang / shebang). -\textbf{Variablen deklarieren:} \mintinline{bash}{Var=<Wert>}, Zugriff -durch \mintinline{bash}{$Var} oder \mintinline{bash}|${Var}|. +\textbf{Variablen deklarieren:} \mintinline{bash}!Var=<Wert>!, Zugriff +durch \mintinline{bash}!$Var! oder \mintinline{bash}!${Var}!. -\textbf{Mit Variablen rechnen:} \mintinline{bash}{$((Rechnung))}. +\textbf{Mit Variablen rechnen:} \mintinline{bash}!$((Rechnung))!. \textbf{Anführungszeichen:} \begin{itemize} -\item Doppelt \mintinline{bash}{"}: Variablen-Ersetzung, keine Dateinamen-Wildcard-Ersetzung -\item Einfach \mintinline{bash}{'}: Keine Ersetzung -\item Backtick \mintinline{bash}{`}: Auffassen als Befehlszeile, stdout-Ausgabe +\item Doppelt \mintinline{bash}!"!: Variablen-Ersetzung, keine Dateinamen-Wildcard-Ersetzung +\item Einfach \mintinline{bash}!'!: Keine Ersetzung +\item Backtick \mintinline{bash}!`!: Auffassen als Befehlszeile, stdout-Ausgabe des Befehls ersetzt Backtick-String. \end{itemize} \textbf{I/O-Nummerierung:} 0 - \textit{stdin}, 1 - \textit{stdout}, @@ -281,16 +287,16 @@ des Befehls ersetzt Backtick-String. I/O-Umlenkung durch \textit{<, >, 2>}; Anfügen an Datei durch \textit{>\textcompwordmark >}. Bündeln von \textit{stderr} nach \textit{stdout}: \textit{2>}\&\textit{1} -\textbf{Pipe:} \mintinline{bash}{|} (mehr siehe \nameref{par:Pipes-und-FIFOS} +\textbf{Pipe:} \mintinline{bash}!|! (mehr siehe \nameref{par:Pipes-und-FIFOS} auf Seite \pageref{par:Pipes-und-FIFOS}) -\textbf{Eingaben im Skript:} \mintinline{bash}{read varname} +\textbf{Eingaben im Skript:} \mintinline{bash}!read varname! \paragraph{Kontrollstrukturen} \begin{multicols}{2} -Bedingungen prüfen mit Befehl \mintinline{bash}{test} oder \mintinline{bash}{[ ... ]}: +Bedingungen prüfen mit Befehl \mintinline{bash}!test! oder \mintinline{bash}![ ... ]!: \begin{tabular}{|c|c|} \hline @@ -309,71 +315,77 @@ Zahl & Text\tabularnewline if: -\begin{minted}{bash} +\begin{minted}[tabsize=2]{bash} if [ <Bedingung> ] then - <Befehle> + <Befehle> elif [ <Bedingung> ] then - <Befehle> + <Befehle> else - <Befehle> + <Befehle> fi \end{minted} -%\columnbreak +\begin{comment} +\columnbreak +\end{comment} for: -\begin{minted}{bash} +\begin{minted}[tabsize=2]{bash} for <Iterator> do - <Befehle> + <Befehle> done \end{minted} Iterator-Beispiele: -\mintinline{bash}{for ((i=0; i<3; i++))} +\mintinline{bash}!for ((i=0; i<3; i++))! -\mintinline{bash}{for VAR in 1 2 3 .. 10} +\mintinline{bash}!for VAR in 1 2 3 .. 10! -\mintinline{bash}{for VAR in $VARNAME} +\mintinline{bash}!for VAR in $VARNAME! -\mintinline{bash}{for VAR in s1 s2 s3} +\mintinline{bash}!for VAR in s1 s2 s3! -\mintinline{bash}{for VAR in string{1..3}} +\mintinline{bash}!for VAR in string{1..3}! -\mintinline{bash}{for VAR in $(command)} +\mintinline{bash}!for VAR in $(command)! while: -\begin{minted}{bash} +\begin{minted}[tabsize=2]{bash} while <Bedingung> do - <Befehle> + <Befehle> done \end{minted} \end{multicols} Parameter: +% fix to use hash char in mintinline inside item command +\newsavebox\dollarhash +\begin{lrbox}{\dollarhash} +\mintinline{bash}!$#! +\end{lrbox} \begin{elabeling}{00.00.0000} -\item [{\mintinline{bash}{$0}}] Programmname -\item [{\mintinline{bash}{$n}}] n-ter Parameter -\item [{\mintinline{bash}{$*}}] alle Parameter (ab 1) → \textquotedbl\$1 +\item [{\mintinline{bash}!$0!}] Programmname +\item [{\mintinline{bash}!$n!}] n-ter Parameter +\item [{\mintinline{bash}!$*!}] alle Parameter (ab 1) → \textquotedbl\$1 \$2 \$3 \ldots{} \$n\textquotedbl{} -\item [{\mintinline{bash}{$@}}] alle Wörter (ab 1) → \textquotedbl\$1\textquotedbl{} +\item [{\mintinline{bash}!$@!}] alle Wörter (ab 1) → \textquotedbl\$1\textquotedbl{} \textquotedbl\$2\textquotedbl{} \textquotedbl\$3\textquotedbl{} \ldots{} \textquotedbl\$n\textquotedbl{} -\item [{\mintinline{bash}{$}\texttt{\textbf{\#}}}] Anzahl Parameter (ab -1) -\item [{\mintinline{bash}{$?}}] \mintinline{bash}{exit}-Code des letzten +\item [{\usebox{\dollarhash}}] Anzahl Parameter (ab 1) +\item [{\mintinline{bash}!$?!}] \mintinline{bash}!exit!-Code des letzten Kommandos \end{elabeling} -\paragraph{\mintinline{bash}{shift}} +\paragraph{\mintinline{bash}!shift!} -Parameter \mintinline{bash}{$1} wird rausgeschoben, restliche Parameterliste +Parameter \mintinline{bash}!$1! wird rausgeschoben, restliche Parameterliste rutscht nach. \section{Programmierung in C und C++} @@ -386,43 +398,50 @@ Hallo Welt in C: #include <stdio.h> int main() { - printf("Hallo Welt!\n"); - return 0; + printf("Hallo Welt!\n"); + return 0; } \end{minted} -\mintinline{c}{#include}: Präprozessor-Anweisung, bindet Datei an +\mintinline{c}!#include!: Präprozessor-Anweisung, bindet Datei an diese Stelle ein. \paragraph{Wichtigste Datentypen:} -\mintinline{c}{char}, \mintinline{c}{int}, \mintinline{c}{long}. +\mintinline{c}!char!, \mintinline{c}!int!, \mintinline{c}!long!. String als char-Zeiger oder char-Feld. -\textbf{Adressoperator \mintinline{c}{&}}: Liefert die Adresse einer +\textbf{Adressoperator }\mintinline{c}!&!: Liefert die Adresse einer Variablen. \paragraph{Zeiger:} Zeigen auf eine Speicherstelle. Initialisierung: -\mint{c}{int* zeiger = &meinezahl;} +\begin{minted}{c} +int* zeiger = &meinezahl; +\end{minted} Vom Zeiger zum Wert: Dereferenzieren: -\mint{c}{printf(*zeiger);} +\begin{minted}{c} +printf(*zeiger); +\end{minted} + \paragraph{Felder (Arrays):} Initialisierung: -\mint{c}{int meinfeld[10];} +\begin{minted}{c} +int meinfeld[10]; +\end{minted} Zugriff auf Werte: -\mintinline{c}{meinfeld[i]} oder \mintinline{c}{*(meinfeld + i)}. +\mintinline{c}!meinfeld[i]! oder \mintinline{c}!*(meinfeld + i)!. -Ausgaben: \mintinline{c}{printf()} aus stdio.h. Nimmt Formatstring +Ausgaben: \mintinline{c}!printf()! aus stdio.h. Nimmt Formatstring und beliebig viele Argumente entgegen. Wichtigste Formate: @@ -443,13 +462,14 @@ Hallo Welt in C++: \begin{minted}{c++} #include<iostream> int main(){ - std::cout << "Hallo Welt!" << std::endl; - //Wenn das std:: nervt: - using namespace std; - cout << "Hallo Welt!" << endl; + std::cout << "Hallo Welt!" << std::endl; + // Wenn das std:: nervt: + using namespace std; + cout << "Hallo Welt!" << endl; } \end{minted} + \paragraph{Klassen:} Syntax ähnlich zu C\#, nur die Zugriffsrechte werden etwas anders @@ -458,15 +478,15 @@ definiert. \begin{comment} \begin{minted}{c++} class meineKlasse{ - private: - /*Private Member*/ - public: - /*Öffentliche Member*/ + private: + /*Private Member*/ + public: + /*Öffentliche Member*/ }; \end{minted} -Zugriff auf Instanzvariablen via Zeiger geht so: \mintinline{c++}{meins -> sagHallo("du");} -oder umständlich auch so: \mintinline{c++}{(*meins).sagHallo("du");} +Zugriff auf Instanzvariablen via Zeiger geht so: \mintinline{c}!meins -> sagHallo("du");! +oder umständlich auch so: \mintinline{c}!(*meins).sagHallo("du");! \end{comment} Konstruktor: Funktioniert wie bei C\# @@ -477,7 +497,7 @@ Syntax: \begin{minted}{c++} ~meineKlasse(){ - std::cout << "Tschüss!" << std::endl; + std::cout << "Tschüss!" << std::endl; } \end{minted} \end{comment} @@ -487,12 +507,12 @@ zurückzugeben (Speicherlöcher verhindern!) \paragraph{Erzeugen von Objekten:} \begin{itemize} -\item Statisch: \mintinline{c++}{meineKlasse meins;} +\item Statisch: \mintinline{c}!meineKlasse meins;! \item Dynamisch:\\ -\mintinline{c++}{meineKlasse* meins = new meineKlasse(Args);} +\mintinline{c}!meineKlasse* meins = new meineKlasse(Args);! \end{itemize} Achtung: Dynamisch erzeugte Objekte müssen explizit gelöscht werden: -\mintinline{c++}{delete meins;} +\mintinline{c}!delete meins;! \begin{comment} @@ -500,41 +520,41 @@ Achtung: Dynamisch erzeugte Objekte müssen explizit gelöscht werden: \begin{minted}{c++} class meineKlasse:public Superklasse{ - public: - void sagHallo(const char* name){ - ... - } - void vorstellen(){ - ... - } + public: + void sagHallo(const char* name){ + ... + } + void vorstellen(){ + ... + } }; class Superklasse{ - public: - void sagHallo(const char* name){ - ... - } - virtual void sagTschüss(const char* name){ - ... - } - //rein virtelle Funktion, - //muss von Kindern implementiert werden! - virtual void vorstellen() = 0; + public: + void sagHallo(const char* name){ + ... + } + virtual void sagTschüss(const char* name){ + ... + } + // rein virtelle Funktion, + // muss von Kindern implementiert werden! + virtual void vorstellen() = 0; }; int main(){ - Superklasse* test = new meineKlasse(); - test -> sagHallo("du"); - // ruft sagHallo in Superklasse auf, - // weil ein Superklasse-Zeiger benutzt wird. - test -> sagTschüss("du"); - // ruft sagTschüss in meineKlasse auf, - // da in der Superklasse als virtual gekenn- - // zeichnet und in der Kindklasse implementiert. - test -> vorstellen(); - // ruft vorstellen in meineKlasse auf, - // da die Superklasse gar keine Implementierung - // bereit stellt. + Superklasse* test = new meineKlasse(); + test -> sagHallo("du"); + // ruft sagHallo in Superklasse auf, + // weil ein Superklasse-Zeiger benutzt wird. + test -> sagTschüss("du"); + // ruft sagTschüss in meineKlasse auf, + // da in der Superklasse als virtual gekenn- + // zeichnet und in der Kindklasse implementiert. + test -> vorstellen(); + // ruft vorstellen in meineKlasse auf, + // da die Superklasse gar keine Implementierung + // bereit stellt. } \end{minted} \end{comment} @@ -969,7 +989,7 @@ Software-Interrupt: Interrupt wird durch Programm ausgelöst, z.B. durch int-Maschinenbefehl. -Systemaufruf: \mintinline{gas}{int 0x80} +Systemaufruf: \mintinline{gas}!0x80! \begin{comment} @@ -1020,7 +1040,7 @@ Prozesse geben ab und an freiwillig die Kontrolle ab. Prozessen wird durch regelmäßige Interrupts die Kontrolle entrissen, nach gewisser Zeit wechselt das Betriebssystem die Prozesse ab (,,\textbf{Zeitscheibe}``). -Zeitscheibe in Linux standardmäßig 100ms, kann mit \mintinline{bash}{nice -n <Wert> <Befehlszeile>} +Zeitscheibe in Linux standardmäßig 100ms, kann mit \mintinline{bash}!nice -n <Wert> <Befehlszeile>! beeinflusst werden. Wert geht von -20 (größte Zeitscheibe) bis +19 (kleinste Zeitscheibe). @@ -1402,33 +1422,33 @@ Programmierunterstützung: \begin{itemize} \item C \begin{itemize} -\item Semaphor: Bibliothek \mintinline{c}{semaphore.h} mit Funktionen \mintinline{c}{sem_init}, -\mintinline{c}{sem_wait} (P, down) und \mintinline{c}{sem_post} +\item Semaphor: Bibliothek \mintinline{c}!semaphore.h! mit Funktionen \mintinline{c}!sem_init!, +\mintinline{c}!sem_wait! (P, down) und \mintinline{c}!sem_post! (V, up). -\item Mutex: In Bibliothek \mintinline{c}{pthread.h} mit Funktionen \mintinline{c}{pthread_mutex_init}, -\mintinline{c}{pthread_mutex_destroy}, \mintinline{c}{pthread_mutex_(try)lock} -und \mintinline{c}{pthread_mutex_unlock}. -\item CV: Bibliothek \mintinline{c}{pthread.h} mit Funktionen \mintinline{c}{pthread_cond_init}, -\mintinline{c}{pthread_cond_destroy}, \mintinline{c}{pthread_cond_(timed)wait}, -\mintinline{c}{pthread_cond_signal} (weckt einen wartenden Thread) -und \mintinline{c}{pthread_cond_broadcast} (weckt alle wartenden +\item Mutex: In Bibliothek \mintinline{c}!pthread.h! mit Funktionen \mintinline{c}!pthread_mutex_init!, +\mintinline{c}!pthread_mutex_destroy!, \mintinline{c}!pthread_mutex_(try)lock! +und \mintinline{c}!pthread_mutex_unlock!. +\item CV: Bibliothek \mintinline{c}!pthread.h! mit Funktionen \mintinline{c}!pthread_cond_init!, +\mintinline{c}!pthread_cond_destroy!, \mintinline{c}!pthread_cond_(timed)wait!, +\mintinline{c}!pthread_cond_signal! (weckt einen wartenden Thread) +und \mintinline{c}!pthread_cond_broadcast! (weckt alle wartenden Threads). \end{itemize} \item C++ \begin{itemize} -\item Semaphor: Bibliothek \mintinline{c++}{semaphor} mit Klasse \mintinline{c++}{binary_semaphore} -(Mutex) oder \mintinline{c++}{counting_semaphore} (C++ 20 oder neuer). -\item Mutex: Bibliothek \mintinline{c++}{mutex} mit Klassen \mintinline{c++}{mutex} -oder \mintinline{c++}{timed_mutex} und Methoden \mintinline{c++}{lock}, -\mintinline{c++}{tryLock} und \mintinline{c++}{unlock} (bei timed\_mutex -noch \mintinline{c++}{try_lock_for(t)} und \mintinline{c++}{try_lock_until(t)}). -\item Wrapper-Klassen \mintinline{c++}{lock_guard<mutex>} und \mintinline{c++}{unique_lock<mutex>} +\item Semaphor: Bibliothek \mintinline{c++}!semaphor! mit Klasse \mintinline{c++}!binary_semaphore! +(Mutex) oder \mintinline{c++}!counting_semaphore! (C++ 20 oder neuer). +\item Mutex: Bibliothek \mintinline{c++}!mutex! mit Klassen \mintinline{c++}!mutex! +oder \mintinline{c++}!timed_mutex! und Methoden \mintinline{c++}!lock!, +\mintinline{c++}!tryLock! und \mintinline{c++}!unlock! (bei timed\_mutex +noch \mintinline{c++}!try_lock_for(t)! und \mintinline{c++}!try_lock_until(t)!). +\item Wrapper-Klassen \mintinline{c++}!lock_guard<mutex>! und \mintinline{c++}!unique_lock<mutex>! belegen den im Konstruktor angegebenen Mutex und geben ihn im Destruktor frei. Unlock kann nicht vergessen werden. -\item CV: Bibliothek \mintinline{c++}{condition_variable} mit gleichnamiger -Klasse und Methoden \mintinline{c++}{wait(lck)}, \mintinline{c++}{wait_for(...)}, -\mintinline{c++}{wait_until(...)}, \mintinline{c++}{notify_one} -und \mintinline{c++}{notify_all}. +\item CV: Bibliothek \mintinline{c++}!condition_variable! mit gleichnamiger +Klasse und Methoden \mintinline{c++}!wait(lck)!, \mintinline{c++}!wait_for(...)!, +\mintinline{c++}!wait_until(...)!, \mintinline{c++}!notify_one! +und \mintinline{c++}!notify_all!. \end{itemize} \end{itemize} Mit Mutex, Unique Lock und CV können alle Synchronisationsmechanismen @@ -1523,7 +1543,7 @@ beim Schreiben der Pipe-Puffer voll ist). Varianten: \begin{itemize} \item unbenannte Pipe: z.B. durch | in der Shell. -\item benannte Pipe: durch \mintinline{bash}{mkfifo pipename}, danach können +\item benannte Pipe: durch \mintinline{bash}!mkfifo pipename!, danach können Ein-und Ausgaben durch die < und > Operatoren aus der Pipe gelesen oder rein geschrieben werden. Zum Reinschreiben müssen aber beide Seiten angeschlossen sein!% @@ -1549,7 +1569,7 @@ und mq\_receive. Nur in Unix verfügbar, einfache und effiziente, asynchrone IPC. -Prozesse können anderen Prozessen ein Signal senden (\mintinline{bash}{kill(pid, signalId)}), +Prozesse können anderen Prozessen ein Signal senden (\mintinline{bash}!kill(pid, signalId)!), wenn sie die Berechtigung dazu haben. Prozesse können Signal-Handler registrieren, die aufgerufen werden,