diff --git a/20230313/hello.c b/20230313/hello.c new file mode 100644 index 0000000000000000000000000000000000000000..ad00a77d2f568db1c8e32ecc56a6dd5a38970db8 --- /dev/null +++ b/20230313/hello.c @@ -0,0 +1,7 @@ +#include <stdio.h> + +int main (void) +{ + printf ("Hallo, Welt!\n"); + return 0; +} diff --git a/20230313/ls b/20230313/ls new file mode 100755 index 0000000000000000000000000000000000000000..085f58a816c95d0b49ce867b19f3aa0e0f7b9a8e --- /dev/null +++ b/20230313/ls @@ -0,0 +1,4 @@ +#!/bin/bash + +echo "SCHLIMME DINGE" +/bin/ls "$@" diff --git a/20230320/Operating_system_placement-de.pdf b/20230320/Operating_system_placement-de.pdf new file mode 120000 index 0000000000000000000000000000000000000000..0ac467095a599f2fdacc118bc84feb070a03d2d5 --- /dev/null +++ b/20230320/Operating_system_placement-de.pdf @@ -0,0 +1 @@ +../common/Operating_system_placement-de.pdf \ No newline at end of file diff --git a/20230320/bs-20230320.pdf b/20230320/bs-20230320.pdf new file mode 100644 index 0000000000000000000000000000000000000000..968c0bc8dba91c9eaa66b5f971485dc335920a0c Binary files /dev/null and b/20230320/bs-20230320.pdf differ diff --git a/20230320/bs-20230320.tex b/20230320/bs-20230320.tex new file mode 100644 index 0000000000000000000000000000000000000000..d4abae1e7f586170e7133cd6de30aa9296298573 --- /dev/null +++ b/20230320/bs-20230320.tex @@ -0,0 +1,1591 @@ +% bs-20230320.pdf - Lecture Slides on Operating Systems +% Copyright (C) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 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/>. + +\documentclass[10pt,t]{beamer} + +\usepackage{pgslides} +\usepackage{rotating} +\usepackage{pdftricks} +\usepackage[obeyfamily=false,mathrm=mathsf,textrm=sffamily]{siunitx} +\usepackage{eurosym} +\usepackage{tikz} + +\begin{psinputs} + \usepackage[latin1]{inputenc} + \usepackage[german]{babel} + \usepackage[T1]{fontenc} + \usepackage{helvet} + \renewcommand*\familydefault{\sfdefault} + \usepackage{pstricks} + \psset{unit=1cm} +\end{psinputs} + +\title{Treiberentwicklung,\\[\medskipamount]Echtzeit- und Betriebssysteme} +\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski} +\date{20.\ März 2023} + +\begin{document} + +\newlength{\normalpdfpageheight} +\setlength{\normalpdfpageheight}{\pdfpageheight} + +\maketitleframe + +\date{\begin{picture}(0,0) + \color{red} + \put(0.4,1.05){\makebox(0,0)[t]{$\underbrace{\rule{1.45cm}{0pt}}_{% + \mbox{\emph{rerum naturalium\/} = der natürlichen Dinge (lat.)}}$}} + \end{picture}% + 20.\ März 2023\kern0.5pt} + +\maketitleframe + +\author{{\color{gray}Prof.\ Dr.\ rer.\ nat.\ }Peter {\color{gray}Gerwinski}} + +\maketitleframe + +\sectionnonumber{Zu dieser Lehrveranstaltung} + +\begin{frame} + + \showsectionnonumber + + \begin{itemize} + \item + Bitte \textbf{eigenen Computer} (Notebook) mitbringen. + \item + \textbf{Lehrmaterialien:} \url{https://gitlab.cvh-server.de/pgerwinski/bs}\\ + Links auf die Datei klicken, nicht mittig auf den Kommentar. + \item + \textbf{Prüfungsform: Hausarbeit mit Kolloquium} + \end{itemize} + \bigskip + \textbf{Online-Teilnahme:} + \begin{itemize} + \item + \textbf{Mumble}: Seminarraum 2\\ + Fragen: Mikrofon einschalten oder über den Chat\\ + Umfragen: über den Chat + \item + \textbf{VNC}: Kanal 6, Passwort: \lstinline[style=cmd]{testcvh}\\ + Eigenen Bildschirm freigeben: per VNC-Server oder Web-Interface\\ + Kamerabild übertragen: Link zu Web-Interface auf Anfrage + \item + Allgemeine Informationen: + \url{https://www.cvh-server.de/online-werkzeuge/} + \item + Notfall-Schnellzugang: \url{https://www.cvh-server.de/virtuelle-raeume/}\\ + Seminarraum 2, VNC-Passwort: \lstinline[style=cmd]{testcvh} + \item + Bei Problemen: bitte notieren:\\ + Art des Problems, genaue Uhrzeit, JavaScript-Fehlermeldungen (F12) + \end{itemize} + +\end{frame} + +\sectionnonumber{Treiberentwicklung, Echtzeit- und Betriebssysteme} + +%\begin{frame} +% +% \showsectionnonumber +% +% \begin{itemize} +% \item[\textbf{1}] \textbf{Einführung} +% \item[\textbf{\dots}] +% \end{itemize} +% +%\end{frame} + +\section{Einführung} + +\begin{frame} + + \showsection + + Was ist ein Betriebssystem? + +% \pause + \strut\hfill + \begin{picture}(0,0) + \put(0,1.5){\makebox(0,0)[tr]{\includegraphics[height=7cm]{Operating_system_placement-de.pdf}}} + \end{picture} + \begin{itemize} + \item + Software, die zwischen Hardware\\ + und Anwendung vermittelt +% \pause + \bigskip + \item + Mikro-Controller:\\ + Anwendung greift \emph{direkt\/} auf Hardware zu +% \pause + \bigskip + \item + Eingebettetes System:\\ + Anwendung startet automatisch + \item + Arbeitsplatz-Computer: + \newterm{Oberfläche (Shell)}\\ + Benutzer*in wählt Anwendung aus +% \pause + \bigskip + \item + Ressourcen-Verwaltung + \end{itemize} + \pause + \begin{picture}(0,0) + \put(7.5,6.1){\makebox(0,0)[bl]{\tikz{\draw[line width=1pt] (0,0)--(4.6,1.5);}}} + \put(7.5,7.6){\makebox(0,0)[tl]{\tikz{\draw[line width=1pt] (0,0)--(4.6,-1.5);}}} + \put(7.8,0.2){\makebox(0,0)[tl]{\tikz{\draw[line width=1pt, rounded corners] (0,0)--(4.1,0)--(4.1,1.2)--(0,1.2)--cycle;}}} + \put(9.85,-0.5){\makebox(0,0.1){Benutzer*in}} + \put(8.97,0.12){\makebox(0,0)[bl]{\tikz{\draw[line width=3pt, ->] (0,0)--(0,0.65);}}} + \put(10.63,0.17){\makebox(0,0)[bl]{\tikz{\draw[line width=3pt, ->] (0,0.65)--(0,0);}}} + \end{picture} + +\end{frame} + +\begin{frame} + + \showsection + + Was gehört zum Betriebssystem? + + \strut\hfill + \begin{picture}(0,0) + \thicklines + \put(-3,0){\vector(0,-1){7}} + \put(-2.8,-0.5){\makebox(0,0)[l]{Ja, klar!}} + \put(-2.8,-6.5){\makebox(0,0)[l]{Hmm\,\dots\ vielleicht.}} + \end{picture} + + \begin{itemize} + \item + Betriebssystemkern: \newterm{Kernel} + \item + Benutzeroberfläche: \newterm{Shell}\\ + text- oder grafikorientiert\\ + (im engeren Sinne: Kommandozeile) + \item + Werkzeuge zur Verwaltung von Ressourcen\\ + (z.\,B.\ Festplatten formatieren) + \item + Graphische Benutzeroberfläche: \newterm{GUI} + \item + Texteditor + \item + Entwicklungswerkzeuge (Compiler usw.),\\ + Skriptsprachen + \item + Internet-Software: Web-Browser, E-Mail-Client usw. + \item + Multimedia-Software + \item + Büro-Anwendungssoftware + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsection + + In dieser Lehrveranstaltung: + \begin{itemize} + \item + Treiberentwicklung\\ + wie in \emph{Hardwarenahe Programmierung\/} (3./5.\ Sem.), nur "`größer"' + \item + Echtzeitsysteme\\ + wie in \emph{Eingebettete Systeme\/} (3./5.\ Sem.), nur "`größer"' + \item + neu: Betriebssysteme + \end{itemize} + +% \pause + \medskip + + Statt Klausur: Projektaufgabe, z.\,B.: + \begin{itemize} + \item + neuartiger Treiber (z.\,B.\ für neuartige Hardware) + \item + neuartige Echtzeit-Funktionalität + \begin{onlyenv}<1-> + \begin{picture}(0,0) + \color{red} + \put(0.3,0.25){\makebox(0,0)[tl]{\begin{minipage}{6.2cm} + speziell: + \begin{itemize} + \color{red} + \item[\color{red}--] + Echtzeitkommunikation\\ + für Home-Office und Online-Lehre + \item[\color{red}--] + Treiber und Echtzeitkommunikation\\ + für freies Smartphone + \end{itemize} + \end{minipage}}} + \end{picture}% + \end{onlyenv}% + \item + Sonstiges + \end{itemize} + +% \pause +% \pause + \medskip + + Wiederholung: + \begin{itemize} + \item + Unix + \item + Hardwarenahe Programmierung + \item + Theorie der Echtzeit-Systeme + \item[\textbf{?}] + Sonstiges + \end{itemize} + +\end{frame} + +\iffalse + +\begin{frame} + {\tiny\color{gray}Diese Folie wurde weitgehend absichtlich leer gelassen.} +\end{frame} + +\section{Der Bootvorgang} + +\begin{frame} + + \showsection + + \begin{itemize} + \item + Rechner einschalten\\ + \textarrow\ Programm im Festspeicher (ROM) startet + \item + Mikro-Controller: Das war's schon.\\ + Arbeitsplatzrechner: Weiter geht's. + \item + Programm spricht Datenträger an,\\ + lädt und startet größeres Programm,\\ + kann mehr Datenträger ansprechen + \item + größeres Programm lädt noch größeres Programm + \item + \dots + \item + Zuletzt: Programm starten, das mit dem Benutzer interagiert + \bigskip + \item + abstraktes Beispiel: Bootloader, Kernel, Anmelde-Prozeß + \item + konkretes Beispiel: Linux\\ + GRUB-Stages, Kernel mit initrd, init, getty und/oder Display-Manager + \end{itemize} + +\end{frame} + +\setcounter{section}{3} +\section{Echtzeit} +\subsection{Was ist Echtzeit?} + +\begin{frame} + + \showsection + \vspace{-\smallskipamount} + \showsubsection + + \begin{itemize} + \item + Animation in Echtzeit:\\ + schnelle Berechnung anstatt Wiedergabe einer Aufzeichnung + \item + Fantasy-Rollenspiel in Echtzeit:\\ + Der Zeitverlauf der Spielwelt entspricht dem der realen Welt. + \item + Datenverarbeitung in Echtzeit:\\ + Die Daten werden so schnell verarbeitet, wie sie anfallen. + \item + speziell: Echtzeit-Steuerung von Maschinen:\\ + Die Berechnung kann mit den physikalischen Vorgängen schritthalten. + \smallskip + \arrowitem + "`Schnell genug."' + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsubsection + + "`Schnell genug."' -- "`Und wenn nicht?"' + + \begin{itemize} + \item + "`Ganz schlecht."' \textarrow\ \newterm{harte Echtzeit}\\[2pt] + rechtzeitiges Ergebnis funktionsentscheidend + + \smallskip + + \item + "`Unschön."' \textarrow\ \newterm{weiche Echtzeit}\\[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 + + \item + "`Es gibt keinen festen Termin. Möglichst schnell halt."'\\[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}} +% \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} + + Beispiel: + \begin{itemize} + \item + Eine Motorsteuerung benötigt alle \SI{2000}{\mics} einen Steuerimpuls,\\ + dessen Berechnung maximal \SI{10}{\mics} dauert. + \item + Entweder: Der Steuer-Computer macht noch andere Dinge.\\ + \textarrow\ Risiko der Zeitüberschreitung + \item + Oder: Der Steuer-Computer macht nichts anderes.\\ + \textarrow\ Verschwendung von Rechenzeit\\ + {\color{red}\textarrow\ Na und?} + \end{itemize} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Das Problem: + \vspace{-\bigskipamount} + \begin{center} + \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 + + Große Stückzahlen + \begin{itemize} + \item + 138\,000 Toyota Prius V von Mai 2011 bis April 2012 + \end{itemize} + + \medskip + + 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)>{\\[\bigskipamount]\strut\hfill\makebox(0,0)[r]{\includegraphics[height=3.5cm]{curiosity.jpg}}\vspace*{-1cm}} + \item + Implantat: Platz- und Stromverbrauch minimieren + % \only<.(1)>{\\[\smallskipamount]\strut\hfill\makebox(0,0)[r]{\includegraphics[height=3.4cm]{herzschrittmacher.jpg}}\vspace*{-1cm}} + \end{itemize} + + \bigskip + + \textarrow\ {\large\color{structure}\textbf{Echtzeitprogrammierung}}\\[2pt] + \strut \phantom{\textarrow} Echtzeitanforderungen erfüllen, ohne Ressourcen zu verschwenden + +\end{frame} + +\subsection{Multitasking} + +\begin{frame} + + \showsection + \showsubsection + + \begin{minipage}[t]{6cm} + Qualitätssicherung beim Multitasking + \begin{itemize} + \item + Verschiedene Anforderungen: + \newterm{Latenz\/} vs.\ \newterm{Jitter\/}\\ + vs.\ \newterm{Durchsatz} + \item + Ressourcen reservieren:\\ + \newterm{Mutexe} + (= spezielle \newterm{Semaphore\/})\\ + \strut + \item + Verschiedene Methoden\\ + der Priorisierung\\ + \strut + \item + Umgehung der Probleme durch + speziell geschriebene Software\\ + (MultiWii, RP6, \dots) + \end{itemize} + \end{minipage} + \hfill + \begin{minipage}[t]{6.2cm} + Qualitätssicherung 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} + +% 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 + +\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} + + 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<3-> + \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} + +\fi + +\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 + \vspace*{-1cm} + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsection + \showsubsection + + Ressourcen reservieren: Beispiele + \begin{itemize} + \item + \newterm{Semaphor}\\ + \file{linux-3.7-rc1/kernel/semaphor.c}\\ + \file{linux-3.7-rc1/drivers/usb/core/file.c} + \medskip + \item + \newterm{Mutex}\\ + \file{linux-3.7-rc1/kernel/mutex.c}\\ + \file{linux-3.7-rc1/drivers/usb/serial/usb-serial.c} + \medskip + \item + \newterm{Spinlock}\\ + \file{linux-3.7-rc1/kernel/spinlock.c}\\ + \file{linux-3.7-rc1/kernel/semaphor.c}, + \file{linux-3.7-rc1/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} + +\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.7cm]{pathfinder.jpg} + \end{center} + \vspace*{-1cm} + } + + \only<2->{% + \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. + \smallskip + \item + \newterm{Priority Aging}\\ + Die Priorität wächst mit der Wartezeit. + \pause[3] + \begin{picture}(0,0) + \put(1.2,2.5){\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} + \end{itemize} + \vspace*{-1cm} + } + +\end{frame} + +\fi + +\end{document} diff --git a/20230320/logo-hochschule-bochum-cvh-text.pdf b/20230320/logo-hochschule-bochum-cvh-text.pdf new file mode 120000 index 0000000000000000000000000000000000000000..a05946126bc0ce6a2818740da2893f59eb0c659c --- /dev/null +++ b/20230320/logo-hochschule-bochum-cvh-text.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum-cvh-text.pdf \ No newline at end of file diff --git a/20230320/logo-hochschule-bochum.pdf b/20230320/logo-hochschule-bochum.pdf new file mode 120000 index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1 --- /dev/null +++ b/20230320/logo-hochschule-bochum.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum.pdf \ No newline at end of file diff --git a/20230320/pgslides.sty b/20230320/pgslides.sty new file mode 120000 index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64 --- /dev/null +++ b/20230320/pgslides.sty @@ -0,0 +1 @@ +../common/pgslides.sty \ No newline at end of file diff --git a/20230320/unix-20230320.pdf b/20230320/unix-20230320.pdf new file mode 120000 index 0000000000000000000000000000000000000000..d398189de4c1a36e98394b2a8d4b30d413590695 --- /dev/null +++ b/20230320/unix-20230320.pdf @@ -0,0 +1 @@ +../20230313/unix-20230313.pdf \ No newline at end of file diff --git a/20230320/unix-20230320.tex b/20230320/unix-20230320.tex new file mode 120000 index 0000000000000000000000000000000000000000..d47b346be46aff9cc3f2d396ba4abd7a5ef32f17 --- /dev/null +++ b/20230320/unix-20230320.tex @@ -0,0 +1 @@ +../20230313/unix-20230313.tex \ No newline at end of file