diff --git a/20221109/es-20221109.pdf b/20221109/es-20221109.pdf
index ec2e9ed6798855bd38bb6fdc250db0a6a3f68e1b..b8071b3d59fdc9290833e5e249dd00007da0c502 100644
Binary files a/20221109/es-20221109.pdf and b/20221109/es-20221109.pdf differ
diff --git a/20221109/es-20221109.tex b/20221109/es-20221109.tex
index a34d71e388ba0d36e1506575bb60efaf4313e98e..0290c1ae648c773f1baf3deb5674a510edcfa421 100644
--- a/20221109/es-20221109.tex
+++ b/20221109/es-20221109.tex
@@ -20,7 +20,7 @@
% Attribution-ShareAlike 3.0 Unported License along with this
% document. If not, see <http://creativecommons.org/licenses/>.
-% README: VNC, Netzwerkanalyse, Netzwerkprogrammierung
+% README: VNC, Netzwerkanalyse, Netzwerkprogrammierung, Bus-Systeme
\documentclass[10pt,t]{beamer}
@@ -36,7 +36,7 @@
\title{Eingebettete Systeme}
\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{2.\ November 2022}
+\date{9.\ November 2022}
\newcommand{\greyurl}[1]{\href{#1}{\color{gray}\nolinkurl{#1}}}
\newcommand{\ItwoC}{I\raisebox{0.5ex}{\footnotesize 2}C}
diff --git a/20221116/I2C_data_transfer.pdf b/20221116/I2C_data_transfer.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..73e7ce07770a0599ae1a2aa11e97899767a1f9b0
--- /dev/null
+++ b/20221116/I2C_data_transfer.pdf
@@ -0,0 +1 @@
+../common/I2C_data_transfer.pdf
\ No newline at end of file
diff --git a/20221116/Retribution_Engine_Screenshot_120807.jpg b/20221116/Retribution_Engine_Screenshot_120807.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..19f4cb3e4aae1e24c3466a25b2c0e5ad90ee49e7
--- /dev/null
+++ b/20221116/Retribution_Engine_Screenshot_120807.jpg
@@ -0,0 +1 @@
+../common/Retribution_Engine_Screenshot_120807.jpg
\ No newline at end of file
diff --git a/20221116/SPI_single_slave.pdf b/20221116/SPI_single_slave.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b51d59e51fffb101086bfaa811370f66436127e7
--- /dev/null
+++ b/20221116/SPI_single_slave.pdf
@@ -0,0 +1 @@
+../common/SPI_single_slave.pdf
\ No newline at end of file
diff --git a/20221116/SPI_three_slaves.pdf b/20221116/SPI_three_slaves.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b2e27257652bbefd9e1c9194ac1f518a43c8aa15
--- /dev/null
+++ b/20221116/SPI_three_slaves.pdf
@@ -0,0 +1 @@
+../common/SPI_three_slaves.pdf
\ No newline at end of file
diff --git a/20221116/SPI_three_slaves_daisy_chained.pdf b/20221116/SPI_three_slaves_daisy_chained.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..967389aeed788b2fed87b2a6b25a5ebd8256978f
--- /dev/null
+++ b/20221116/SPI_three_slaves_daisy_chained.pdf
@@ -0,0 +1 @@
+../common/SPI_three_slaves_daisy_chained.pdf
\ No newline at end of file
diff --git a/20221116/Telefon_t-sinus-700.jpg b/20221116/Telefon_t-sinus-700.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..27c322c50b0f05edc8b07cfb0cc99b1876eb506d
--- /dev/null
+++ b/20221116/Telefon_t-sinus-700.jpg
@@ -0,0 +1 @@
+../common/Telefon_t-sinus-700.jpg
\ No newline at end of file
diff --git a/20221116/Zeichen_123.pdf b/20221116/Zeichen_123.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..fdbc897227df059cfda790a16555e6e417682116
--- /dev/null
+++ b/20221116/Zeichen_123.pdf
@@ -0,0 +1 @@
+../common/Zeichen_123.pdf
\ No newline at end of file
diff --git a/20221116/a380.jpg b/20221116/a380.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..33a5d1fd18843bf7385e5a6d90f69af9fd8720da
--- /dev/null
+++ b/20221116/a380.jpg
@@ -0,0 +1 @@
+../common/a380.jpg
\ No newline at end of file
diff --git a/20221116/curiosity.jpg b/20221116/curiosity.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..4452844da537414b751c5283ca8468b3ced9afb3
--- /dev/null
+++ b/20221116/curiosity.jpg
@@ -0,0 +1 @@
+../common/curiosity.jpg
\ No newline at end of file
diff --git a/20221116/dsc_8208.jpg b/20221116/dsc_8208.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..5796341ebc774aa09965a3a29854c65ce1144fb8
--- /dev/null
+++ b/20221116/dsc_8208.jpg
@@ -0,0 +1 @@
+../common/dsc_8208.jpg
\ No newline at end of file
diff --git a/20221116/es-20221116.pdf b/20221116/es-20221116.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..b8091c9b1d1b7dcf257b68f9eea747aa39b4fd59
Binary files /dev/null and b/20221116/es-20221116.pdf differ
diff --git a/20221116/es-20221116.tex b/20221116/es-20221116.tex
new file mode 100644
index 0000000000000000000000000000000000000000..4bb4f9424a442c3d1c571f0c752cdbbfd1ca2b83
--- /dev/null
+++ b/20221116/es-20221116.tex
@@ -0,0 +1,2126 @@
+% es-20221116.pdf - Lecture Slides on Embedded Systems
+% Copyright (C) 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document. If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document. If not, see <http://creativecommons.org/licenses/>.
+
+% README: Bus-Systeme: SPI, PWM, Sonstiges; Echtzeit
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{rotating}
+\usepackage{tikz}
+\usepackage[obeyfamily=false,mathrm=mathsf,textrm=sffamily]{siunitx}
+
+\newcommand{\underconstruction}{%
+ \begin{picture}(0,0)
+ \put(9,0.9){\makebox(0,0)[b]{\includegraphics[width=1.5cm]{Zeichen_123.pdf}}}
+ \put(9,0.6){\makebox(0,0)[t]{\shortstack{Änderungen\\vorbehalten}}}
+ \end{picture}}
+
+\title{Eingebettete Systeme}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{16.\ November 2022}
+
+\newcommand{\greyurl}[1]{\href{#1}{\color{gray}\nolinkurl{#1}}}
+\newcommand{\ItwoC}{I\raisebox{0.5ex}{\footnotesize 2}C}
+
+\begin{document}
+
+\maketitleframe
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+ \shownosectionnonumber
+
+ \begin{itemize}
+ \item[\textbf{1}] \textbf{Einführung}
+ \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/es}}}%
+ \item[\textbf{2}] \textbf{Einführung in Unix}
+ \item[\textbf{3}] \textbf{TCP/IP in der Praxis}
+ \begin{itemize}
+ \vspace{-\smallskipamount}
+ \item [\dots]
+ \color{medgreen}
+ \item [3.6] Netzwerkanalyse
+ \color{black}
+ \item [3.7] SSH
+ \item [3.8] X11 und VNC
+ \color{medgreen}
+ \item[3.9] Programmierung
+ \end{itemize}
+ \item[\textbf{4}] \textbf{Bus-Systeme}
+ \begin{itemize}
+ \color{medgreen}
+ \item[4.1] Was sind Bus-Systeme?
+ \item[4.1] RS-232
+ \item[4.1] \ItwoC\ (TWI)
+ \color{red}
+ \item[4.1] SPI
+ \item[4.1] PWM
+ \item[4.1] Sonstiges
+ \end{itemize}
+ \item[\textbf{\dots}]
+ \end{itemize}
+% \strut\hfill \url{https://www.peter.gerwinski.de/download/net-2013ss.tar.gz}
+
+% \vspace*{-1cm plus 1filll}
+
+% \underconstruction
+
+\end{frame}
+
+\setcounter{section}{2}
+\section{TCP/IP in der Praxis}
+
+\setcounter{subsection}{5}
+\subsection{Netzwerkanalyse}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ \begin{itemize}
+ \item
+ \lstinline[style=cmd]{tcpdump}
+ \item
+ \lstinline[style=cmd]{wireshark}
+ \item
+ \lstinline[style=cmd]{ettercap}
+ \end{itemize}
+
+\end{frame}
+
+\setcounter{subsection}{8}
+\subsection{Programmierung}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Beispiel: Programmierung eines VNC-Servers per Web-Interface
+
+ \begin{itemize}
+ \item
+ Grundlagen: RFC~6143
+ \item
+ Praxis: Untersuchung mit Wireshark
+ \item
+ Implementation: JavaScript, WebSockets, \file{websockify}, Callbacks
+ \end{itemize}
+
+ \bigskip
+
+ Weitere Beispiele:
+
+ \begin{itemize}
+ \item
+ Shell-Skripte: \file{nc} (\file{traditional} oder \file{OpenBSD})
+ \item
+ C: Sockets, \lstinline{select()}
+ \item
+ C++: Callbacks
+ \end{itemize}
+
+\end{frame}
+
+\section{Bus-Systeme}
+\subsection{Was sind Bus-Systeme?}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+
+ \begin{quote}
+ Ein Bus ist ein System zur Datenübertragung zwischen mehreren
+ Teilnehmern über einen gemeinsamen Übertragungsweg.
+ \color{gray}
+ Findet eine Datenübertragung zwischen zwei Teilnehmern statt, so
+ müssen die übrigen Teilnehmer schweigen, da sie sich sonst
+ gegenseitig stören würden. Umgangssprachlich werden mitunter --
+ oft aus historischen Gründen – auch Datenübertragungssysteme als
+ "`Bus"' bezeichnet, die technisch eigentlich eine andere
+ Topologie besitzen.
+
+ \medskip
+
+ \strut\hfill\url{https://de.wikipedia.org/wiki/Bus_(Datenverarbeitung)}
+ \end{quote}
+ Beispiele:
+ \begin{itemize}
+ \item
+ Computer kommuniziert mit Peripherie
+ \item
+ Computer kommunizieren (direkt) miteinander
+ \item
+ Prozessor kommuniziert mit externem Speicher
+ \item
+ Teile eines Prozessors kommunizieren miteinander
+ \end{itemize}
+\end{frame}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+ Standard-Personal-Computer:
+ \begin{itemize}
+ \item
+ Einsteckkarten: PCI (und Vorgänger)
+ \item
+ Festplatten: SATA (und Vorgänger)
+ \item
+ USB, FireWire, \dots
+ \item
+ Ethernet, CAN-Bus, \dots
+ \item
+ WLAN, BlueTooth, IR, \dots
+ \item
+ PS/2, RS-232, Centronics
+ \end{itemize}
+
+ \medskip
+
+ \begin{visibleenv}<2->
+ Minimal-Hardware:
+ \begin{itemize}
+ \item
+ RS-232
+ \item
+ \ItwoC\ (TWI)
+ \item
+ SPI
+ \end{itemize}
+ \end{visibleenv}
+
+ \begin{onlyenv}<1>
+ \begin{picture}(0,0)
+ \put(5,1.5){\includegraphics[height=3cm]{motherboard-anschluesse.jpg}}
+ \end{picture}
+ \end{onlyenv}
+ \begin{onlyenv}<2>
+ \begin{picture}(0,0)(-1.3,-4)
+ \put(1.8,-4.9){\includegraphics[height=3.5cm]{kompassmodul-an-roboter.jpg}}
+ \put(6.1,-3.3){\includegraphics[height=4.5cm]{kompassmodul.jpg}}
+ \put(6.1,1.2){\makebox(0,0)[tr]{\tikz{\draw(0,0)--(-1.9,-3.6);}}}
+ \put(6.1,-3.3){\makebox(0,0)[br]{\tikz{\draw(0,0)--(-1.8,0.2);}}}
+ \end{picture}
+ \end{onlyenv}
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsection
+ \showsubsection
+
+ \vspace*{-\bigskipamount}
+ \begin{tabbing}
+ \newterm{Punkt-zu-Punkt}\quad\=\kill
+ \newterm{seriell} \> jedes Bit einzeln übertragen\\
+ \newterm{parallel} \> mehrere Bits gleichzeitig\\[\smallskipamount]
+ \newterm{synchron} \> Abgleich über Steuerleitung: \newterm{Takt}\\
+ \newterm{asynchron} \> Abgleich über Zeitvereinbarungen\\[\smallskipamount]
+ \newterm{Punkt-zu-Punkt} \> genau zwei Teilnehmer\\
+ \newterm{busfähig} \> mehrere Teilnehmer, mit \newterm{Adressierung}
+ \end{tabbing}
+
+ \begin{itemize}
+ \item
+ \ItwoC: seriell, synchron, mit Adressierung
+ \item
+ RS-232: seriell, asynchron, Punkt-zu-Punkt
+ \item
+ RS-485, USB, CAN: seriell, asynchron, mit Adressierung
+ \item
+ SPI: seriell, synchron, Punkt-zu-Punkt oder mit Adressierung
+ \end{itemize}
+
+\end{frame}
+
+\subsection{RS-232}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+
+ seriell
+ \begin{itemize}
+ \item
+ \newterm{TX\/}: 1 Leitung für Daten
+ \item
+ \newterm{RX\/}: ggf.\ 1 Leitung für Daten in der anderen Richtung
+ \item
+ \newterm{GND\/}: gemeinsame \newterm{Masse}
+ \item
+ evtl.\ zusätzliche Steuerleitungen
+ \end{itemize}
+
+ \medskip
+
+ asynchron
+ \begin{itemize}
+ \item
+ \emph{keine\/} Taktleitung für Abgleich, wann Daten anliegen
+ \item
+ Stattdessen: Abgleich über Zeitvereinbarungen
+ \arrowitem
+ Jeder Teilnehmer braucht eine eigene Zeitbasis.
+ \end{itemize}
+
+ \medskip
+
+ Punkt-zu-Punkt
+ \begin{itemize}
+ \item
+ nur 2 Teilnehmer vorgesehen
+ \end{itemize}
+\end{frame}
+
+\begin{frame}
+ \showsubsection
+ \vspace*{-0.35cm}
+ \begin{center}
+ \includegraphics[scale=0.9]{rs-232.pdf}
+ \end{center}
+\end{frame}
+
+\subsection{\protect\ItwoC\ (TWI)}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+
+ \ItwoC\ = Inter-IC; TWI = Two-Wire-Interface
+
+ \medskip
+
+ seriell
+ \begin{itemize}
+ \item
+ \newterm{SDA\/}: 1 Leitung für Daten (in beiden Richtungen)
+ \item
+ \newterm{SCL\/}: Taktleitung (Clock)
+ \item
+ \newterm{GND\/}: gemeinsame Masse
+ \item
+ evtl.\ \newterm{VCC\/}: Stromversorgung für Peripheriegerät
+ \end{itemize}
+
+ \medskip
+
+ synchron
+ \begin{itemize}
+ \item
+ Abgleich über\\Taktleitung
+ \begin{picture}(0,0)
+ \put(0.4,-0.4){\includegraphics[width=9.7cm]{I2C_data_transfer.pdf}}
+ \end{picture}
+ \end{itemize}
+
+ \medskip
+
+ busfähig
+ \begin{itemize}
+ \item
+ \newterm{Master\/} initiiert Kommuniation und steuert Taktleitung
+ \item
+ erstes gesendetes Byte: \newterm{Adresse\/} des Teilnehmers
+ \item
+ 2 Adressen pro Teilnehmer: Lesen/Schreiben
+ \end{itemize}
+ \vspace*{-1cm}
+\end{frame}
+
+\subsection{SPI}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+
+ Serial Peripheral Interface
+
+ \medskip
+
+ seriell
+ \begin{itemize}
+ \item
+ \newterm{MOSI\/}: Master Out, Slave In
+ \item
+ \newterm{MISO\/}: Master In, Slave Out
+ \item
+ \newterm{SCLK\/}: Taktleitung (Clock)
+ \item
+ \newterm{$\overline{\text{SS}}$\/}: Slave Select (invertiert)
+ \item
+ \newterm{GND\/}: gemeinsame Masse
+ \item
+ evtl.\ \newterm{VCC\/}: Stromversorgung für Peripheriegerät
+ \end{itemize}
+
+ \medskip
+
+ synchron
+ \begin{itemize}
+ \item
+ Abgleich über Taktleitung
+ \end{itemize}
+
+ \medskip
+
+ busfähig
+ \begin{itemize}
+ \item
+ \newterm{Master\/} initiiert Kommuniation und steuert Taktleitung
+ \item
+ \newterm{Slave\/} wird über \newterm{Slave Select\/} ausgewählt
+ \begin{picture}(0,0)(0,-0.2)
+ \only<1>{\put(-2.175,2.875){\includegraphics[scale=0.7]{SPI_single_slave.pdf}}}
+ \only<2>{\put(-2.0,3.0){\includegraphics[scale=0.7]{SPI_three_slaves.pdf}}}
+ \only<2>{\put(2.55,3.1){\begin{minipage}[t]{2.5cm}
+ \newterm{Stern}
+ \end{minipage}}}
+ \only<3->{\put(-2.0,3.0){\includegraphics[scale=0.7]{SPI_three_slaves_daisy_chained.pdf}}}
+ \only<3->{\put(2.55,3.1){\begin{minipage}[t]{2.5cm}
+ \newterm{Kaskade}\\
+ \newterm{Daisy Chain}\pause[4]\par\smallskip
+ \setlength{\leftskip}{-3.5cm}\small
+ Slave gibt MOSI-Input um 1 Takt verzögert
+ an MISO aus \textarrow\ Master setzt
+ "`im richtigen Moment"' $\overline{\text{SS}}$
+ \end{minipage}}}
+ \end{picture}
+ \end{itemize}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\subsection{PWM}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+
+ Pulsweitenmodulation -- \emph{pulse-width modulation}
+
+ \begin{itemize}
+ \item
+ Steuerung von Motoren
+ \item
+ Nutzung als allgemeines Protokoll\\
+ zur Übertragung analoger Werte
+ \end{itemize}
+\end{frame}
+
+\subsection{Sonstiges}
+
+\begin{frame}
+ \showsection
+ \showsubsection
+
+ Matrix-Schaltung
+ \begin{itemize}
+ \item
+ möglichst viele Aktoren/Sensoren\\
+ über möglichst wenige digitals Inputs abfragen\\
+ bzw.\ über möglichst wenige digitale Outputs steuern
+ \item
+ Beispiele: LED-Felder, Tastaturen
+ \end{itemize}
+
+ \pause
+ \bigskip
+
+ R/2R-Netzwerk
+ \begin{itemize}
+ \item
+ möglichst viele digitale Inputs\\
+ über einen einzigen analogen Input abfragen
+ \item
+ Beispiele: Tastaturen
+ \end{itemize}
+
+\end{frame}
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+ \shownosectionnonumber
+
+ \begin{itemize}
+ \item[\textbf{1}] \textbf{Einführung}
+ \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/es}}}%
+ \item[\textbf{2}] \textbf{Einführung in Unix}
+ \item[\textbf{3}] \textbf{TCP/IP in der Praxis}
+ \item[\textbf{4}] \textbf{Bus-Systeme}
+ \begin{itemize}
+ \item[4.1] Was sind Bus-Systeme?
+ \item[4.1] RS-232
+ \item[4.1] \ItwoC\ (TWI)
+ \color{medgreen}
+ \item[4.1] SPI
+ \item[4.1] PWM
+ \item[4.1] Sonstiges
+ \end{itemize}
+ \item[\textbf{6}] \textbf{Echtzeit}
+ \begin{itemize}
+ \color{red}
+ \item[6.1] Was ist Echtzeit?
+ \item[6.2] Echtzeitprogrammierung
+ \color{black}
+ \item[6.3] Multitasking
+ \item[6.4] Ressourcen
+ \item[6.5] Prioritäten
+ \end{itemize}
+ \end{itemize}
+
+ \vspace*{-2cm}
+ \underconstruction
+
+\end{frame}
+
+\section{Echtzeit}
+
+\subsection{Was ist Echtzeit?}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ \begin{itemize}
+ \pause
+ \item
+ Animation in Echtzeit:\\
+ schnelle Berechnung anstatt Wiedergabe einer Aufzeichnung
+ \pause
+ \medskip
+ \item
+ Fantasy-Rollenspiel in Echtzeit:\\
+ Der Zeitverlauf der Spielwelt entspricht dem der realen Welt.
+ \pause
+ \medskip
+ \item
+ Datenverarbeitung in Echtzeit:\\
+ Die Daten werden so schnell verarbeitet, wie sie anfallen.
+ \pause
+ \medskip
+ \item
+ speziell: Echtzeit-Steuerung von Maschinen:\\
+ Die Berechnung kann mit den physikalischen Vorgängen schritthalten.
+ \pause
+ \bigskip
+ \arrowitem
+ "`Schnell genug."'
+ \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsubsection
+
+ "`Schnell genug."' \pause-- "`Und wenn nicht?"'
+
+ \pause
+
+ \begin{itemize}
+ \item
+ "`Ganz schlecht."' \pause\textarrow\ \newterm{harte Echtzeit}
+ \begin{onlyenv}<4-8>
+ \begin{picture}(0,0)(0,-0.3)
+ \pause
+ \put(0,-4){\makebox(0,0)[br]{\includegraphics[height=3.5cm]{a380.jpg}}}
+ % http://de.wikipedia.org/w/index.php?title=Datei:Airbus_A380_overfly.jpg&filetimestamp=20111223141606
+ \pause
+ \put(0.2,-3.9){\makebox(0,0)[bl]{\includegraphics[height=4.0cm]{quadrocopter.jpg}}}
+ %\put(0.2,-3.5){\makebox(0,0)[bl]{\includegraphics[height=3.5cm]{mercedes-benz-w116.jpg}}}
+ % http://commons.wikimedia.org/wiki/File:1973-1980_Mercedes-Benz_450_SEL_%28W116%29_sedan_%282010-12-28%29_01.jpg
+ \pause
+ \put(-0.5,-4.2){\makebox(0,0)[tr]{\includegraphics[height=3.5cm]{herzschrittmacher.jpg}}}
+ % http://de.wikipedia.org/w/index.php?title=Datei:Pacemaker_GuidantMeridianSR.jpg&filetimestamp=20051203173642
+ \pause
+ \put(0,-4){\makebox(0,0)[tl]{\includegraphics[height=3.5cm]{curiosity.jpg}}}
+ % http://mars.jpl.nasa.gov/msl/news/whatsnew/index.cfm?FuseAction=ShowNews&NewsID=1344
+ \end{picture}
+ \end{onlyenv}
+ \pause\\[2pt]
+ rechtzeitiges Ergebnis funktionsentscheidend
+
+ \smallskip
+
+ \pause
+ \item
+ "`Unschön."' \textarrow\ \newterm{weiche Echtzeit}
+ \begin{onlyenv}<10-12>
+ \begin{picture}(0,0)(0,0.3)
+ \pause
+ \put(0,-4){\makebox(0,0)[br]{\includegraphics[width=5cm]{Retribution_Engine_Screenshot_120807.jpg}}}
+ % http://en.wikipedia.org/wiki/File:Retribution_Engine_Screenshot_120807.jpg
+ \pause
+ \put(0.1,-4.5){\makebox(0,0)[bl]{\includegraphics[width=5cm]{Telefon_t-sinus-700.jpg}}}
+ % http://de.wikipedia.org/w/index.php?title=Datei:Telefon_t-sinus-700.jpg&filetimestamp=20050807203655
+ \end{picture}
+ \end{onlyenv}
+ \pause\\[2pt]
+ verspätetes Ergebnis qualitätsmindernd
+ \begin{itemize}
+ \baselineskip14pt\par
+ \item
+ verwenden und Verzögerung in Kauf nehmen
+ \item
+ verwerfen und Ausfall in Kauf nehmen
+ \end{itemize}
+
+ \smallskip
+
+ \pause
+ \item
+ "`Es gibt keinen festen Termin. Möglichst schnell halt."'\pause\\[2pt]
+ \textarrow\ \newterm{keine Echtzeit}
+ \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Das Problem:
+ \vspace{-\bigskipamount}
+ \begin{center}
+ \begin{picture}(6,2)
+ \put(3,2){\makebox(0,0)[t]{Harte Echtzeitanforderungen}}
+ \put(3,0){\makebox(0,0)[b]{Ressourcen optimal nutzen}}
+% \put(2.75,0.875){\vector(1,3){0.25}}
+% \put(2.75,0.875){\line(2,1){0.5}}
+% \put(3.25,1.125){\vector(-1,-3){0.25}}
+ \put(2.70,0.350){\tikz{\draw[latex-latex](0.25,0.625)--(0,-0.12)--(0.5,0.12)--(0.25,-0.625);}}
+ \end{picture}
+% \begin{pdfpic}
+% \begin{pspicture}(6,2)
+% \put(3,2){\makebox(0,0)[t]{Harte Echtzeitanforderungen}}
+% \put(3,0){\makebox(0,0)[b]{Ressourcen optimal nutzen}}
+% \psline[arrows=<->](3,0.4)(3.2,1.125)(2.8,0.875)(3,1.6)
+% \end{pspicture}
+% \end{pdfpic}
+ \end{center}
+
+ \pause
+
+ Beispiel:
+ \begin{itemize}
+ \item
+ Eine Motorsteuerung benötigt alle \SI{2000}{\mics} einen Steuerimpuls,\\
+ dessen Berechnung maximal \SI{10}{\mics} dauert.
+ \pause[3]
+ \item
+ Entweder: Der Steuer-Computer macht noch andere Dinge.\\
+ \textarrow\ Risiko der Zeitüberschreitung
+ \pause
+ \item
+ Oder: Der Steuer-Computer macht nichts anderes.\\
+ \textarrow\ Verschwendung von Rechenzeit\\
+ \pause
+ {\color{red}\textarrow\ Na und?}
+ \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Das Problem:
+ \vspace{-\bigskipamount}
+ \begin{center}
+ \begin{picture}(6,2)
+ \put(3,2){\makebox(0,0)[t]{Harte Echtzeitanforderungen}}
+ \put(3,0){\makebox(0,0)[b]{Ressourcen optimal nutzen}}
+% \put(2.75,0.875){\vector(1,3){0.25}}
+% \put(2.75,0.875){\line(2,1){0.5}}
+% \put(3.25,1.125){\vector(-1,-3){0.25}}
+ \put(2.70,0.350){\tikz{\draw[latex-latex](0.25,0.625)--(0,-0.12)--(0.5,0.12)--(0.25,-0.625);}}
+ \end{picture}
+% \begin{pdfpic}
+% \begin{pspicture}(6,2)
+% \put(3,2){\makebox(0,0)[t]{Harte Echtzeitanforderungen}}
+% \put(3,0){\makebox(0,0)[b]{Ressourcen optimal nutzen}}
+% \psline[arrows=<->](3,0.4)(3.2,1.125)(2.8,0.875)(3,1.6)
+% \end{pspicture}
+% \end{pdfpic}
+ \end{center}
+
+ \medskip
+
+ {\large\color{structure}\textbf{"`Verschwendung von Rechenzeit -- na und?"'}}
+
+ \medskip
+
+ \pause
+ Große Stückzahlen
+ \begin{itemize}
+ \item
+ 138\,000 Toyota Prius V von Mai 2011 bis April 2012
+ \end{itemize}
+
+ \medskip
+
+ \pause
+ Wertvolle Ressourcen
+ \begin{itemize}
+ \item
+ Fähigkeiten einer Raumsonde optimieren
+ % (Marsumlaufbahn: ab ca.~127\,000 Euro pro kg)
+ % 70000000 / 550000 = 127._27
+ % http://www.bernd-leitenberger.de/blog/2009/09/29/reduktion-der-kosten-von-planetenmissionen/
+ \only<.(1)>{\\[\medskipamount]\strut\hfill\makebox(0,0)[r]{\includegraphics[height=3.3cm]{curiosity.jpg}}\vspace*{-1cm}}
+ \pause
+ \item
+ Implantat: Platz- und Stromverbrauch minimieren
+ \only<.(1)>{\\\strut\hfill\makebox(0,0)[r]{\includegraphics[height=3.4cm]{herzschrittmacher.jpg}}\vspace*{-1cm}}
+ \end{itemize}
+
+ \bigskip
+
+ \pause
+ \textarrow\ {\large\color{structure}\textbf{Echtzeitprogrammierung}}\\[2pt]
+ \strut \phantom{\textarrow} Echtzeitanforderungen erfüllen, ohne Ressourcen zu verschwenden
+
+\end{frame}
+
+\subsection{Echtzeitprogrammierung}
+
+\begin{frame}
+
+ \showsubsection
+
+ Echtzeitanforderungen erfüllen, ohne Ressourcen zu verschwenden
+
+ \bigskip
+
+ \alt<.(1)>{Aber wie?}{Beispiele für Lösungen:}
+
+ \begin{itemize}
+ \pause
+ \item
+ ZigBee-Modul:\only<.(1)>{\hfill\makebox(0,0)[tr]{\includegraphics[width=5cm]{xbee.jpg}}}\\
+ % http://commons.wikimedia.org/wiki/File:Arduino_xbee.JPG
+ Funk- vs.\ UART-Protokoll\\
+ \textarrow\ dedizierte Hardware
+ \pause
+ \item
+ RP6:\\
+ Motorsteuerung vs.\ Anwender-Software\\
+ \textarrow\ spezielle Software
+ \only<.(1)>{\hfill\makebox(0,0)[r]{\includegraphics[width=5cm]{rp6.jpg}}}
+ \pause
+ \item
+ Quadrocopter:\\
+ Motorsteuerung vs.\ Sensoren-Abfrage\\
+ vs.\ Funk-Fernsteuerung \dots\\
+ \textarrow\ spezielle Software
+ \only<.(1)>{\hfill\makebox(0,0)[br]{\includegraphics[width=5cm]{quadrocopter.jpg}}}\\
+ \pause
+ \item
+ Flugzeugkabinensimulatortür:\\
+ Türsteuerung vs.\ Bedienung\\
+ \textarrow\ Echtzeitbetriebssystem
+ \only<.(1)>{\\[-3.2cm]\strut\hfill\makebox(0,0)[r]{\includegraphics[angle=-90,width=5cm]{dsc_8208.jpg}}}
+ \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsubsection
+
+ Quadrocopter-Steuerung \emph{MultiWii}
+ \begin{itemize}
+ \item
+ Konfiguration durch bedingte Compilierung (Präprozessor)
+ \item
+ In der Hauptschleife wird 50mal pro Sekunde der RC-Task aufgerufen,\\
+ ansonsten zyklisch einer von bis zu 5 weiteren Tasks.
+ \end{itemize}
+
+ \pause
+
+ RP6-Steuerung
+ \begin{itemize}
+ \item
+ Konfiguration durch bedingte Compilierung (Präprozessor)
+ \item
+ Lichtschranken an Encoder-Scheiben lösen bei Bewegung Interrupts aus.\\
+ Die Interrupt-Handler zählen Variable hoch.
+ \item
+ 10000mal pro Sekunde: Timer-Interrupt\\
+ Durch Zähler im Interrupt-Handler: verschiedene Taktraten\\
+ 1000mal pro Sekunde: Stopwatches\\
+ 5mal pro Sekunde: Blinkende Power-On-LED\\
+ 1000mal pro Sekunde: Bumper, ACS, PWM zur Motorsteuerung\\
+ Geschwindigkeitsmessung durch Zählen der Ticks in 0.2\,s\\
+ Anpassung der Motorkraft in $\pm$1-Schritten
+ \pause
+ \item
+ Nebenbei: \only<4->{1 }Benutzerprogramm
+ \end{itemize}
+
+\end{frame}
+
+\subsection{Multitasking}
+
+\begin{frame}
+
+ \showsubsection
+
+ \begin{itemize}
+ \item
+ \newterm{Kooperatives Multitasking}\\
+ Prozesse geben freiwillig Rechenzeit ab
+ \item
+ \newterm{Präemptives Multitasking}\\
+ Das Betriebssystem unterbricht laufende Prozesse\\
+ (englisch: \emph{to pre-empt\/} -- jemandem zuvorkommen)
+ \pause
+ \bigskip
+ \item
+ \newterm{Scheduler}\\
+ Steuerprogramm, das Prozessen Rechenzeit zuteilt
+ \item
+ \newterm{Kontextwechsel}\\
+ Umschalten zwischen zwei Prozessen
+ \item
+ \newterm{Round-Robin-Verfahren (Rundlauf)}\\
+ Zuteilung von \newterm{Zeitschlitzen\/} auf einer \newterm{Zeitscheibe} an die Prozesse
+ \bigskip
+ \pause
+ \item
+ Ausblick: Zuteilung von Rechenzeit = wichtiger Spezialfall\\
+ allgemein: Zuteilung von Ressourcen
+ \end{itemize}
+
+\end{frame}
+
+\subsectionnonumber{Beispiele für Multitasking}
+
+\begin{frame}
+
+ \showsubsectionnonumber
+
+ Quadrocopter-Steuerung \emph{MultiWii}
+ \begin{itemize}
+ \item
+ Konfiguration durch bedingte Compilierung (Präprozessor)
+ \item
+ In der Hauptschleife wird 50mal pro Sekunde der RC-Task aufgerufen,\\
+ ansonsten zyklisch einer von bis zu 5 weiteren Tasks.
+ \end{itemize}
+
+ RP6-Steuerung
+ \begin{itemize}
+ \item
+ Konfiguration durch bedingte Compilierung (Präprozessor)
+ \item
+ Lichtschranken an Encoder-Scheiben lösen bei Bewegung Interrupts aus.\\
+ Die Interrupt-Handler zählen Variable hoch.
+ \item
+ 10000mal pro Sekunde: Timer-Interrupt\\
+ verschiedene Tasks werden unterschiedlich häufig aufgerufen
+ \item
+ Nebenbei: 1 Benutzerprogramm
+ \end{itemize}
+
+% \pause
+%
+% Linux 0.01
+% \begin{itemize}
+% \item
+% Timer-Interrupt:\only<2->{ Zähler des aktuellen Tasks wird dekrementiert;}\\
+% Task mit höchstem Zähler bekommt Rechenzeit.
+% \item
+% Wenn es keinen laufbereiten Task mit positivem Zähler gibt,\\
+% bekommen alle Tasks gemäß ihrer Priorität neue Zähler zugewiesen.
+% \item
+% \emph{keine\/} harte Echtzeit
+% % Aufgabe: Wo wird der Zähler heruntergezählt?
+% \end{itemize}
+
+\end{frame}
+
+\iffalse
+
+\subsectionnonumber{Zombies}
+
+\begin{frame}
+
+ \showsubsectionnonumber
+
+ \pause
+ Wikipedia:
+ \begin{quote}
+ Als Zombie wird die fiktive Figur eines zum Leben erweckten
+ Toten (Untoter) oder eines seiner Seele beraubten, willenlosen
+ Wesens bezeichnet. Der Begriff leitet sich von dem Wort nzùmbe
+ aus der zentralafrikanischen Sprache Kimbundu ab und bezeichnet
+ dort ursprünglich einen Totengeist.
+ \end{quote}
+
+ \bigskip
+
+ \pause
+ Ein Zombie-Prozeß ist bereits beendet ("`tot"'),\\
+ bekommt keine Rechenzeit mehr ("`seiner Seele beraubt"'),\\
+ hat alle belegten Ressourcen wieder freigegeben ("`willenlos"'),\\
+ wird aber noch in der Prozeßliste geführt ("`untot"').
+ \begin{itemize}
+ \pause
+ \item
+ Warum?
+ \textarrow\
+ Ein anderer Prozeß (Elternprozeß) wartet noch auf den
+ Rückgabewert des beendeten Prozesses.
+ \pause
+ \item
+ Schadet das?
+ \textarrow\
+ Nein.
+ \pause
+ \item
+ Aber?
+ \textarrow\
+ Wenn sich Zombie-Prozesse anhäufen, deutet dies auf einen
+ Prozeß hin, der andere Prozesse erzeugt und anschließend "`hängt"'.
+ \pause
+ \item
+ Beispiel:
+ Datenträger entfernt, zugreifender Prozeß "`hängt"'.\\
+ \textarrow\
+ Tochterprozesse werden zu Zombies.
+ \end{itemize}
+
+\end{frame}
+
+\subsectionnonumber{Multitasking}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ \begin{minipage}[t]{6cm}
+ Qualitätsaspekte beim Multitasking
+ \begin{itemize}
+ \item<2->
+ Verschiedene Anforderungen:
+ \newterm{Latenz\/} vs.\ \newterm{Jitter\/}\\
+ vs.\ \newterm{Durchsatz}
+ \smallskip
+ \begin{onlyenv}<3>
+ \begin{itemize}
+ \item
+ \newterm{Latenz:} interaktive Anwendungen
+ \item
+ \newterm{Jitter:} Echtzeitanwendungen
+ \item
+ \newterm{Durchsatz:} Stapelverarbeitung
+ \end{itemize}
+ \vspace*{-3cm}
+ \end{onlyenv}
+ \item<4->
+ Ressourcen reservieren:\\
+ \newterm{Mutexe}
+ \only<5->{(= spezielle \newterm{Semaphore\/})\\}
+ \only<6->{\textarrow\ kommt gleich}
+ \item<7->
+ Verschiedene Methoden\\
+ der Priorisierung\\
+ \textarrow\ später\\
+ \strut
+ \item<8->
+ Umgehung der Probleme durch
+ speziell geschriebene Software\\
+ (MultiWii, RP6, \dots)
+ \end{itemize}
+ \end{minipage}
+ \hfill
+ \pause[9]%
+ \begin{minipage}[t]{6.2cm}
+ Qualitätsaspekte für Netzwerke:
+ \begin{itemize}
+ \item
+ Verschiedene Anforderungen:
+ \newterm{Latenz\/} vs.\ \newterm{Jitter\/} vs.\ \newterm{Verluste\/}\\vs.\ \newterm{Durchsatz}
+ \item
+ Ressourcen reservieren:\\
+ \newterm{IntServ} mit \newterm{Resource Reservation Protocol (RSVP)}
+ \item
+ Klassifizierung und Priorisierung:
+ \newterm{DiffServ} mit Type-of-Service-Bits (IPv4)
+ bzw.\ Traffic-Class-Bits (IPv6) im IP-Header
+ \item
+ Eigenes Protokoll (Telefondienste):\\
+ \newterm{Asynchronous Transfer Mode (ATM)}
+ \end{itemize}
+ \end{minipage}
+
+\end{frame}
+
+\subsection{Ressourcen}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ressourcen reservieren
+ \begin{itemize}
+ \item
+ \newterm{Semaphor}\\
+ gemeinsame Variable mehrerer Prozesse\\
+ zur Regelung des Zugriffs auf eine Ressource\\[\smallskipamount]
+ Ressource belegt \textarrow\ Kontextwechsel
+ \begin{onlyenv}<1>
+ \par\medskip
+ griechisch: \emph{sema\/} -- Zeichen, \emph{pherein\/} -- tragen\\
+ "`Eisenbahnsignal"'
+ \vspace*{-3cm}
+ \end{onlyenv}
+ \pause
+ \medskip
+ \item
+ \newterm{Mutex}\\
+ Mechanismus, damit immer nur ein Prozeß gleichzeitig\\
+ auf eine Ressource zugreifen kann
+ \begin{onlyenv}<2>
+ \par\medskip
+ englisch: \emph{mutual exclusion\/} -- wechselseitiger Ausschluß\\
+ spezieller binärer Semaphor: nur "`Besitzer"' darf freigeben\\
+ % allgemein: auch jemand anderer dürfte freigeben
+ \vspace*{-3cm}
+ \end{onlyenv}
+ \pause
+ \medskip
+ \item
+ \newterm{Spinlock} (\emph{busy waiting\/})\\
+ leichtgewichtige Alternative zu Kontextwechsel
+ \begin{onlyenv}<3>
+ \par\medskip
+ englisch: \emph{spin\/} -- rotieren, \emph{lock\/} Sperre\\
+ \emph{busy waiting} auf etwas Schnelles, z.\,B.\ auf einen Semaphor\\[\medskipamount]
+ Hardware-Unterstützung:
+ Prüfen, ob Variable bestimmten Wert hat;\\
+ wenn ja, auf anderen Wert setzen; andere Prozessoren solange anhalten
+ \vspace*{-3cm}
+ \end{onlyenv}
+ \pause
+ \medskip
+ \item
+ \newterm{Kritischer Abschnitt -- critical section}\\
+ Programmabschnitt zwischen Reservierung\\
+ und Freigabe einer Ressource\\
+ \textarrow\ sollte immer so kurz wie möglich sein
+ \end{itemize}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ressourcen reservieren --
+ Beispiel: \file{linux-3.7rc1}
+ \begin{itemize}
+ \item
+ \newterm{Semaphor}\\
+ \file{kernel/semaphor.c}\\
+ \file{drivers/usb/core/file.c}
+ \medskip
+ \item
+ \newterm{Mutex}\\
+ \file{kernel/mutex.c}\\
+ \file{drivers/usb/serial/usb-serial.c}
+ \medskip
+ \item
+ \newterm{Spinlock}\\
+ \file{kernel/spinlock.c}\\
+ \file{kernel/semaphor.c},
+ \file{kernel/mutex.c}
+ \end{itemize}
+
+ % Aufgabe: Anwendungsarten im MultiWii- und RP6-Code identifizieren
+
+ % evtl. Aufgabe: Warte-Problem
+
+ % Aufgabe: Wie lösen bekannte Multitasking-Betriebssysteme
+ % das o.a. Zuteilungsproblem?
+
+ % Danach: Semaphoren, Mutexe, Spinlocks
+ % Priorisierungsmethoden und -probleme
+
+ % Festplatten: completely fair queueing
+ % cat /sys/block/sdc/queue/scheduler
+ % "noop" hat sich für SVG gelohnt
+
+ % Virtualisierung + Kernel-Threads + Multiprozessorsystem = Chaos
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \textbf{Beispiel:}
+ \lstinline{usb_serial_get_by_index()} -- serielle Schnittstelle reservieren
+
+ Datei \file{linux-3.7-rc1/drivers/usb/serial/usb-serial.c}, ab Zeile 62
+
+ \medskip
+
+ \begin{lstlisting}
+ struct usb_serial *usb_serial_get_by_index (unsigned index)
+ {
+ struct usb_serial *serial;
+ mutex_lock (&table_lock);
+ serial = serial_table[index];
+ if (serial)
+ {
+ mutex_lock (&serial->disc_mutex);
+ if (serial->disconnected)
+ {
+ mutex_unlock (&serial->disc_mutex);
+ serial = NULL;
+ }
+ else
+ kref_get (&serial->kref);
+ }
+ mutex_unlock (&table_lock);
+ return serial;
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(5.1,6.85){\vector(-1,0){0.5}}
+ \put(5.2,6.85){\makebox(0,0)[l]{exklusiven Zugriff auf Tabelle sichern}}
+ \put(5.4,1.35){\vector(-1,0){0.5}}
+ \put(5.5,1.35){\makebox(0,0)[l]{\shortstack[l]{exklusiven Zugriff auf Tabelle\\wieder freigeben}}}
+ \end{picture}
+
+\end{frame}
+
+\setlength{\pdfpageheight}{48cm}
+
+\begin{frame}[fragile]
+
+ \lstinline{mutex_lock()} -- Ressource beanspruchen, notfalls warten
+
+ Datei \file{linux-3.7-rc1/drivers/usb/serial/usb-serial.c}, ab Zeile 62
+
+ \medskip
+
+ \begin{lstlisting}
+ void __sched mutex_lock (struct mutex *lock)
+ {
+ might_sleep ();
+ __mutex_fastpath_lock (&lock->count, __mutex_lock_slowpath);
+ mutex_set_owner (lock);
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(11.6,1.35){\line(-1,0){1}}
+ \put(11.6,1.35){\line(0,-1){2.45}}
+ \put(11.6,-1.10){\vector(-1,0){2.0}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/arch/x86/include/asm/mutex\_32.h}, ab Zeile 24
+
+ Macro-Definition für \lstinline{__mutex_fastpath_lock} (expandiert)
+
+ \medskip
+
+ Assembler:
+ \begin{lstlisting}[language={[x86masm]Assembler}]
+ lock dec (lock->count)
+ jns 1
+ call __mutex_lock_slowpath
+ 1:
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(9,0.95){\line(-1,0){3.5}}
+ \put(9,0.95){\line(0,-1){2.5}}
+ \put(9.0,-1.55){\vector(-1,0){1.0}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/kernel/mutex.c}, ab Zeile 398
+
+ \medskip
+
+ \begin{lstlisting}
+ static __used noinline void __sched
+ __mutex_lock_slowpath (atomic_t *lock_count)
+ {
+ struct mutex *lock = container_of (lock_count, struct mutex, count);
+ __mutex_lock_common (lock, TASK_UNINTERRUPTIBLE, 0,
+ NULL, _RET_IP_);
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(11.0,1.40){\line(-1,0){1.0}}
+ \put(11.0,1.40){\vector(0,-1){2.5}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/kernel/mutex.c}, ab Zeile 132
+
+ \medskip
+
+ \begin{lstlisting}
+ static inline int __sched
+ __mutex_lock_common (struct mutex *lock, long state, unsigned int subclass,
+ struct lockdep_map *nest_lock, unsigned long ip)
+ {
+ struct task_struct *task = current;
+ struct mutex_waiter waiter;
+ unsigned long flags;
+
+ preempt_disable ();
+ mutex_acquire_nest (&lock->dep_map, subclass, 0, nest_lock, ip);
+
+ /* ... */
+
+ spin_lock_mutex (&lock->wait_lock, flags);
+
+ debug_mutex_lock_common (lock, &waiter);
+ debug_mutex_add_waiter (lock, &waiter, task_thread_info (task));
+
+ /* add waiting tasks to the end of the waitqueue (FIFO): */
+ list_add_tail (&waiter.list, &lock->wait_list);
+ waiter.task = task;
+
+ if (atomic_xchg (&lock->count, -1) == 1)
+ goto done;
+
+ lock_contended (&lock->dep_map, ip);
+
+ for (;;)
+ {
+ /*
+ * Lets try to take the lock again - this is needed even if
+ * we get here for the first time (shortly after failing to
+ * acquire the lock), to make sure that we get a wakeup once
+ * it's unlocked. Later on, if we sleep, this is the
+ * operation that gives us the lock. We xchg it to -1, so
+ * that when we release the lock, we properly wake up the
+ * other waiters:
+ */
+ if (atomic_xchg (&lock->count, -1) == 1)
+ break;
+
+ /*
+ * got a signal? (This code gets eliminated in the
+ * TASK_UNINTERRUPTIBLE case.)
+ */
+ if (unlikely (signal_pending_state (state, task)))
+ {
+ mutex_remove_waiter (lock, &waiter, task_thread_info (task));
+ mutex_release (&lock->dep_map, 1, ip);
+ spin_unlock_mutex (&lock->wait_lock, flags);
+
+ debug_mutex_free_waiter (&waiter);
+ preempt_enable ();
+ return -EINTR;
+ }
+ __set_task_state (task, state);
+
+ /* didn't get the lock, go to sleep: */
+ spin_unlock_mutex (&lock->wait_lock, flags);
+ schedule_preempt_disabled ();
+ spin_lock_mutex (&lock->wait_lock, flags);
+ }
+
+ done:
+ lock_acquired (&lock->dep_map, ip);
+ /* got the lock - rejoice! */
+ mutex_remove_waiter (lock, &waiter, current_thread_info ());
+ mutex_set_owner (lock);
+
+ /* set it to 0 if there are no waiters left: */
+ if (likely (list_empty (&lock->wait_list)))
+ atomic_set (&lock->count, 0);
+
+ spin_unlock_mutex (&lock->wait_lock, flags);
+
+ debug_mutex_free_waiter (&waiter);
+ preempt_enable ();
+
+ return 0;
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(7.9,28.3){\vector(-1,0){0.5}}
+ \put(8.0,28.3){\makebox(0,0)[l]{\shortstack[l]{exklusiven Zugriff\\auf Mutex sichern}}}
+ \put(7.4,2.3){\vector(-1,1){0.4}}
+ \put(7.5,2.0){\makebox(0,0)[l]{\shortstack[l]{exklusiven Zugriff auf Mutex\\wieder freigeben}}}
+ \end{picture}
+
+\end{frame}
+
+\setlength{\pdfpageheight}{40.5cm}
+
+\begin{frame}[fragile]
+
+ \lstinline{spin_lock_mutex()} -- Mutex beanspruchen, notfalls \emph{busy waiting}
+
+ Datei \file{linux-3.7-rc1/kernel/mutex.h}, ab Zeile 12
+
+ \medskip
+
+ \begin{lstlisting}
+ #define spin_lock_mutex(lock, flags) \
+ do \
+ { \
+ spin_lock (lock); \
+ (void) (flags); \
+ } \
+ while (0)
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(8.5,1.75){\line(-1,0){4.5}}
+ \put(8.5,1.75){\line(0,-1){2.9}}
+ \put(8.5,-1.15){\vector(-1,0){1.0}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/kernel/spinlock.h}, ab Zeile 283
+
+ \medskip
+
+ \begin{lstlisting}
+ static inline void spin_lock (spinlock_t *lock)
+ {
+ raw_spin_lock (&lock->rlock);
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(9.3,0.95){\line(-1,0){4.0}}
+ \put(9.3,0.95){\line(0,-1){2.1}}
+ \put(9.3,-1.15){\vector(-1,0){1.0}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/kernel/spinlock.h}, Zeile 170
+
+ \medskip
+
+ \begin{lstlisting}
+ #define raw_spin_lock(lock) _raw_spin_lock (lock)
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(10.0,0.55){\line(-1,0){0.5}}
+ \put(10.0,0.55){\line(0,-1){1.7}}
+ \put(10.0,-1.15){\vector(-1,0){1.3}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/include/linux/spinlock\_api\_smp.h}, Zeile 47
+
+ \medskip
+
+ \begin{lstlisting}
+ #define _raw_spin_lock(lock) __raw_spin_lock (lock)
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(10.7,0.55){\line(-1,0){0.5}}
+ \put(10.7,0.55){\line(0,-1){1.75}}
+ \put(10.7,-1.2){\vector(-1,0){2.3}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/kernel/spinlock.c}, ab Zeile 46 (expandiert):
+
+ \medskip
+
+ \begin{lstlisting}
+ void __lockfunc __raw_spin_lock (spinlock_t *lock)
+ {
+ for (;;)
+ {
+ preempt_disable ();
+ if (likely (do_raw_spin_trylock (lock)))
+ break;
+ preempt_enable ();
+
+ if (!(lock)->break_lock)
+ (lock)->break_lock = 1;
+ while (!raw_spin_can_lock (lock) && (lock)->break_lock)
+ arch_spin_relax (&lock->raw_lock);
+ }
+ (lock)->break_lock = 0;
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(10.7,4.75){\line(-1,0){3.5}}
+ \put(10.7,4.75){\line(0,-1){5.95}}
+ \put(10.7,-1.2){\vector(-1,0){1.1}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{linux-3.7-rc1/include/linux/spinlock.h}, ab Zeile 150:
+
+ \medskip
+
+ \begin{lstlisting}
+ static inline int do_raw_spin_trylock (raw_spinlock_t *lock)
+ {
+ return arch_spin_trylock (&(lock)->raw_lock);
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(11.5,0.95){\line(-1,0){3.5}}
+ \put(11.5,0.95){\line(0,-1){2.1}}
+ \put(11.5,-1.15){\vector(-1,0){0.7}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{arch/x86/include/asm/spinlock.h}, ab Zeile 116:
+
+ \medskip
+
+ \begin{lstlisting}
+ static __always_inline int arch_spin_trylock (arch_spinlock_t *lock)
+ {
+ return __ticket_spin_trylock (lock);
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(9.5,0.95){\line(-1,0){3.5}}
+ \put(9.5,0.95){\vector(0,-1){1.7}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{arch/x86/include/asm/spinlock.h}, ab Zeile 65:
+
+ \medskip
+
+ \begin{lstlisting}
+ static __always_inline int __ticket_spin_trylock (arch_spinlock_t *lock)
+ {
+ arch_spinlock_t old, new;
+
+ old.tickets = ACCESS_ONCE (lock->tickets);
+ if (old.tickets.head != old.tickets.tail)
+ return 0;
+
+ new.head_tail = old.head_tail + (1 << TICKET_SHIFT);
+
+ /* cmpxchg is a full barrier, so nothing can move before it */
+ return cmpxchg (&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(2.2,0.3){\line(0,1){0.4}}
+ \put(9.0,0.3){\line(-1,0){6.8}}
+ \put(9.0,0.3){\line(0,-1){1.45}}
+ \put(9.0,-1.15){\vector(-1,0){3.2}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{arch/x86/include/asm/cmpxchg.h}, ab Zeile 147:
+
+ \medskip
+
+ \begin{lstlisting}
+ #define cmpxchg(ptr, old, new) \
+ __cmpxchg (ptr, old, new, sizeof (*(ptr)))
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(9.0,0.5){\line(-1,0){1.8}}
+ \put(9.0,0.5){\line(0,-1){1.65}}
+ \put(9.0,-1.15){\vector(-1,0){2.2}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{arch/x86/include/asm/cmpxchg.h}, ab Zeile 131:
+
+ \medskip
+
+ \begin{lstlisting}
+ #define __cmpxchg(ptr, old, new, size) \
+ __raw_cmpxchg ((ptr), (old), (new), (size), LOCK_PREFIX)
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(2.2,-0.1){\line(0,1){0.3}}
+ \put(9.0,-0.1){\line(-1,0){6.8}}
+ \put(9.0,-0.1){\line(0,-1){1.05}}
+ \put(9.0,-1.15){\vector(-1,0){2.2}}
+ \end{picture}
+
+ \bigskip
+
+ Datei \file{arch/x86/include/asm/cmpxchg.h}, ab Zeile 110:
+
+ \medskip
+
+ \begin{lstlisting}
+ asm volatile (lock "cmpxchgl %2,%1" \
+ : "=a" (__ret), "+m" (*__ptr) \
+ : "r" (__new), "0" (__old) \
+ : "memory");
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(9.8,1.8){\vector(-1,0){0.6}}
+ \put(9.8,1.2){\line(0,1){0.6}}
+ \put(9.8,1.1){\makebox(0,0)[t]{\shortstack{atomarer und exklusiver\\Zugriff auf Spinlock\\durch Hardware-Unterstützung}}}
+ \end{picture}
+
+\end{frame}
+
+\setlength{\pdfpageheight}{\normalpdfpageheight}
+
+%\sectionnonumber{Literaturempfehlung}
+%\subsectionnonumber{Automotive Embedded Systeme}
+%
+%\begin{frame}[c]
+%
+% \showsectionnonumber
+%
+% Prof.\ Dr.\ Joachim Wietzke, FH Darmstadt,\\
+% Prof.\ Dr.\ Manh Tien Tran, FH Kaiserslautern:
+%
+% \medskip
+%
+% \showsubsectionnonumber
+%
+% \vspace{-\medskipamount}
+%
+% Springer-Verlag, Berlin, Heidelberg 2005
+%
+% \bigskip
+%
+% Lizenz: proprietär
+%
+% \medskip
+%
+% (gesetzt mit \textrm{\LaTeX}, ca.\ \EUR{10})
+%
+%\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ressourcen reservieren
+ \begin{itemize}
+ \item
+ \newterm{Semaphor}\\
+ gemeinsame Variable mehrerer Prozesse\\
+ zur Regelung des Zugriffs auf eine Ressource\\[\smallskipamount]
+ Ressource belegt \textarrow\ Kontextwechsel
+ \medskip
+ \item
+ \newterm{Mutex}\\
+ Mechanismus, damit immer nur ein Prozeß gleichzeitig\\
+ auf eine Ressource zugreifen kann
+ \medskip
+ \item
+ \newterm{Spinlock} (\emph{busy waiting\/})\\
+ leichtgewichtige Alternative zu Kontextwechsel
+ \medskip
+ \item
+ \newterm{Kritischer Abschnitt -- critical section}\\
+ Programmabschnitt zwischen Reservierung\\
+ und Freigabe einer Ressource\\
+ \textarrow\ sollte immer so kurz wie möglich sein
+ \end{itemize}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ \begin{picture}(0,0)
+ \only<2-3>{\put(6.3,-7){\includegraphics[height=6cm]{philosophenproblem.jpg}}}
+ \end{picture}%
+ \newterm{Verklemmungen\/}: Gegenseitiges Blockieren von Ressourcen
+ \begin{itemize}
+ \item
+ \newterm{Deadlock\/}: Prozeß wartet
+ \item
+ \newterm{Livelock\/}: Prozeß macht andere Dinge\\
+ (z.\,B.\ \emph{busy waiting\/})
+ \end{itemize}
+
+ \pause
+ \bigskip
+
+ Beispiel: Philosophenproblem
+
+ \only<2-3>{%
+ \begin{itemize}
+ \item
+ 5 Philosophen, 5 Gabeln
+ \item
+ 2 Gabeln zum Essen notwendig
+ \item
+ Wer essen will, nimmt eine Gabel\\
+ und wartet notfalls auf die zweite.
+ \item
+ Keiner legt eine einzelne Gabel\\
+ wieder zurück.
+ \end{itemize}
+ Jeder hält 1 Gabel \textarrow\ \newterm{Verklemmung}\\[0.5\smallskipamount]
+ \pause
+ \strut\quad schweigen \textarrow\ \newterm{Deadlock}\\
+ \strut\quad philosophieren weiter \textarrow\ \newterm{Livelock}\\[-1cm]
+ }
+ \only<4->{%
+ \bigskip
+
+ Bedingungen für Verklemmungen:
+
+ \begin{minipage}[t]{4.5cm}
+ \begin{itemize}
+ \item
+ Exklusivität
+ \item
+ \newterm{hold and wait}
+ \item
+ Entzug nicht möglich
+ \item
+ zirkuläre Blockade
+ \end{itemize}
+ \end{minipage}\pause[5]
+ \begin{minipage}[t]{7.5cm}
+ \begin{itemize}
+ \arrowitem
+ Spooling
+ \arrowitem
+ simultane Zuteilung
+ \arrowitem
+ Prozesse suspendieren, beenden, \newterm{Rollback}
+ \arrowitem
+ Reihenfolge abhängig von Ressourcen
+ \end{itemize}
+ \end{minipage}
+ }
+
+\end{frame}
+
+\subsection{Prioritäten}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Linux 0.01
+ \begin{itemize}
+ \item
+ Timer-Interrupt: Zähler des aktuellen Prozesses wird dekrementiert;\\
+ Prozeß mit höchstem Zähler bekommt Rechenzeit.
+ \item
+ Wenn es keinen laufbereiten Prozeß mit positivem Zähler gibt,\\
+ bekommen alle Prozesse gemäß ihrer \newterm{Priorität\/} neue Zähler zugewiesen.
+ \item
+ \emph{keine\/} harte Echtzeit
+ \arrowitem
+ \newterm{dynamische Prioritätenvergabe\/}:\\
+ Rechenzeit hängt vom Verhalten des Prozesses ab
+ \end{itemize}
+
+ \medskip
+
+ Echtzeitbetriebssysteme
+ \begin{itemize}
+ \item
+ Prozesse können einen festen Anteil an Rechenzeit bekommen.
+ \item
+ Bei Ereignissen können Prozesse hoher Priorität\\
+ Prozesse niedriger Priorität unterbrechen, aber nicht umgekehrt.
+ \arrowitem
+ \newterm{statische Prioritätenvergabe}
+ \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Echtzeitbetriebssysteme
+ \begin{itemize}
+ \item
+ Prozesse können einen festen Anteil an Rechenzeit bekommen.
+ \item
+ Bei Ereignissen können Prozesse hoher Priorität\\
+ Prozesse niedriger Priorität unterbrechen, aber nicht umgekehrt.
+ \end{itemize}
+
+ \vspace{0cm plus 1filll}
+
+ \begin{center}
+ \begin{picture}(11,4)(-1,0)
+ \small
+
+ \put(-0.1,0.5){\vector(1,0){10.1}}
+ \put(9.75,0.4){\makebox(0,0)[tr]{Zeit}}
+ \put(0,0.4){\vector(0,1){3.6}}
+ \put(-0.1,3.75){\makebox(0,0)[tr]{Priorität}}
+
+ \put(1,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(3,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}
+ \put(5,3){{\color{lightorange}\rule{0.6cm}{0.4cm}}}
+ \put(7,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(9,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}
+ \put(0,3){\line(1,0){10}}
+
+ \put(0,1){{\color{lightgreen}\rule{1cm}{0.4cm}}}
+ \put(1.5,1){{\color{lightgreen}\rule{1.5cm}{0.4cm}}}
+ \put(3.7,1){{\color{lightgreen}\rule{0.6cm}{0.4cm}}}
+ \alt<1>{%
+ \put(7.9,1){{\color{lightgreen}\rule{1.1cm}{0.4cm}}}
+ }{%
+ \put(8.1,1){{\color{lightgreen}\rule{0.9cm}{0.4cm}}}
+ }
+ \put(9.7,1){{\color{lightgreen}\rule{0.3cm}{0.4cm}}}
+ \put(0,1){\line(1,0){10}}
+
+ \pause
+
+ \put(4.6,2){{\color{lightyellow}\rule{0.4cm}{0.4cm}}}
+ \put(5.7,2){{\color{lightyellow}\rule{1.3cm}{0.4cm}}}
+ \put(7.7,2){{\color{lightyellow}\rule{0.4cm}{0.4cm}}}
+ \put(0,2){\line(1,0){10}}
+
+ \end{picture}
+ \end{center}
+
+\end{frame}
+
+\subsectionnonumber{Prioritäten \protect\color{darkgray}und Ressourcen}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ \only<4->{%
+ Der höher priorisierte Prozeß bewirkt selbst,\\
+ daß er eine Ressource verspätet bekommt.
+
+ \medskip
+
+ \textarrow\ \newterm{begrenzte Prioritätsinversion}
+
+ \medskip
+
+ maximale Verzögerung: Länge des kritischen Bereichs
+ }
+
+ \vspace{0cm plus 1filll}
+
+ \begin{center}
+ \begin{picture}(11,4)(-1,0)
+ \small
+
+ \put(-0.1,0.5){\vector(1,0){10.1}}
+ \put(9.75,0.4){\makebox(0,0)[tr]{Zeit}}
+ \put(0,0.4){\vector(0,1){3.6}}
+ \put(-0.1,3.75){\makebox(0,0)[tr]{Priorität}}
+
+ \put(1,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \only<1-2>{\put(3,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}}
+ \only<3->{\put(3,3){{\color{lightorange}\rule{0.4cm}{0.4cm}}}}
+ \only<3-4>{%
+ \put(3.4,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ \put(4.2,3){{\color{lightorange}\rule{0.2cm}{0.4cm}}}
+ {\thicklines
+ \put(3.3,2.95){\line(2,1){1.0}}
+ \put(3.3,3.45){\line(2,-1){1.0}}}
+ }
+ \only<5->{%
+ \put(3.9,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ \put(4.7,3){{\color{lightorange}\rule{0.2cm}{0.4cm}}}
+ }
+ \put(5,3){{\color{lightorange}\rule{0.6cm}{0.4cm}}}
+ \only<1-2>{%
+ \put(5.4,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ \put(6.2,3){{\color{lightorange}\rule{0.2cm}{0.4cm}}}
+ }
+ \put(7,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(9,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}
+ \put(0,3){\line(1,0){10}}
+
+ \only<2->{%
+ \put(0,1){{\color{lightgreen}\rule{1cm}{0.4cm}}}
+ \put(1.5,1){{\color{lightgreen}\rule{1.5cm}{0.4cm}}}
+ \put(2.6,1){{\color{medgreen}\rule{0.4cm}{0.4cm}}}
+ \only<2-4>{%
+ \put(3.7,1){{\color{medgreen}\rule{0.5cm}{0.4cm}}}
+ \put(4.2,1){{\color{lightgreen}\rule{0.3cm}{0.4cm}}}
+ }
+ \only<5->{%
+ \put(3.4,1){{\color{medgreen}\rule{0.5cm}{0.4cm}}}
+ \put(4.9,1){{\color{lightgreen}\rule{0.1cm}{0.4cm}}}
+ \put(5.6,1){{\color{lightgreen}\rule{0.2cm}{0.4cm}}}
+ }
+ \put(7.7,1){{\color{lightgreen}\rule{1.3cm}{0.4cm}}}
+ \put(9.7,1){{\color{lightgreen}\rule{0.3cm}{0.4cm}}}
+ \put(0,1){\line(1,0){10}}
+ }
+ \end{picture}
+ \end{center}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ \visible<4->{%
+ Ein Prozeß mit mittlerer Priorität bewirkt,
+ daß ein Prozeß mit hoher Priorität eine Ressource überhaupt nicht bekommt.
+
+ \medskip
+
+ \textarrow\ }\newterm{unbegrenzte Prioritätsinversion}
+
+ \pause
+ \vspace{0cm plus 1filll}
+
+ \begin{center}
+ \begin{picture}(11,4)(-1,0)
+ \small
+
+ \put(-0.1,0.5){\vector(1,0){10.1}}
+ \put(9.75,0.4){\makebox(0,0)[tr]{Zeit}}
+ \put(0,0.4){\vector(0,1){3.6}}
+ \put(-0.1,3.75){\makebox(0,0)[tr]{Priorität}}
+
+ \put(1,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(3,3){{\color{lightorange}\rule{0.4cm}{0.4cm}}}
+ \only<2>{%
+ \put(3.4,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ \put(4.2,3){{\color{lightorange}\rule{0.2cm}{0.4cm}}}
+ {\thicklines
+ \put(3.3,2.95){\line(2,1){1.0}}
+ \put(3.3,3.45){\line(2,-1){1.0}}}
+ \put(5,3){{\color{lightorange}\rule{0.6cm}{0.4cm}}}
+ \put(7,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(9,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}
+ }
+ \put(0,3){\line(1,0){10}}
+
+ \only<2->{%
+ \put(0,1){{\color{lightgreen}\rule{1cm}{0.4cm}}}
+ \put(1.5,1){{\color{lightgreen}\rule{1.1cm}{0.4cm}}}
+ \alt<1-4>{%
+ \put(2.6,1){{\color{medgreen}\rule{0.4cm}{0.4cm}}}
+ }{%
+ \put(2.6,1){{\color{medgreen}\rule{0.2cm}{0.4cm}}}
+ }
+ \only<2>{%
+ \put(3.7,1){{\color{medgreen}\rule{0.5cm}{0.4cm}}}
+ \put(4.2,1){{\color{lightgreen}\rule{0.3cm}{0.4cm}}}
+ }
+ \only<3-4>{%
+ \put(3.4,1){{\color{medgreen}\rule{0.5cm}{0.4cm}}}
+% \put(3.9,1){{\color{lightgreen}\rule{0.3cm}{0.4cm}}}
+ }
+ \only<2>{%
+ \put(7.7,1){{\color{lightgreen}\rule{1.3cm}{0.4cm}}}
+ \put(9.7,1){{\color{lightgreen}\rule{0.3cm}{0.4cm}}}
+ }
+ \put(0,1){\line(1,0){10}}
+ }
+
+ \only<5->{%
+ \put(2.8,2){{\color{lightyellow}\rule{0.2cm}{0.4cm}}}
+ \put(3.4,2){{\color{lightyellow}\rule{6.6cm}{0.4cm}}}
+ \put(0,2){\line(1,0){10}}
+ }
+ \end{picture}
+ \end{center}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ein Prozeß mit mittlerer Priorität bewirkt,
+ daß ein Prozeß mit hoher Priorität eine Ressource überhaupt nicht bekommt.
+
+ \medskip
+
+ \textarrow\ \newterm{unbegrenzte Prioritätsinversion}
+
+ \medskip
+
+ Beispiel: Beinahe-Verlust der Marssonde \emph{Pathfinder\/} im Juli 1997
+
+ \only<1>{%
+ \begin{center}
+ \includegraphics[width=8.5cm]{pathfinder.jpg}
+ \vspace*{-1.5cm}
+ \end{center}
+ }
+
+ \bigskip
+
+ \only<2>{%
+ Gegenmaßnahmen
+ \begin{itemize}
+ \item
+ \newterm{Priority Inheritance -- Prioritätsvererbung}\\
+ Der Besitzer des Mutex erbt die Priorität\\
+ des Prozesses, der auf den Mutex wartet.
+ \end{itemize}
+
+ \bigskip
+
+ \begin{minipage}{7.0cm}
+ \begin{flushright}
+ \url{http://research.microsoft.com/en-us/\\um/people/mbj/Mars\_Pathfinder/}
+ \end{flushright}
+ \end{minipage}
+
+ \vspace{-0.2cm}\strut\hfill\makebox(0,0)[br]{\includegraphics[height=2.7cm]{pathfinder.jpg}}\vspace*{-1cm}
+ }
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ein Prozeß mit mittlerer Priorität bewirkt,
+ daß ein Prozeß mit hoher Priorität eine Ressource überhaupt nicht bekommt.
+
+ \medskip
+
+ \textarrow\ \newterm{unbegrenzte Prioritätsinversion}
+
+ \bigskip
+
+ Gegenmaßnahme: \newterm{Priority Inheritance -- Prioritätsvererbung}
+
+ \vspace{0cm plus 1filll}
+
+ \begin{center}
+ \begin{picture}(11,4)(-1,0)
+ \small
+
+ \put(-0.1,0.5){\vector(1,0){10.1}}
+ \put(9.75,0.4){\makebox(0,0)[tr]{Zeit}}
+ \put(0,0.4){\vector(0,1){3.6}}
+ \put(-0.1,3.75){\makebox(0,0)[tr]{Priorität}}
+
+ \put(0,1){{\color{lightgreen}\rule{1cm}{0.4cm}}}
+ \put(1.5,1){{\color{lightgreen}\rule{1.1cm}{0.4cm}}}
+ \put(2.6,1){{\color{medgreen}\rule{0.2cm}{0.4cm}}}
+ \put(0,1){\line(1,0){10}}
+
+ \put(2.8,2){{\color{lightyellow}\rule{0.2cm}{0.4cm}}}
+ \only<1-2>{%
+ \put(3.4,2){{\color{lightyellow}\rule{6.6cm}{0.4cm}}}
+ }
+ \put(0,2){\line(1,0){10}}
+
+ \put(1,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(3,3){{\color{lightorange}\rule{0.4cm}{0.4cm}}}
+ \put(0,3){\line(1,0){10}}
+
+ \only<2>{%
+ \put(3.4,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ {\thicklines
+ \put(3.3,2.95){\line(2,1){1.0}}
+ \put(3.3,3.45){\line(2,-1){1.0}}}
+ }
+
+ \only<3->{%
+ \put(3.4,3){{\color{medgreen}\rule{0.7cm}{0.4cm}}}
+ \put(4.1,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ \put(5.7,2){{\color{lightyellow}\rule{1.3cm}{0.4cm}}}
+ \put(4.9,3){{\color{lightorange}\rule{0.8cm}{0.4cm}}}
+ \put(7,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(7.5,2){{\color{lightyellow}\rule{1.5cm}{0.4cm}}}
+ \put(9,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}
+ \put(9.7,2){{\color{lightyellow}\rule{0.3cm}{0.4cm}}}
+ }
+ \end{picture}
+ \end{center}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ein Prozeß mit mittlerer Priorität bewirkt,
+ daß ein Prozeß mit hoher Priorität eine Ressource überhaupt nicht bekommt.
+
+ \medskip
+
+ \textarrow\ \newterm{unbegrenzte Prioritätsinversion}
+
+ \bigskip
+
+ Gegenmaßnahme: \newterm{Priority Ceiling -- Prioritätsobergrenze}
+
+ \vspace{0cm plus 1filll}
+
+ \begin{center}
+ \begin{picture}(11,4)(-1,0)
+ \small
+
+ \put(-0.1,0.5){\vector(1,0){10.1}}
+ \put(9.75,0.4){\makebox(0,0)[tr]{Zeit}}
+ \put(0,0.4){\vector(0,1){3.6}}
+ \put(-0.1,3.75){\makebox(0,0)[tr]{Priorität}}
+
+ \put(0,1){{\color{lightgreen}\rule{1cm}{0.4cm}}}
+ \put(1.5,1){{\color{lightgreen}\rule{1.1cm}{0.4cm}}}
+% \only<1>{%
+% \put(2.6,1){{\color{medgreen}\rule{0.2cm}{0.4cm}}}
+% }
+ \put(0,1){\line(1,0){10}}
+
+% \only<1>{%
+% \put(2.8,2){{\color{lightyellow}\rule{0.2cm}{0.4cm}}}
+% \put(3.4,2){{\color{lightyellow}\rule{6.6cm}{0.4cm}}}
+% }
+ \put(0,2){\line(1,0){10}}
+
+ \put(1,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+% \only<1>{%
+% \put(3,3){{\color{lightorange}\rule{0.4cm}{0.4cm}}}
+% }
+ \put(0,3){\line(1,0){10}}
+
+% \only<2>{%
+% \only<2>{%
+ \put(2.6,3){{\color{medgreen}\rule{0.9cm}{0.4cm}}}
+ \put(3.5,3){{\color{lightorange}\rule{0.4cm}{0.4cm}}}
+ \put(3.9,3){{\color{red}\rule{0.8cm}{0.4cm}}}
+ \put(4.7,3){{\color{lightorange}\rule{0.8cm}{0.4cm}}}
+ \put(5.5,2){{\color{lightyellow}\rule{1.5cm}{0.4cm}}}
+ \put(7,3){{\color{lightorange}\rule{0.5cm}{0.4cm}}}
+ \put(7.5,2){{\color{lightyellow}\rule{1.5cm}{0.4cm}}}
+ \put(9,3){{\color{lightorange}\rule{0.7cm}{0.4cm}}}
+ \put(9.7,2){{\color{lightyellow}\rule{0.3cm}{0.4cm}}}
+% }
+ \end{picture}
+ \end{center}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+ \showsubsection
+
+ Ein Prozeß mit mittlerer Priorität bewirkt,
+ daß ein Prozeß mit hoher Priorität eine Ressource überhaupt nicht bekommt.
+
+ \medskip
+
+ \textarrow\ \newterm{unbegrenzte Prioritätsinversion}
+
+ \medskip
+
+ Beispiel: Beinahe-Verlust der Marssonde \emph{Pathfinder\/} im Juli 1997
+
+ \bigskip
+
+ Gegenmaßnahmen
+ \begin{itemize}
+ \item
+ \newterm{Priority Inheritance -- Prioritätsvererbung}\\
+ Der Besitzer des Mutex erbt die Priorität\\
+ des Prozesses, der auf den Mutex wartet.
+ \smallskip
+ \item
+ \newterm{Priority Ceiling -- Prioritätsobergrenze}\\
+ Der Besitzer des Mutex bekommt sofort\\
+ die Priorität des höchstmöglichen Prozesses,\\
+ der evtl.\ den Mutex benötigen könnte.
+ \pause
+ \begin{picture}(0,0)
+ \put(1.2,1.45){\makebox(0,0)[l]{$\left\}\rule{0pt}{1.7cm}\right.$
+ \begin{minipage}{4cm}
+ nur möglich, wenn\\
+ Mutexe im Spiel sind
+ \end{minipage}}}
+ \end{picture}
+ \smallskip
+ \pause
+ \item
+ \newterm{Priority Aging}\\
+ Die Priorität wächst mit der Wartezeit.
+ \end{itemize}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\fi
+
+\end{document}
diff --git a/20221116/herzschrittmacher.jpg b/20221116/herzschrittmacher.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..92d8f0053003cc555aec83f5d088f1cec822ad81
--- /dev/null
+++ b/20221116/herzschrittmacher.jpg
@@ -0,0 +1 @@
+../common/herzschrittmacher.jpg
\ No newline at end of file
diff --git a/20221116/i2c.jpg b/20221116/i2c.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e9041b98cdaec58233516da23139e9eea1a357ab
Binary files /dev/null and b/20221116/i2c.jpg differ
diff --git a/20221116/kompassmodul-an-roboter.jpg b/20221116/kompassmodul-an-roboter.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..dab8b38c1a92bf8072d42dc3abcc07be54a58c7b
--- /dev/null
+++ b/20221116/kompassmodul-an-roboter.jpg
@@ -0,0 +1 @@
+../common/kompassmodul-an-roboter.jpg
\ No newline at end of file
diff --git a/20221116/kompassmodul.jpg b/20221116/kompassmodul.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..be108a5341df13a693959dbe69b7b9541b36fc4c
--- /dev/null
+++ b/20221116/kompassmodul.jpg
@@ -0,0 +1 @@
+../common/kompassmodul.jpg
\ No newline at end of file
diff --git a/20221116/logo-hochschule-bochum-cvh-text-v2.pdf b/20221116/logo-hochschule-bochum-cvh-text-v2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8
--- /dev/null
+++ b/20221116/logo-hochschule-bochum-cvh-text-v2.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221116/logo-hochschule-bochum.pdf b/20221116/logo-hochschule-bochum.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1
--- /dev/null
+++ b/20221116/logo-hochschule-bochum.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221116/motherboard-anschluesse.jpg b/20221116/motherboard-anschluesse.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..07335d7dff65c71a683588d2ed108485c4653fb7
--- /dev/null
+++ b/20221116/motherboard-anschluesse.jpg
@@ -0,0 +1 @@
+../common/motherboard-anschluesse.jpg
\ No newline at end of file
diff --git a/20221116/pgslides.sty b/20221116/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64
--- /dev/null
+++ b/20221116/pgslides.sty
@@ -0,0 +1 @@
+../common/pgslides.sty
\ No newline at end of file
diff --git a/20221116/quadrocopter.jpg b/20221116/quadrocopter.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..7eaf0c024b63b7bc1dd3df2c17c8ab93f67fc15c
--- /dev/null
+++ b/20221116/quadrocopter.jpg
@@ -0,0 +1 @@
+../common/quadrocopter.jpg
\ No newline at end of file
diff --git a/20221116/rp6.jpg b/20221116/rp6.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..2a0ecff23845770c3a98178eca6dce3ec73aca58
--- /dev/null
+++ b/20221116/rp6.jpg
@@ -0,0 +1 @@
+../common/rp6.jpg
\ No newline at end of file
diff --git a/20221116/rs-232.pdf b/20221116/rs-232.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..67016059af4a0ca0db871b9dd784bcacc0eecf7a
--- /dev/null
+++ b/20221116/rs-232.pdf
@@ -0,0 +1 @@
+../common/rs-232.pdf
\ No newline at end of file
diff --git a/20221116/xbee.jpg b/20221116/xbee.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..ff0adff2eadf3d9b775d03cea8cf1f118534e2b9
--- /dev/null
+++ b/20221116/xbee.jpg
@@ -0,0 +1 @@
+../common/xbee.jpg
\ No newline at end of file