[Kapitel] Ergänze neue Inhalte

Kapitel/03_Speicher.tex

@@ -232,7 +232,7 @@ $\Rightarrow$ sobald das Zugriffsmuster Lokalität aufweist, ergibt sich eine be
 	\item[Valid-Flag] Die Daten werden im Cache geändert und müssen noch in den \acs{HS} zurückgeschrieben werden (nur bei Write-Back-Schreibstrategie)
 \end{description}
 
-\subsection{Vollassoziativer Cache}
+\subsection{Vollassoziativer Cache} \index{Cache!Vollassoziativ}
 Jede \acl{HSS} kann in jeder \acl{CL} eingelagert werden (nicht gleichzeitig!)
 
 \begin{itemize}
@@ -306,17 +306,266 @@ Somit ergibt sich als Schaltnetz für einen 4-Bit-Komparator die \autoref{fig:n_
 
 \acs{HW}-Aufwand für einen kaskadierbaren 1-Bit-Komparator
 \begin{itemize}[noitemsep]
-	\item[] HW: 42 Transistoren
+	\item HW: 42 Transistoren
-	\item[] Zeit: 2 \acs{GLZ}
+	\item Zeit: 2 \acs{GLZ}
 \end{itemize}
 
-
 Im Cache reicht der Vergleich auf Gleichheit aller Ziffern parallel:
 
 \begin{itemize}[noitemsep]
 	\item 2 $n$-Bit-Zahlen: $n$ Äquivalenzgatter und 1 \code{UND} mit $n$ Eingängen. (vergleiche \autoref{fig:cache_komparator_3})
 
-		$\Rightarrow$ $7n$ Transistoren HW-Aufwand
+		$\Rightarrow$ $7n$ Transistoren \acs{HW}-Aufwand
 
 		$\Rightarrow$  3 \acs{GLZ} Zeitaufwand
-\end{itemize}\todo{Formatieren, etc}
+\end{itemize}
+
+\subsection{Direct-Mapped Cache}\index{Cache!Direct-Mapped}
+
+\begin{wrapfigure}[8]{r}[15mm]{78mm}
+	\centering
+	\vspace*{-15mm}
+	\begin{tikzpicture}
+		\draw (0.5, 0) rectangle ++(2,1);
+		\node at (1.5, 0.5) (Tag) {Tag};
+		\draw [decorate,decoration={brace,amplitude=6pt,raise=4pt},yshift=0pt]
+		(0.5,1) -- (4,1) node [black,midway,yshift=0.7cm,font=\footnotesize] {
+			Nummer der \acs{HSS}};
+		
+		\draw (2.5, 0) rectangle ++(1.5,1);
+		\node at (3.25, 0.5) (mBit) {$m$-Bit};
+		\draw[->,very thick] (3.25,0) -- ++(0,-1.5);
+		\node[font=\footnotesize,align=center] at (3.25, -2) (mBesc) {Nummer der\\ \acs{CL} im \acs{DMC}};
+		
+		\draw (4, 0) rectangle ++(1.5,1);
+		\node at (4.75, 0.5) (kBit) {$k$-Bit};
+		\draw[->,very thick] (4.75,0) -- ++(0,-0.6);
+		\node[font=\footnotesize,align=center] at (4.75, -1.1) (kBesch) {Position innerhalb\\einer \acs{HSS}};
+	\end{tikzpicture}
+	\caption{Direct-Mapped-Cache-Line}
+	\label{fig:direct_mapped_cache_line}
+\end{wrapfigure}
+
+Beim \acf{DMC} gibt es für jede \acs{HSS} nur/genau eine \acs{CL}, in welche diese \acs{HSS} eingelagert werden kann. \newline
+$\Rightarrow$ es ist nur ein Komparator nötig
+
+Es ist eine Hash-Funktion notwendig, welche die gekürzte \acs{HSA} auf die \acs{CL}-Nummer abbildet. Die einfachste Hash-Funktion ist \enquote{Modulo} (Rest einer Ganzzahldivision).
+
+Modulo ist besonders einfach, falls der Divisor eine Zweierpotenz (\zB $2^m$) an Bits ist, denn dann stellen die niederwertigsten $m$ Bit den gesuchten Rest dar! Nachteil ist, dass dadurch nur Zweierpotenzen an \acsp{CL} möglich sind.
+
+Viele Paare von \acs{HSS} können nicht gleichzeitig im Cache gehalten werden (bei gleichem Ergebnis der Hash-Funktion). Eine mögliche Problemlösung: Ausweichfunktion (wird aus Zeitgründen beim Cache nicht verwendet).
+
+\textbf{Abhilfe}: \acf{nWAC}
+
+\subsection{$n$-Wege-Assoziativ-Cache} \index{Cache!$n$-Wege-Assoziativ-Cache}
+Für jede \acs{HSS} gibt es genau $n$ \acl{CL}, in welche die \acs{HSS} eingelagert werden kann.
+Realisierung über $n$ \acs{DMC}, welche alle jeweils gleich aufgebaut sind.
+
+
+\subsection{Kollision}
+Falls beim Einlagern einer \acl{HSS} in den Cache bereits alle für diese \acs{HSS} in Frage kommenden \aclp{CL} belegt sind, handelt es sich um eine Kollision.
+
+Eine Kollision kann frühestens auftreten:
+\begin{itemize}[noitemsep]
+	\item beim \acs{VAC}: bei vollem (heißen) Cache
+	\item beim \acs{DMC}: beim zweiten Zugriff
+	\item beim $n$-Wege-\acs{AC}: beim $(n+1)$-ten Zugriff
+\end{itemize}
+
+Wie groß ist die Kollisionswahrscheinlichkeit?
+
+\begin{tabular}{c@{}llccl}
+	\textbullet~ & \acs{DMC}:         & $p_\text{Kollision beim 2. Zugriff}$  & $=$ & $\frac{1}{\text{Anzahl \acs{CL}}}$ & $=\frac{1}{2^m}$      \\[1.5ex]
+	\textbullet~ & $n$-Wege-\acs{AC}: & $p_\text{Kollision beim n+1 Zugriff}$ & $=$ &        $(\frac{1}{2^m})^n$         & $=(\frac{1}{2^{mn}})$
+\end{tabular}
+
+\bigskip
+Beispiel: Vergleich \acs{DMC} mit 2-Wege-\acs{AC}
+
+\begin{tabular}{c@{}l@{}ll}
+	\textbullet~ & \acs{DMC}:       & Anzahl \acs{CL} $= 16 \Rightarrow m=4: p_\text{Kollision 2. Zugriff}$   & $=\frac{1}{2^4}=0,0625=6,25\%$                 \\[1.5ex]
+	\textbullet~ & 2-Wege-\acs{AC}:~ & Anzahl \acs{CL} je 8~ $\Rightarrow m=3: p_\text{Kollision 2. Zugriff}$ & $=\frac{1}{2^{3\cdot 2}}=\frac{1}{2^6}=1,5625$
+\end{tabular}
+
+\subsection{Verdrängung} \index{Cache!Verdrängung}
+Wenn eine \acs{HSS} in den Cache eingelagert werden soll, muss eine andere aus dem Cache entfernt werden. Eine Kollision ist Voraussetzung für Verdrängung. Mit einer Verdrängungsstrategie wird darüber entschieden, welche der möglichen \acs{HSS} verdrängt wird. In \autoref{sec:verdraengungsstrategie} wird auf die Verdrängungsstrategie eingegangen.
+
+\begin{Hinweis}
+	Eine Verdrängungsstrategie ist nur notwendig beim \acs{VAC} und beim $n$-Wege-\acs{AC}. Beim \acs{DMC} braucht man \textit{keine} Verdrängungsstrategie!
+\end{Hinweis}
+
+\subsection{Adressrechnen mit Cache}
+
+\columnratio{0.6}
+\begin{paracol}{2}
+	\begin{tabular}{c@{}ll}
+		\textbullet~ & 2-Wege-\acs{AC}:                          & $n=2$                  \\[1ex]
+		\textbullet~ & 2 \acs{DMC} mit jeweils 8 \acs{CL}:   & $m=3$                  \\[1ex]
+		\textbullet~ & jede \acs{CL} beinhaltet 16 Worte:    & $k=4$                  \\[1ex]
+		\textbullet~ & \acs{HS} beinhaltet $4096$ \acs{HSA}: & $2^{12}$ Speicherwerte
+	\end{tabular}
+	\switchcolumn
+	Der Tag ist $12-4-3=5$ Bit groß, siehe \autoref{fig:5_Bit_Tag}.
+\end{paracol}
+
+\bigskip
+\begin{Hinweis}
+	Die Größe eines Speicherwertes in Bit wird nicht definiert und ist auch unerheblich für die folgenden Überlegungen
+\end{Hinweis}
+
+\begin{figure}[!ht]
+	\centering
+	\begin{tikzpicture}
+		\draw (-0.5, 0) rectangle ++(3.5,1.5);
+		\node[align=center] at (1.25, 0.75) (Tag) {$12-m-k$ \\$=5$ Bit Tag};
+		\draw [decorate,decoration={brace,amplitude=6pt,raise=4pt},yshift=0pt]
+		(-0.5,1.5) -- (9,1.5) node [black,midway,yshift=0.7cm] {\acs{HSA} - 12 Bit};
+		
+		\draw (3, 0) rectangle ++(3,1.5);
+		\node[align=center] at (4.5, 0.75) (mBit) {$m$ (3) Bit\\\acs{CL}-Nummer};
+		
+		\draw (6, 0) rectangle ++(3,1.5);
+		\node[align=center] at (7.5, 0.75) (kBit) {$k$ (4) Bit\\ Pos. in \acs{CL}};
+	\end{tikzpicture}
+	\caption{Cache-Line mit $5$-Bit Tag}
+	\label{fig:5_Bit_Tag}
+\end{figure}
+
+\autoref{fig:adressrechnen} zeigt Cache A (links) und Cache B (rechts), mit denen im folgenden gerechnet wird. Die angefragten \aclp{HSA} müssen auf 12-Bit erweitert werden, denn hier ist eine \acl{CL} 12-Bit groß, wie in \autoref{fig:5_Bit_Tag} zu sehen ist.
+
+\begin{figure}[!h]
+	\centering
+	\hspace*{-2cm}
+	\includegraphics[width=\textwidth+4cm]{./Bilder/Adressrechnen.png}
+	\caption{2-Wege-\acs{AC} - Beispiel für Adressrechnen}
+	\label{fig:adressrechnen}
+\end{figure}
+
+\columnratio{0.5}
+\begin{paracol}{2}
+	\textbf{angefragte \acs{HSA}}: $42_{10}=101010_2$
+	\begin{center}
+		$\underbrace{0~0~0~0~0}_\text{Tag}\underbrace{~0~~~1~~~0~}_{\text{\acs{CL}-Nr (2)}}\underbrace{~1~~~~0~~~~1~~~~0~}_{\text{Pos. in \acs{CL} (10)}}$
+	\end{center}
+	
+	Cache A \acs{CL}-Nr. 2 ist nicht valide
+	
+	Cache B \acs{CL}-Nr. 2 ist nicht valide
+	
+	$\Rightarrow$ ein Miss
+	
+	$\Rightarrow$ Einlagern der \acs{HSS} (von \acs{HSA} 32 bis 47) \newline
+	\phantom{$\Rightarrow$} in \acs{CL}-Nr. 2
+	
+	\switchcolumn
+	\textbf{angefragte \acs{HSA}}: $0815_{10}=1100101111_2$
+	\begin{center}
+		$\underbrace{0~0~1~1~0}_\text{Tag}\underbrace{~0~~1~~0~}_\text{\acs{CL}-Nr. (2)}\underbrace{~1~~~1~~~1~~~1~}_\text{Pos. in \acs{CL} (15)}$
+	\end{center}
+	
+	Cache-A \acs{CL}-Nr. 2 ist valide, aber falscher Tag.
+	
+	Cache-B \acs{CL}-Nr. 2 ist nicht valide.
+	
+	$\Rightarrow$ insgesamt ein Miss
+	
+	$\Rightarrow$ Einlagern der \acs{HSS} (von \acs{HSA} 800 bis 815) \newline
+	\phantom{$\Rightarrow$} in \acs{CL}-Nr. 2 in Cache B \newline
+	\phantom{$\Rightarrow$} (Cache A nicht möglich)
+\end{paracol}
+\bigskip
+
+\columnratio{0.5}
+\begin{paracol}{2}
+	\textbf{angefragte \acs{HSA}}: $0271_{10}$
+	
+	\begin{center}
+		$\underbrace{~0~0~0~1~0~}_\text{Tag}\underbrace{~0~~~0~~~0~}_\text{\acs{CL}-Nr. 0}\underbrace{~1~1~1~1~}_\text{Pos. in \acs{CL} (15)}$
+	\end{center}
+
+	Cache A \acs{CL}-Nr. 0 ist nicht valide
+	
+	Cache B \acs{CL}-Nr. 0 ist nicht valide
+	
+	$\Rightarrow$ Miss
+	
+	$\Rightarrow$ Einlagen der \acs{HSS} von (\acs{HSA} 256 bis 271) \newline
+	\phantom{$\Rightarrow$} in \acs{CL}-Nr. 0
+	\switchcolumn
+	\textbf{angefragte \acs{HSA}}: $37_{10}$
+	
+	\begin{center}
+		$\underbrace{~0~0~0~0~0~}_\text{Tag}\underbrace{~0~~~1~~~0~}_\text{\acs{CL}-Nr. 2}\underbrace{~0~1~0~1~}_\text{Pos. in \acs{CL} (5)}$
+	\end{center}
+
+	\acs{CL}-Nr. 2 in Cache A ist valide, der Tag stimmt überein, also
+	
+	$\Rightarrow$ Hit in Cache A \acs{CL}-Nr. 2
+\end{paracol}
+
+\columnratio{0.5}
+\begin{paracol}{2}
+	\textbf{angefragte \acs{HSA}}: $0675_{10}$	
+	\begin{center}
+		$\underbrace{~0~0~1~0~1~}_\text{Tag}\underbrace{~0~~~1~~~0~}_\text{\acs{CL}-Nr. 2}\underbrace{~0~0~1~1~}_\text{Pos. in \acs{CL} (3)}$
+	\end{center}
+	Tag in \acs{CL}-Nr. 2 von Cache A und Cache B sind verschieden vom angefragten Tag.
+	
+	$\Rightarrow$ Miss $\Rightarrow$ sogar Kollision
+	
+	$\Rightarrow$ Verdrängung notwendig
+	\switchcolumn
+\end{paracol}
+
+
+\subsection{Verdrängungsstrategie} \label{sec:verdraengungsstrategie} \index{Cache!Verdrängungsstrategie}
+
+\subsubsection{Random}
+Die zu verdrängende Seite wird zufällig aus den möglichen \acs{HSS} ausgewählt.
+
+\textit{Bewertung}:\newline
+Erwartete Hit-Rate $=\frac{\text{Größe (Cache)}}{\text{Größe (\acs{HS})}}$ (bei zufällig verteilten Zugriffen, also ziemlich schlecht)
+
+$\Rightarrow$ nur für Benchmark-Zwecke
+
+notwendiger Aufwand: Zufallszahlengenerator
+\begin{itemize}[noitemsep]
+	\item[$\Rightarrow$] echter Zufall ist sehr teuer \& aufwändig.
+	\item[$\Rightarrow$] für Benchmarks reichen (meist) Pseudozufallszahlen aus
+\end{itemize}
+
+\subsubsection{Optimale Strategie}
+Es wird die \acs{HSS} verdrängt, welche in der Zukunft gar nicht mehr oder am längsten nicht mehr gebraucht wird.
+
+\textit{Bewertung}: \newline
+Erwartete Hit-Rate = \enquote{systembedingtes Maximum}
+
+\textit{Aufwand}: \newline
+\enquote{Blick in die Zukunft} bzw. \enquote{Kristallkugel} $\Rightarrow$  nicht möglich!
+
+\textit{Realisierung für Benchmarking}: \newline
+Zweimaliger Durchlauf für genau dieselben Parameter. Der erste Durchlauf für Logfile und zweiter Durchlauf mit optimaler Strategie anhand des Logfiles.
+
+\subsubsection{First-In-First-Out (FIFO)}
+Bei der \acf{FIFO}-Strategie wird die \acs{HSS}, welche sich am längsten im Cache befindet, verdrängt (klassische Warteschlangenbedienstrategie).
+
+\textit{Aufwand}:\newline
+Timestamp in jeder \acl{CL}. Bei Verdrängung: Suche nach dem Minimum der Timestamps (sehr aufwändig!).
+
+\textit{Besser}:\newline
+Verwaltung der \acsp{CL} als einfach verwaltete List, \dash Zeiger auf den Nachfolger in jeder \acs{CL}. Globalen Zeiger auf den ersten und letzten Eintrag für Verdrängung und Einlagerung.
+
+\textit{Schlecht unterstützte, aber häufige Zugriffsmuster}: \newline
+Ständig genutzte Datenstücke werden genauso schnell verdrängt wie Daten, die nur ein einziges Mal gebraucht werden. Anders gesagt: Daten, die lange nicht benötigt wurden, werden auch nicht schneller verdrängt, als Daten, die genauso lange im Cache sind, aber erst kürzlich gebraucht wurden.
+
+\subsubsection{Least-Recently-Used (LRU)}
+Bei der \acf{LRU}-Strategie wird die \acs{HSS}, auf welche am längsten nicht zugegriffen wurde, verdrängt.
+
+\textit{Aufwand}: \newline
+Timestamp mit Update bei jedem Zugriff $\Rightarrow$ Die Suche bei Verdrängung ist zu aufwändig
+
+\textit{Besser}:\newline
+Verwaltung als \textit{doppelt} verkettete Liste, \dash Zeiger auf Vorgänger \textit{und} Nachfolger in jeder \acs{CL}. Globalen Zeiger auf ersten und letzten Eintrag.
+
+\textit{Schlecht unterstützte Zugriffsmuster}: \newline
+Häufigkeit der Zugriffe wird nicht berücksichtigt, \dash vielfach genutzte \acl{HSS} werden genauso verdrängt wie \acs{HSS} mit nur einem Zugriff)

Rechnerarchitektur_Roethig_Skript_AM.tex

@@ -41,16 +41,19 @@
 	
 	\chapter{Abkürzungsverzeichnis}
 	\begin{acronym}[xxxxxxxx]
+		\acro{AC}{Assoziativ-Cache}
 		\acro{BLW}{Bandlaufwerk}
 		\acro{CISC}{Complex Instruction Set Computer}
 		\acro{CL}{Cache Line}
 		\acro{CLA-PA}{Carry-Look-Ahead-Paralleladdierer}
 		\acro{CPU}{Central Processing Unit}
 		\acro{D-FF}{D-Flip-Flop}
+		\acro{DMC}{Direct-Mapped-Cache}
 		\acro{DMF}{Disjunktive Minimalform}
 		\acro{DNF}{Disjunktive Normalform}
 		\acro{ENIAC}{Electronic Numerical Integrator and Computer}
 		\acro{IC}{Integrated Circuit}
+		\acro{FIFO}{First-In-First-Out}
 		\acro{GLZ}{Gatterlaufzeit}
 		\acrodefplural{GLZ}[GLZs]{Gatterlaufzeiten}
 		\acro{HA}{Halbaddierer}
@@ -59,6 +62,7 @@
 		\acrodefplural{HSA}[HSA]{Hauptspeicheradressen}
 		\acro{HSS}{Hauptspeicherseite}
 		\acro{HW}{Hardware}
+		\acro{LRU}{Least-Recently-Used}
 		\acro{LW}{Laufwerk}
 		\acro{PC}{Personal Computer}
 		\acro{PA}{Paralleladdierer}
@@ -70,6 +74,8 @@
 		\acro{SR}{Schieberegister}
 		\acro{UNIVAC}{Universal Automatic Computer}
 		\acro{VA}{Volladdierer}
+		\acro{VAC}{Vollassoziativer Cache}
+		\acro{nWAC}{$n$-Wege-Assozativ-Cache}
 	\end{acronym}
 
 	\newpage