From 882eb660fe2832a47a73738c4684469c751fc09d Mon Sep 17 00:00:00 2001
From: oppmannma79054 <oppmannma79054@th-nuernberg.de>
Date: Mon, 23 Jan 2023 15:27:48 +0100
Subject: [PATCH] re-export latex
bc. of the Listing change, the listings delimiter has also changed in the LyX export
---
BS Spicker.tex | 252 ++++++++++++++++++++++++++-----------------------
1 file changed, 136 insertions(+), 116 deletions(-)
diff --git a/BS Spicker.tex b/BS Spicker.tex
index 60be432..d8982ca 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,
--
GitLab