wieerwill/Informatik
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Performanz und Parallelität

Browse Source
This commit is contained in:
WieErWill 2022-03-01 20:27:52 +01:00
parent 1c1cc093cc
commit 50a57c0f1d
2 changed files with 109 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Advanced Operating Systems - Cheatsheet.pdf (Stored with Git LFS)
View File

Binary file not shown.

293
Advanced Operating Systems - Cheatsheet.tex
View File

@ -3100,284 +3100,197 @@
\item cgroups: Accounting/Beschränkung der Ressourcenzuordnung \item cgroups: Accounting/Beschränkung der Ressourcenzuordnung
\item union mounting: Funktion zur logischen Reorganisation hierarchischer Dateisysteme \item union mounting: Funktion zur logischen Reorganisation hierarchischer Dateisysteme
\end{itemize*} \end{itemize*}
\item \includegraphics[width=.8\linewidth]{Assets/AdvancedOperatingSystems-docker.png} \item \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-docker.png}
\end{itemize*} \end{itemize*}
\section{Performanz und \section{Performanz und Parallelität}
Parallelität} Motivation
\subsection{Motivation}
\begin{itemize*} \begin{itemize*}
\item Performanz: Wer hätte gern einen schnell(er)en Rechner...? \item Hochleistungsrechnen, HPC (,,high performancecomputing''
\item Wer braucht schnelle Rechner: \item ,,Big Data'': Dienstleistungen für Kunden
\begin{itemize*} \item Wettervorhersage
\item Hochleistungsrechnen, HPC (,,high performancecomputing'') \begin{itemize*} \item wissenschaftliches Rechnen(z.B. Modellsimulation natürlicher Prozesse, Radioteleskop-Datenverarbeitung) \item Datenvisualisierung(z.B. Analysen großer Netzwerke) \item Datenorganisation-und speicherung(z.B. Kundendatenverarbeitung zur Personalisierung von Werbeaktivitäten, Bürgerdatenverarbeitung zur Personalisierung von Geheimdienstaktivitäten) \end{itemize*} \item anspruchsvolle Multimedia- Anwendungen (Animationen, VR-Rendering)
\item nicht disjunkt dazu: kommerzielle Anwendungen \begin{itemize*} \item ,,Big Data'': Dienstleistungen für Kunden, die o. g. Probleme auf gigantischen Eingabedatenmengen zu lösen haben (Software wie Apache Hadoop ) \item Wettervorhersage \end{itemize*}
\item anspruchsvolle Multimedia- Anwendungen \begin{itemize*} \item Animationsfilme \item VR-Rendering \end{itemize*}
\end{itemize*}
\end{itemize*} \end{itemize*}
Performanzbegriff
\subsection{Performanzbegriff}
\begin{itemize*} \begin{itemize*}
\item Performance: The degree to which a system or component accomplishes \item Minimierung der für korrekte Funktion (= Lösung eines Berechnungsproblems) zur Verfügung stehenden Zeit.
its designated functions within given constraints, such as speed, \item technischer: Maximierung der Anzahl pro Zeiteinheit abgeschlossener Berechnungen
accuracy, or memory usage. (IEEE)
\item Performanz im engeren Sinne dieses Kapitels: Minimierung der für
korrekte Funktion (= Lösung eines Berechnungsproblems) zur Verfügung
stehenden Zeit.
\item oder technischer: Maximierung der Anzahl pro Zeiteinheit
abgeschlossener Berechnungen.
\end{itemize*} \end{itemize*}
Anforderungen hochparallelen Rechnens an ...
\subsection{Roadmap}
\begin{itemize*}
\item Grundlegende Erkenntnis: Performanz geht nicht (mehr) ohne
Parallelität $\rightarrow$ Hochleistungsrechnen =
hochparalleles Rechnen
\item daher in diesem Kapitel: Anforderungen hochparallelen Rechnens an ...
\begin{itemize*} \begin{itemize*}
\item Hardware: Prozessorarchitekturen \item Hardware: Prozessorarchitekturen
\item Systemsoftware: Betriebssystemmechanismen \item Systemsoftware: Betriebssystemmechanismen
\item Anwendungssoftware: Parallelisierbarkeitvon Problemen \item Anwendungssoftware: Parallelisierbarkeitvon Problemen
\end{itemize*} \end{itemize*}
\item BS-Architekturen anhand von Beispielsystemen:
\begin{itemize*}
\item Multikernel: Barrelfish
\item verteilte Betriebssysteme
\end{itemize*}
\end{itemize*}
\subsection{Hardware-Voraussetzungen} \subsection{Hardware-Voraussetzungen}
\begin{itemize*}
\item Entwicklungstendenzen der Rechnerhardware:
\begin{itemize*} \begin{itemize*}
\item Entwicklungstendenzen der Rechnerhardware
\item Multicore-Prozessoren: seit ca. 2006 (in größerem Umfang) \item Multicore-Prozessoren: seit ca. 2006 (in größerem Umfang)
\item Warum neues Paradigma für Prozessoren? bei CPU-Taktfrequenz $>>$ 4 GHz: z.Zt. physikalische Grenze, u.a. nicht mehr sinnvoll handhabbare Abwärme \item bei CPU-Taktfrequenz $>>$ 4GHz z.Zt. physikalische Grenze%, u.a. nicht mehr sinnvoll handhabbare Abwärme
\item Damit weiterhin: \begin{enumerate*} \item Anzahl der Kerne wächst nicht linear \item Taktfrequenz wächst asymptotisch, nimmt nur noch marginal zu \end{enumerate*} \item Anzahl der Kerne wächst nicht linear
\end{itemize*} \item Taktfrequenz wächst asymptotisch, nimmt nur noch marginal zu
\end{itemize*} \end{itemize*}
\subsection{Performanz durch Parallelisierung ...}
\subsection{Performanz durch Parallelisierung
...}
Folgerungen
\begin{enumerate*} \begin{enumerate*}
\item weitere Performanz-Steigerung von Anwendungen: primär durch \item Performanz-Steigerung von Anwendungen: primär durch Parallelität, Multi-Threaded-Anwendungen
Parallelität (aggressiverer) Multi-Threaded-Anwendungen \item erforderlich: Betriebssystem-Unterstützung $\rightarrow$ Scheduling, Sychronisation
\item erforderlich: Betriebssystem-Unterstützung \item weiterhin: Sprachen, Compiler, verteilte Algorithmen ...
$\rightarrow$ Scheduling, Sychronisation
\item weiterhin erforderlich: Formulierungsmöglichkeiten (Sprachen),
Compiler, verteilte Algorithmen ... $\rightarrow$ hier
nicht im Fokus
\end{enumerate*} \end{enumerate*}
\subsection{... auf Prozessorebene} \subsection{... auf Prozessorebene}
Vorteile von Multicore-Prozessoren Vorteile von Multicore-Prozessoren
\begin{enumerate*} \begin{enumerate*}
\item möglich wird: \textbf{Parallelarbeit auf Chip-Ebene} \item möglich wird: \textbf{Parallelarbeit auf Chip-Ebene} $\rightarrow$ Vermeidung der Plagen paralleler verteilter Systeme
$\rightarrow$ Vermeidung der Plagen paralleler \item bei geeigneter Architektur: Erkenntnisse und Software aus Gebiet verteilter Systeme als Grundlage verwendbar
verteilter Systeme \item durch gemeinsame Caches (architekturabhängig): schnellere Kommunikation (speicherbasiert), billigere Migration von Aktivitäten kann möglich sein
\item bei geeigneter Architektur: Erkenntnisse und Software aus Gebiet \item höhere Energieeffizienz: mehr Rechenleistung pro Chipfläche, geringere elektrische Leistungsaufnahme $\rightarrow$ weniger Gesamtabwärme, z.T. einzelne Kerne abschaltbar
verteilter Systeme als Grundlage verwendbar
\item durch gemeinsame Caches (architekturabhängig): schnellere
Kommunikation (speicherbasiert), billigere Migration von Aktivitäten
kann möglich sein
\item höhere Energieeffizienz: mehr Rechenleistung pro Chipfläche, geringere
elektrische Leistungsaufnahme $\rightarrow$ weniger
Gesamtabwärme, z.T. einzelne Kerne abschaltbar (vgl. Sparsamkeit ,
mobile Geräte)
\item Baugröße: geringeres physisches Volumen \item Baugröße: geringeres physisches Volumen
\end{enumerate*} \end{enumerate*}
Nachteile von Multicore-Prozessoren Nachteile von Multicore-Prozessoren
\begin{enumerate*} \begin{enumerate*}
\item durch gemeinsam genutzte Caches und Busstrukturen: Engpässe \item durch gemeinsam genutzte Caches und Busstrukturen: Engpässe (Bottlenecks) möglich
(Bottlenecks) möglich \item zur Vermeidung thermischer Zerstörungen: Lastausgleich zwingend erforderlich! (Ziel: ausgeglichene Lastverteilung auf einzelnen Kernen)
\item zur Vermeidung thermischer Zerstörungen: Lastausgleich zwingend \end{enumerate*}
erforderlich! (Ziel: ausgeglichene Lastverteilung auf einzelnen
Kernen) zum optimalen Einsatz zwingend erforderlich
\item zum optimalen Einsatz zwingend erforderlich:
\begin{enumerate*} \begin{enumerate*}
\item Entwicklung Hardwarearchitektur \item Entwicklung Hardwarearchitektur
\item zusätzlich: Entwicklung geeigneter Systemsoftware \item zusätzlich: Entwicklung geeigneter Systemsoftware
\item zusätzlich: Entwicklung geeigneter Anwendungssoftware \item zusätzlich: Entwicklung geeigneter Anwendungssoftware
\end{enumerate*} \end{enumerate*}
\end{enumerate*}
\subsubsection{Multicore-Prozessoren} \subsubsection{Multicore-Prozessoren}
Terminologie und Abkürzungen
\begin{itemize*} \begin{description*}
\item Sprechweise in der Literatur gelegentlich unübersichtlich... \item[MC] multicore (processor)
\item daher: Terminologie und Abkürzungen: \item[CMP] chip-level multiprocessing, hochintegrierte Bauweise für MC
\begin{itemize*} \item[SMC] symmetric multicore $\rightarrow$ SMP ... symm. multi-processing
\item MC ...multicore(processor) \item[AMC] asymmetric multicore $\rightarrow$ AMP ... asymmetric multi-processing
\item CMP ...chip-level multiprocessing, hochintegrierte Bauweise für ,,MC'' \item[UP] uni-processing, singlecore (SC) oder uniprocessor
\item SMC ...symmetric multicore $\rightarrow$ SMP ... symmetric multi-processing \end{description*}
\item AMC ...asymmetric (auch: heterogeneous ) multicore $\rightarrow$ AMP ... asymmetric multi-processing
\item UP ...uni-processing , Synonym zu singlecore(SC) oder uniprocessor
\end{itemize*}
\end{itemize*}
Architekturen von Multicore-Prozessoren Architekturen von Multicore-Prozessoren
\begin{itemize*} \begin{itemize*}
\item A. Netzwerkbasiertes Design \item Netzwerkbasiertes Design
\begin{itemize*} \begin{itemize*}
\item Prozessorkerne des Chips u. ihre lokalen Speicher (oder Caches): durch Netzwerkstruktur verbunden \item Prozessorkerne des Chips u. ihre lokalen Speicher (oder Caches) durch Netzwerkstruktur verbunden
\item damit: größte Ähnlichkeit zu traditionellen verteilten Systemen \item größte Ähnlichkeit zu traditionellen verteilten Systemen
\item Verwendung: bei Vielzahl von Prozessorkernen (Skalierbarkeit!) \item Verwendung bei Vielzahl von Prozessorkernen (Skalierbar)
\item Beispiel: Intel Teraflop-Forschungsprozessor Polaris (80 Kerne als 8x10-Gitter) %\item Beispiel: Intel Teraflop-Forschungsprozessor Polaris (80 Kerne als 8x10-Gitter)
%\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren.png} \item \includegraphics[width=.3\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren.png}
\end{itemize*} \end{itemize*}
\item B. Hierarchisches Design \item Hierarchisches Design
\begin{itemize*} \begin{itemize*}
\item mehrere Prozessor-Kerne teilen sich mehrere baumartig angeordnete Caches \item mehrere Prozessor-Kerne teilen sich baumartige Caches
\item meistens: \begin{itemize*} \item jeder Prozessorkern hat eigenen L1-Cache \item L2-Cache, Zugriff auf (externen) Hauptspeicher u. Großteil der Busse aber geteilt \end{itemize*} \item jeder Prozessorkern hat eigenen L1-Cache
\item L2-Cache, Zugriff auf Hauptspeicher u. Großteil der Busse %aber geteilt
\item Verwendung: typischerweise Serverkonfigurationen \item Verwendung: typischerweise Serverkonfigurationen
\item Beispiele: \begin{itemize*} \item IBM Power \item Intel Core 2, Core i \item Sun UltraSPARCT1 (Niagara) \end{itemize*} \item \includegraphics[width=.3\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png}
%\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png}
\end{itemize*} \end{itemize*}
\item C. Pipeline-Design \item Pipeline-Design
\begin{itemize*} \begin{itemize*}
\item Daten durch mehrere Prozessor-Kerne schrittweise verarbeitet \item Daten durch Prozessor-Kerne schrittweise verarbeitet
\item durch letzten Prozessor: Ablage im Speichersystem \item durch letzten Prozessor: Ablage im Speichersystem
\item Verwendung: \begin{itemize*} \item Graphikchips \item (hochspezialisierte) Netzwerkprozessoren \end{itemize*} \item Verwendung: Graphikchips, Netzwerkprozessoren
\item Beispiele: Prozessoren X10 u. X11 von Xelerator zur Verarbeitung von Netzwerkpaketen in Hochleistungsroutern (X11: bis zu 800 Pipeline-Prozessorkerne) %\item Beispiele: Prozessoren X10 u. X11 von Xelerator zur Verarbeitung von Netzwerkpaketen in Hochleistungsroutern (X11: bis zu 800 Pipeline-Prozessorkerne)
%\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png} \item \includegraphics[width=.3\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png}
\end{itemize*} \end{itemize*}
\end{itemize*} \end{itemize*}
Symmetrische u. asymmetrische Multicore-Prozessoren Symmetrische u. asymmetrische Multicore-Prozessoren
\begin{itemize*} \begin{itemize*}
\item symmetrische Multicore-Prozessoren (SMC) \item symmetrische Multicore-Prozessoren (SMC): alle Kerne identisch, d.h. gleiche Architektur und gleiche Fähigkeiten
\begin{itemize*} %\item Beispiele: \begin{itemize*} \item Intel Core 2 Duo \item Intel Core 2 Quad \item ParallaxPropeller \end{itemize*}
\item alle Kerne identisch, d.h. gleiche Architektur und gleiche Fähigkeiten \item asymmetrische MC-Prozessoren (AMC): Multicore-Architektur, jedoch mit Kernen unterschiedlicher Architektur
\item Beispiele: \begin{itemize*} \item Intel Core 2 Duo \item Intel Core 2 Quad \item ParallaxPropeller \end{itemize*}
\end{itemize*}
\item asymmetrische MC-Prozessoren (AMC)
\item Multicore-Architektur, jedoch mit Kernen unterschiedlicher Architektur
und/oder unterschiedlichen Fähigkeiten und/oder unterschiedlichen Fähigkeiten
\item Beispiel: Kilocore:
\begin{itemize*}
\item 1 Allzweck-Prozessor (PowerPC)
\item \begin{itemize*} \item 256 od. 1024 Datenverarbeitungsprozessoren \end{itemize*}
\end{itemize*}
\end{itemize*} \end{itemize*}
\subsubsection{Superskalare Prozessoren}
\subsubsection{Superskalare
Prozessoren}
\begin{itemize*} \begin{itemize*}
\item Bekannt aus Rechnerarchitektur: Pipelining \item Bekannt aus Rechnerarchitektur: Pipelining
\begin{itemize*} \begin{itemize*}
\item parallele Abarbeitung von Teilen eines Maschinenbefehls in Pipeline-Stufen \item parallele Abarbeitung von Teilen eines Maschinenbefehls in Pipeline-Stufen
\item ermöglicht durch verschiedene Funktionseinheiten eines Prozessors für verschiedene Stufen: \begin{itemize*} \item Control Unit (CU) \item ArithmeticLogicUnit (ALU) \item Float Point Unit (FPU) \item Memory Management Unit (MMU) \item Cache \end{itemize*} \item ermöglicht durch verschiedene Funktionseinheiten eines Prozessors für verschiedene Stufen
%\begin{itemize*}
% \item Control Unit (CU)
% \item Arithmetic Logic Unit (ALU)
% \item Float Point Unit (FPU)
% \item Memory Management Unit (MMU)
% \item Cache
%\end{itemize*}
\item sowie mehrere Pipeline-Register \item sowie mehrere Pipeline-Register
\end{itemize*} \end{itemize*}
\item superskalare Prozessoren: solche, bei denen zur Bearbeitung einer \item superskalare Prozessoren: solche, bei denen zur Bearbeitung einer Pipeling-Stufe erforderlichen Funktionseinheiten n-fach vorliegen
Pipeling-Stufe erforderlichen Funktionseinheiten n-fach vorliegen \item Ziel
\item Ziel:
\begin{itemize*} \begin{itemize*}
\item Skalarprozessor (mit Pipelining): 1 Befehl pro Takt (vollständig) bearbeitet \item Skalarprozessor (mit Pipelining): 1 Befehl pro Takt (vollständig) bearbeitet
\item Superskalarprozessor: bis zu n Befehle pro Taktbearbeitet \item Superskalarprozessor: bis zu n Befehle pro Taktbearbeitet
\end{itemize*} \end{itemize*}
\item Verbereitung heute: universell (bis hin zu allen \item Verbereitung heute: universell %(bis hin zu allen Desktop-Prozessorfamilien)
Desktop-Prozessorfamilien)
\end{itemize*} \end{itemize*}
\subsection{Parallelisierung in Betriebssystemen}
\subsection{Parallelisierung in
Betriebssystemen}
\begin{itemize*} \begin{itemize*}
\item Basis für alle Parallelarbeit aus BS-Sicht: Multithreading \item Basis für alle Parallelarbeit aus BS-Sicht: Multithreading
\item wir erinnern uns ...:
\begin{itemize*} \begin{itemize*}
\item Kernel-Level-Threads (KLTs): BS implementiert Threads $\rightarrow$ Scheduler kann mehrere Threads nebenläufig planen $\rightarrow$ Parallelität möglich \item Kernel-Level-Threads (KLTs): BS implementiert Threads $\rightarrow$ Scheduler kann mehrere Threads nebenläufig planen $\rightarrow$ Parallelität möglich
\item User-Level-Threads (ULTs): Anwendung implementiert Threads $\rightarrow$ keine Parallelität möglich! \item User-Level-Threads (ULTs): Anwendung implementiert Threads $\rightarrow$ keine Parallelität möglich
\end{itemize*} \end{itemize*}
\item grundlegend für echt paralleles Multithreading: \item grundlegend für echt paralleles Multithreading
\begin{itemize*} \begin{itemize*}
\item parallelisierungsfähige Hardware \item parallelisierungsfähige Hardware
\item kausal unabhängige Threads \item kausal unabhängige Threads
\item passendes (und korrekt eingesetztes!) Programmiermodell, insbesondere Synchronisation! \item passendes Programmiermodell, insbesondere Synchronisation!
\item[$\rightarrow$] Programmierer + Compiler \item[$\rightarrow$] Programmierer + Compiler
\end{itemize*} \end{itemize*}
\end{itemize*} \item BS-Abstraktionen müssen Parallelität unterstützen %(Abstraktion nebenläufiger Aktivitäten: KLTs)
Vorläufiges Fazit:
\begin{itemize*}
\item BS-Abstraktionen müssen Parallelität unterstützen (Abstraktion
nebenläufiger Aktivitäten: KLTs)
\item BS muss Synchronisationsmechanismen implementieren \item BS muss Synchronisationsmechanismen implementieren
\end{itemize*} \end{itemize*}
\subsubsection{Synchronisations- und Sperrmechanismen}
\subsubsection{Synchronisations- und
Sperrmechanismen}
\begin{itemize*} \begin{itemize*}
\item Synchronisationsmechanismen zur Nutzung \item Synchronisationsmechanismen zur Nutzung
\begin{itemize*} \begin{itemize*}
\item ... durch Anwendungen $\rightarrow$ Teil der API \item durch Anwendungen $\rightarrow$ Teil der API
\item ... durch den Kernel (z.B. Implementierung Prozessmanagement, E/A, ...) \item durch den Kernel
\end{itemize*} \end{itemize*}
\item Aufgabe: Verhinderung konkurrierender Zugriffe auf logische oder \item Verhinderung konkur. Zugriffe auf logische/physische Ressourcen
physische Ressourcen
\begin{itemize*} \begin{itemize*}
\item Vermeidung von race conditions \item Vermeidung von race conditions
\item Herstellung einer korrekten Ordnung entsprechend Kommunikationssemantik (z.B. ,,Schreiben vor Lesen'') \item Herstellung einer korrekten Ordnung entsprechend Kommunikationssemantik (z.B. ,,Schreiben vor Lesen'')
\end{itemize*} \end{itemize*}
\item (alt-) bekanntes Bsp.: Reader-Writer-Problem
\end{itemize*} \end{itemize*}
Erinnerung: Reader-Writer-Problem Erinnerung: Reader-Writer-Problem
\begin{itemize*}
\item Begriffe: (bekannt)
\begin{itemize*} \begin{itemize*}
\item wechselseitiger Ausschluss ( mutual exclusion) \item wechselseitiger Ausschluss ( mutual exclusion)
\item kritischer Abschnitt (critical section) \item kritischer Abschnitt (critical section)
\end{itemize*} \item Synchronisationsprobleme
\item Synchronisationsprobleme:
\begin{itemize*} \begin{itemize*}
\item Wie verhindern wir ein write in vollen Puffer? \item write in vollen Puffer
\item Wie verhindern wir ein read aus leerem Puffer? \item read aus leerem Puffer
\item Wie verhindern wir, dass auf ein Element während des read durch ein gleichzeitiges write zugegriffen wird? (Oder umgekehrt?) \item während read durch gleichzeitiges write zugegriffen
\end{itemize*} \end{itemize*}
\end{itemize*} \end{itemize*}
Sperrmechanismen (Locks) Sperrmechanismen (Locks)
\begin{itemize*} \begin{itemize*}
\item Wechselseitiger Ausschluss ... \item Wechselseitiger Ausschluss ...
\begin{itemize*} \begin{itemize*}
\item ... ist in nebenläufigen Systemen zwingend erforderlich \item ist in nebenläufigen Systemen zwingend erforderlich
\item ... ist in echt parallelen Systemen allgegenwärtig \item ist in echt parallelen Systemen allgegenwärtig
\item ... skaliert äußerst unfreundlich mit Code-Komplexität $\rightarrow$ (monolithischer) Kernel-Code! \item skaliert äußerst unfreundlich mit Code-Komplexität $\rightarrow$ (monolithischer) Kernel-Code
\end{itemize*} \end{itemize*}
\item Mechanismen in Betriebssystemen: Locks \item Mechanismen in Betriebssystemen: Locks
\item Arten von Locks am Beispiel Linux: \item Arten von Locks am Beispiel Linux
\begin{itemize*} \begin{itemize*}
\item Big Kernel Lock (BKL) \begin{itemize*} \item historisch (1996-2011): lockkernel(); ... unlockkernel(); \item ineffizient durch massiv gestiegene Komplexität des Kernels \end{itemize*} \item Big Kernel Lock (BKL)
\item atomic-Operationen \item atomic-Operationen
\item Spinlocks \item Spinlocks
\item Semaphore (Spezialform: Reader/Writer Locks) \item Semaphore (Spezialform: Reader/Writer Locks)
@ -3385,44 +3298,23 @@
\end{itemize*} \end{itemize*}
atomic* atomic*
\begin{itemize*}
\item Bausteine der komplexeren Sperrmechanismen:
\begin{itemize*} \begin{itemize*}
\item Bausteine der komplexeren Sperrmechanismen
\item Granularität: einzelne Integer- (oder sogar Bit-) Operation \item Granularität: einzelne Integer- (oder sogar Bit-) Operation
\item Performanz: mittels Assembler implementiert, nutzt Atomaritäts garantiender CPU ( TSL - Anweisungen: ,,test-set-lock'' ) \item Performanz: mittels Assembler implementiert %nutzt Atomaritäts garantiender CPU ( TSL - Anweisungen: ,,test-set-lock'' )
\end{itemize*}
\item Benutzung:
%\begin{Shaded}
%\begin{Highlighting}[]
%\DataTypeTok{atomic_t}\NormalTok{ x;}
%\NormalTok{atomic_set(\&x, }\DecValTok{42}\NormalTok{);}
%\DataTypeTok{int}\NormalTok{ y = atomic_read(\&x);}
%\end{Highlighting}
%\end{Shaded}
\begin{itemize*}
\item \texttt{atomic\_*} Geschmacksrichtungen: read, set, add, sub, inc, dec u. a. \item \texttt{atomic\_*} Geschmacksrichtungen: read, set, add, sub, inc, dec u. a.
\item keine explizite Lock-Datenstruktur $\rightarrow$ Deadlocks durch Mehrfachsperrung syntaktisch unmöglich \item keine explizite Lock-Datenstruktur $\rightarrow$ Deadlocks durch Mehrfachsperrung syntaktisch unmöglich
\item definierte Länge des kritischen Abschnitts (genau diese eine Operation) $\rightarrow$ unnötiges Sperren sehr preiswert \item definierte Länge des kritischen Abschnitts $\rightarrow$ unnötiges Sperren sehr preiswert
\end{itemize*}
\end{itemize*} \end{itemize*}
\pagebreak
\section{Zusammenfassung} \section{Zusammenfassung}
\subsection{Funktionale und nichtfunktionale Eigenschaften}
\subsection{Funktionale und nichtfunktionale
Eigenschaften}
\begin{itemize*} \begin{itemize*}
\item Funktionale Eigenschaften: beschreiben, was ein (Software)-Produkt tun \item Funktionale Eigenschaften: beschreiben, was ein (Software)-Produkt tun soll
soll \item Nichtfunktionale Eigenschaften: beschreiben, wie funktionale Eigenschaften realisiert werden, also welche sonstigen Eigenschaftendas Produkt haben soll ... unterteilbar in
\item Nichtfunktionale Eigenschaften: beschreiben, wie funktionale
Eigenschaften realisiert werden, also welche sonstigen
Eigenschaftendas Produkt haben soll ... unterteilbar in:
\begin{enumerate*} \begin{enumerate*}
\item Laufzeiteigenschaften (zur Laufzeit sichtbar) \item Laufzeiteigenschaften (zur Laufzeit sichtbar)
\item Evolutionseigenschaften (beim Betrieb sichtbar: Erweiterung, Wartung, Test usw.) \item Evolutionseigenschaften (beim Betrieb sichtbar: Erweiterung, Wartung, Test usw.)
\end{enumerate*} \end{enumerate*}
@ -3778,4 +3670,5 @@
werden Sie aktiv! werden Sie aktiv!
\end{multicols} \end{multicols}
\end{document} \end{document}