\chapter{Rechner}
\columnratio{0.55}
\begin{paracol}{2}
	\textsf{\textbf{Rechner}} \newline
	Hilfsmittel zum Durchführen von \enquote{Rechnungen}.
	\begin{itemize}[noitemsep]
		\item schneller
		\item fehlerfreier
		\item besseres Speichervermögen
	\end{itemize}

	\switchcolumn

	\textsf{\textbf{Rechenmaschine}}
	\begin{itemize}[noitemsep]
		\item Abakus (mechanisch, digital)
		\item Rechenschieber (mechanisch, analog)
	\end{itemize}
\end{paracol}

\textsf{\textbf{Arbeitsweise}}

Man unterscheidet zwischen \enquote{mechanisch vs elektrisch} und \enquote{digital vs analog}. Moderne \enquote{Rechner} (PC \& Co.) arbeiten elektrisch und digital. Dem gegenüber stehen elektrische Analogrechner, die um die 1920er genutzt wurden.

\section{Geschichte}
\subsection{Elektrischer Digitalrechner}

\begin{description}
	\item[ZUSE] Z1, Z2 (ab \circa{1940})

		Relais als zentrale Bauteile (elektromagnetischer Schalter mit Elektromagnet)

		\begin{itemize}[noitemsep]
			\item[$\oplus$] Automatismus möglich
			\item[$\ominus$] langsame Geschwindigkeit
			\item[$\ominus$] großer Platzverbrauch
			\item[$\ominus$] Geräusche beim Schalten
			\item[$\ominus$] hoher Energieverbrauch beim Schalten
			\item[$\ominus$] großer Verschleiß
		\end{itemize}

	\item[ENIAC] (\circa{1945}) \newline
		Die \acs{ENIAC} besitzt als zentrales Bauteil eine Elektronenröhre. Eine Elektronenröhre ist ein eigentlich analog arbeitender Verstärker, wird hier aber als digitaler Schalter genutzt. Die Funktionsweise wird in \autoref{fig:elektronenstrahlroehre} dargestellt, wobei die Kathode negativ und die Anode positiv geladen sind.

		\begin{itemize}[noitemsep]
			\item[$\oplus$] sehr hohe Geschwindigkeit
			\item[$\ominus$] großer Platzverbrauch
			\item[$\ominus$] ständiges Summen bei $50Hz$ oft möglich
			\item[$\ominus$] hoher, ständiger Energieverbrauch
			\item[$\ominus$] großer Verschleiß
		\end{itemize}

		\begin{figure}[ht]
			\centering
			\includegraphics[width=11cm]{Bilder/800px-Cathode_ray_tube_de.png}
			\caption{Funktionsweise Kathodenstrahlröhre [Quelle: \href{https://de.wikipedia.org/wiki/Kathodenstrahlr\%C3\%B6hre}{Wikipedia}]}
			\label{fig:elektronenstrahlroehre}
		\end{figure}

	\newpage % Für das Seitenlayout

	\item[Moderne Rechner] Moderne transistorisierte Digitalrechner (\zB \acs{UNIVAC} ab Ende der 1950er).
		\begin{itemize}[noitemsep]
			\item Transistor als zentrales Bauteil.
				Ein Transistor ist ein analog arbeitender Verstärker, wird hier aber als digital arbeitender Schalter genutzt.
			\item[$\oplus$] sehr hohe Geschwindigkeit
			\item[$\oplus$] sehr geringer Platzverbrauch
			\item[$\oplus$] keine Geräuschentwicklung (außer Lüfter)
			\item[$\oplus$] sehr niedriger Energieverbrauch
			\item[$\oplus$] geringer Verschleiß
		\end{itemize}
\end{description}

\section{Fundamentalarchitektur}
\subsection{von-Neumann-Architektur}\label{sec:von_neumann} \index{von-Neumann-Architektur}
In \autoref{fig:neumann_architektur} wird die von-Neumann-Architektur vereinfacht dargestellt. Diese besteht aus:

\begin{description}
	\item[Zentraleinheit (\acs{CPU})] Die CPU besteht aus:
		\begin{description}
			\item[Rechenwerk] Rechnen mit Zahlen und logischen Werten
			\item[Steuerwerk] Zuständig für das Steuern und Koordinieren aller anderen Komponenten $\Rightarrow$ Interpretation und Ausführung des (Maschinensprachen-)Programms
		\end{description}
	\item[Speicherwerk] (Hauptspeicher, Primärspeicher) \newline
		Speichern von Informationen (sowohl Programmcode als auch Nutzdaten gleichermaßen)
	\item[Bus] verbindet alle Komponenten und ermöglicht den Informationsaustausch/Datenfluss zwischen ihnen.
	\item[Eingabewerk] \enquote{Schnittstelle} für Eingabegeräte (\zB USB-Controller, S-ATA-Controller) nicht jedoch das Peripheriegerät selbst (also nicht die Tastatur)
	\item[Ausgabewerk] \enquote{Schnittstelle} für Ausgabegeräte (\zB Grafikkarte)
\end{description}

\begin{figure}[ht]
	\centering
	\includegraphics[width=8cm]{Bilder/Von-Neumann_Architektur.png}
	\caption{Vereinfachte Darstellung der von-Neumann-Architektur}
	\label{fig:neumann_architektur}
\end{figure}

\subsection{Harvard-Architektur}\label{sec:harvard} \index{Harvard-Architektur}
Die Harvard-Architektur ist ähnlich der \hyperref[sec:von_neumann]{von-Neumann-Architektur}, besitzt aber anstatt eines gemeinsamen, zwei getrennte Speicherwerke für Nutzdaten und Programmcode. Zusätzlich kann noch ein optionales zweites Eingabewerk existieren, welches nur für den Programmcode vorhanden ist. Das Speicher- und Eingabewerk für den Programmcode wird über einen zweiten Bus angebunden. \newline
Dadurch ist eine klare physikalische Trennung von Programmcode und Nutzdaten möglich. \autoref{fig:harvard_architektur} auf der nächsten Seite zeigt die Harvard-Architektur und wie sich diese von der  \hyperref[sec:von_neumann]{von-Neumann-Architektur} unterscheidet.

\begin{figure}[ht]
	\centering
	\begin{tikzpicture}
	% 2. Bus-System
	\draw[red] (-1, 2) rectangle ++(3.5, 1);
	\node[red] at (0.75, 2.5) {2. Bus System};
	\draw[red] (0.5, 2) -- ++(0, -0.5);

	\draw[red] (-1, 3.5) rectangle ++(3.5, 1.25);
	\node[red, text width=3.2cm] at (0.75, 4.1) {2. Speicherwerk für Programmcode};
	\draw[red] (0.5, 3.5) -- ++(0, -0.5);

	\draw[red, dashed] (-4, 3.5) rectangle ++(2.5, 1.25);
	\node[red, text width=2.5cm] at (-2.5, 4.1) {2. Eingabe- werk};
	\draw[red, dashed] (-2.75, 3.5) |- ++(1.75, -1);
	\node[red] at (-2.2, 2.2) {optional};

	% CPU
	\draw (-2, -1.5) rectangle ++(4,3);
	\node at (0, 1) {Zentraleinheit (CPU)};
	\draw (-1.75, -1.25) rectangle ++(1.5,1.5);
	\node [text width=1.25cm] at (-1.05, -0.45) (RW)  {Rechen- werk};
	\draw (0.25, -1.25) rectangle ++(1.5,1.5);
	\node[text width=1.25cm] at ([xshift=2.1cm]RW) (SW) {Steuer- werk};

	% Bus-System
	\draw (0, -1.5) -- (0, -2.5);
	\draw (-2, -2.5) rectangle ++(4, -1);
	\node at (0, -3) {Bus-System};

	% Ein-/Ausgabe
	\draw (-2.5, -4.5) rectangle ++(2,-2);
	\draw (0.5, -4.5) rectangle ++(2,-2);
	\node[text width=1.8cm] at (-1.4, -5.4) {Ein-/ Ausgabe- werk};
	\node[text width=1.8cm] at (1.6, -5.4) {Speicher-werk \textcolor{red}{ für Daten}};
	\draw (-1.5, -4.5) -- ++(0,1);
	\draw (1.5, -4.5) -- ++(0,1);

	% Info Box
	\draw[fill=black] (3, -5) rectangle ++(0.4,0.4);
	\draw[fill=red] (3, -6) rectangle ++(0.4,0.4);
	\node at (5.8,-4.8) {von-Neumann-Architektur};
	\node at (5.3,-5.8) {Harvard-Architektur};
	\end{tikzpicture}
	\caption{Vereinfachte Darstellung der Harvard-Architektur}
	\label{fig:harvard_architektur}
\end{figure}


\subsection{Vergleich}
\autoref{tbl:vergleich_vn_hv} auf \autopageref{tbl:vergleich_vn_hv} vergleicht die von-Neumann-Architektur mit der Harvard-Architektur.

\begin{table}[h]
	\hspace*{-5mm}
	\begin{tabular}{cp{7.5cm}|cp{7.5cm}}
		& \textbf{von-Neumann-Architektur} & & \textbf{Harvard-Architektur} \\
		\midrule

		  $\ominus$ & Virenanfälligkeit: Nutzdaten können als Programm ausgeführt werden
		& $\oplus$  & nahezu immun gegen unabsichtlichen Virenbefall
		\\

		  $\oplus$ & universelle Programmierbarkeit \newline (\zB Compiler-Ausgabe wird als Programme ausgeführt)
		& $\oplus$ & keine (unbeabsichtigten oder ungewollten) Änderungen an der Betriebssoftware möglich
		\\

		  $\oplus$  & flexible Speicheraufteilung zwischen Programmcode und Daten
		& $\ominus$ & komplexer und teurer (durch 2 Bus und ggf. 2 Eingabewerke)
		\\

		  $\ominus$ & möglicher Flaschenhals Bus \& Speicherwerk
		& $\ominus$ & schwer update-fähig
		\\

		  $\oplus$ & kostengünstig
		& $\oplus$ & bessere Performance möglich durch gleichzeitigen Zugriff auf beide Speicherwerke
		\\

		&
		& $\ominus$ & ohne zweites Eingabewerk keine Möglichkeit anderen Programmcode auszuführen.
		\\

		&
		& $\ominus$ & unflexible Aufteilung des Speichers, wenn das eine Speicherwerk voll ist, kann das andere Speicherwerk nicht genutzt werden.
		\\

	\end{tabular}
	\hspace*{-7mm}
	\begin{tabular}{cp{7.6cm}|cp{7.6cm}}
		\multicolumn{4}{c}{\textbf{Einsatz}} \\
		\midrule

		  \textbullet & übliche PC-Architektur -- \enquote{Universal-PC}
		& \textbullet & \enquote{embedded systems} (\zB in Waschmaschinen, KFZ-Elektronik, etc.)
		\\

		&
		& \textbullet & Smartphones \& Co.
		\\

		&
		& \textbullet & Bestandteile von \acsp{PC}: BIOS, \acs{CPU}-Cache in modernen \acsp{CPU} (Trennung in Cache für Programmcode und Nutzdaten), NX-Flag (Non-Executable) im Hauptspeicher
	\end{tabular}
	\caption{Vergleich der von-Neumann- und Harvard-Architektur}
	\label{tbl:vergleich_vn_hv}
\end{table}



\chapter{Rechenwerk / Rechnen in Hardware}

\textsf{\textbf{Grundlagen: Addition}} \index{Addition}

\columnratio{0.25}
\begin{paracol}{2}
	\begin{tabular}{l|c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}}
			&   & 4 & 7 & 1 & 1 \\
			& + & 0 & 8 & 1 & 5 \\
		Übertrag         & 0 & 1 & 0 & 0 &  \\
		\hline
		&   & 5 & 5 & 2 & 6
	\end{tabular}

	\switchcolumn
	Die Addition von mehrstelligen Zahlen wird reduziert auf die Addition von zwei (oder drei) einstelligen Zahlen (bzw. Ziffern) zu einer einstelligen Zahl sowie einem einstelligen Übertrag, also einer zweistelligen Zahl als Ergebnis $\Rightarrow$ genauso funktioniert dies im Binärsystem.
\end{paracol}

\begin{Hinweis}
	Herr Röthig meint mit \enquote{einstellig} und \enquote{mehrstellig} die Anzahl der Zahlen und nicht die Stellenanzahl einer einzelnen Zahl. Im Beispiel oben werden zwei Zahlen addiert und daraus ergeben sich zwei weitere Zahlen als Ergebnis.
\end{Hinweis}

\section{Schaltnetzsysnthese -- Wiederholung / Grundlegendes}

\begin{description}
	\item[Schaltnetz] \index{Schaltnetz} Kann nur die derzeitigen Eingangsdaten verarbeiten, da keine Rückkopplung vorliegt
\item[Schaltwerk] \index{Schaltwerk} \enquote{Hat ein Gedächtnis}, da eine Rückkopplung vorliegt
\item[Vollkonjunktion/Minterm] \texttt{UND}-Verknüpfung aller vorkommenden Variablen entweder in negierter oder nicht-negierter Form
\item[\acf{DNF}] \index{DNF} Eine Disjunktion (\texttt{ODER}-Verknüpfung) von Konjunktionstermen (\texttt{UND}-Verknüpfungen).
\item[\acf{DMF}] \index{DMF} Ist die minimale Darstellung einer Ausgabefunktion und damit eine Vereinfachung einer \acs{DNF}
\end{description}

\subsection{Schaltungsanalyse} \index{Schaltungsanalyse}
Eine Schaltungsanalyse ist die Bestimmung des \enquote{Aufwands}. Dabei kann der Aufwand sein:
\begin{itemize}[noitemsep]
	\item \enquote{Hardware-Aufwand} (in Anzahl an Transistoren)
	\item Zeitaufwand (in \acl{GLZ})
\end{itemize}

\subsection{Warum soll der Zeitaufwand analysiert werden?} \index{Zeitaufwand}
Es wird der Zeitaufwand betrachtet, da Gatter Schaltzeiten haben, welche typischerweise \circa{10 Pikosekunden} betragen. Insgesamt werden bei einem Signaldurchgang auf dem \acs{IC} sehr viele Gatter durchlaufen. Damit sind die Schaltzeiten um Größenordnungen größer als die reine Laufzeit der Signale auf dem Leiter angegeben (letztere wird vernachlässigt, Zeitverzögerung wird in \enquote{Anzahl \acfp{GLZ}} angegeben).

\section{Halbaddierer} \index{Halbaddierer}
Vollzieht die Addition von zwei einstelligen Binärzahlen $a$ und $b$ zu einer zweistelligen Binärzahl $c_{out}s$ (Übertrag und Summe). Schaltsymbol und Schaltnetz des Halbaddierers werden in \autoref{fig:halbaddierer} dargestellt.

Die folgende Tabelle zeigt den Gedankenweg, wie ein Halbaddierer funktioniert.
\begin{center}
	\begin{tabular}{c|cc|ccc|c}
		Nr. & $b$ & $a$ & $c_{out}$ & $s$ &     Minterm     & \acs{DNF}                                         \\ \midrule
		 0  &  0  &  0  &     0     &  0  &                 &                                                   \\
		 1  &  0  &  1  &     0     &  1  & $\overline{b}a$ & $c_{out} = ba$                                    \\
		 2  &  1  &  0  &     0     &  1  & $b\overline{a}$ & $s=\overline{b}a \vee b\overline{a}$              \\
		 3  &  1  &  1  &     1     &  0  &      $ba$       & $\Rightarrow$  beides gleichzeitig auch \acs{DMF}
	\end{tabular}
\end{center}

\begin{figure}[ht]
	\centering
	\begin{tikzpicture}[font=\sffamily, circuit logic IEC, large circuit symbols,
		knoten/.style={circle,fill,draw,inner sep=0pt,minimum size=1.5mm}]
		\node at (3,5.9) {Schaltnetz};

		\node at (1,5.5)    (B) {b};
		\node at (1.5,5.5)  (A) {a};

		\node[and gate, inputs={nn}] at (3,4.5) (PORT1) {};
		\node[and gate, inputs={in}] at (3,3) (PORT2) {};
		\node[and gate, inputs={ni}] at (3,1.5) (PORT3) {};
		\node[or gate,  inputs={nn}] at (5,1.675) (PORT5) {};

		% -| nutzt nur eine Koordinate
		\draw (A) |- (PORT1.input 1); \node[knoten] at (PORT1.input 1 -| A) {};
		\draw (A) |- (PORT2.input 1); \node[knoten] at (PORT2.input 1 -| A) {};
		\draw (A) |- (PORT3.input 1);

		\draw (B) |- (PORT1.input 2); \node[knoten] at (PORT1.input 2 -| B) {};
		\draw (B) |- (PORT2.input 2); \node[knoten] at (PORT2.input 2 -| B) {};
		\draw (B) |- (PORT3.input 2);

		\draw (PORT2.output) -- ([xshift=5mm]PORT2.output) |- (PORT5.input 1);
		\draw (PORT3.output) -- ([xshift=5mm]PORT3.output) |- (PORT5.input 2);

		\draw (PORT5.output) -- ([xshift=8mm]PORT5.output);
		\node[right=of PORT5.output] {$s$};
		\node[font=\tiny] at ($(PORT5.output) + (0.5,0.25)$) {\textcolor{blue}{2 GLZ}};

		\draw (PORT1.output) -- (PORT1.output) |- ++(1,0);
		\node[right=of PORT1.output] {$c_{out}$};
		\node[font=\tiny] at ($(PORT1.output) + (0.5,0.25)$) {\textcolor{blue}{1 GLZ}};
	\end{tikzpicture}
	\begin{tikzpicture}[font=\sffamily, circuit logic IEC, large circuit symbols,
		knoten/.style={circle,fill,draw,inner sep=0pt,minimum size=1.5mm}]
		\node at (2.5,6.8) {Schaltnetz vereinfacht};

		\node at (1,5.5)    (B) {b};
		\node at (1.5,5.5)  (A) {a};

		\node[and gate, inputs={nn}] at (3,4.5) (PORT1) {};
		\node[xor gate, inputs={nn}] at (3,3) (PORT2) {};

		% -| nutzt nur eine Koordinate
		\draw (A) |- (PORT1.input 1); \node[knoten] at (PORT1.input 1 -| A) {};
		\draw (A) |- (PORT2.input 1); \node[knoten] at (PORT2.input 1 -| A) {};

		\draw (B) |- (PORT1.input 2); \node[knoten] at (PORT1.input 2 -| B) {};
		\draw (B) |- (PORT2.input 2); \node[knoten] at (PORT2.input 2 -| B) {};

		\draw (PORT2.output) -- ([xshift=8mm]PORT2.output);
		\node[right=of PORT2.output] {$s$};

		\draw (PORT1.output) -- (PORT1.output) |- ++(1,0);
		\node[right=of PORT1.output] {$c_{out}$};

		\node at (0,2) {}; % Nur fürs positionieren
	\end{tikzpicture}
	\begin{tikzpicture}[font=\sffamily]
		\node at (-0.25,2.5) {Schaltsymbol};

		\draw (-1, -1) rectangle ++(1.5,1.5);
		\node[] at (-0.25,-0.25) (HA) {HA};
		\node[] at ($(HA)+(1.6,0.5)$) (cout) {$c_{out}$};
		\node[] at ($(HA)+(1.4,-0.5)$) (s) {$s$};
		\node[] at ($(HA)+(-1.4,0.5)$) (b) {$b$};
		\node[] at ($(HA)+(-1.4,-0.5)$) (a) {$a$};

		\draw (-1, 0.25) -- ++(-0.4,0);
		\draw (-1, -0.75) -- ++(-0.4,0);

		\draw (0.5, 0.25) -- ++(0.4,0);
		\draw (0.5, -0.75) -- ++(0.4,0);

		\node at (0,-2.3) {}; % Nur fürs positionieren
	\end{tikzpicture}
	\caption{Halbaddierer -- Schaltnetz und Schaltsymbol}
	\label{fig:halbaddierer}
\end{figure}

\section{Volladdierer}\index{Volladdierer}
Vollzieht die Addition von drei einstelligen Binärzahlen $a$, $b$ und $c_{in}$ zu einer zweistelligen Binärzahl $c_{out}s$ (Übertrag und Summe). Schaltsymbol und Schaltnetz des Volladdierer werden in \autoref{fig:volladdierer} dargestellt.

\begin{figure}[h!]
	\centering

	\begin{tikzpicture}[font=\sffamily]
		\node at (4,1.5) {Schaltnetz};

		\node[] at (0,0.75) (a) {$a$};
		\node[] at (0,0) (b) {$b$};
		\node[] at (0,-0.75) (c) {$c_{in}$};

		% HA 1
		\draw (1, -0.3) rectangle ++(1.5,1.5);
		\node[] at (1.75,0.45) (HA1) {HA};
		\draw (a) -- ($(a)+(1, 0)$);
		\draw ($(a)+(2.5,0)$) -- ++(3.5,0);
		\draw (b) -- ($(b)+(1, 0)$);
		\node at ($(a)+(3,0.15)$) {$c_{out_1}$};
		\node at ($(b)+(2.8,-0.24)$) {$s_1$};

		% HA 2
		\draw (3.5, -1.2) rectangle ++(1.5,1.5);
		\node[] at (4.25,-0.45) (HA2) {HA};
		\draw ($(b)+(2.5,0)$) -- ++(1,0);
		\draw (c) -- ++(3.5,0);
		\node at ($(b)+(5.5,-0.24)$) {$c_{out_2}$};
		\node at ($(c)+(5.3,-0.24)$) {$s_2$};

		% HA 3
		\draw (6, -0.3) rectangle ++(1.5,1.5);
		\node[font=\large] at (6.75,0.4) (HA2) {$\geq1$};
		\draw ($(b)+(5,0)$) -- ++(1,0);
		\draw ($(c)+(5,0)$) -- ++(3,0);
		\node at ($(c)+(8.5,0)$) {$s$};
		\draw ($(b)+(7.5,0)$) -- ++(0.5,0);
		\node at ($(b)+(8.5,0)$) {$c_{out}$};
	\end{tikzpicture}
	\begin{tikzpicture}[font=\sffamily]
		\node at (-0.25,1.1) {Schaltsymbol};

		\draw (-1, -1) rectangle ++(1.5,1.5);
		\node[] at (-0.25,-0.25) (VA) {VA};
		\node[] at ($(VA)+(1.6,0.5)$) (cout) {$c_{out}$};
		\node[] at ($(VA)+(1.4,-0.5)$) (s) {$s$};

		\node[] at ($(VA)+(-1.4,0.5)$) (c) {$c_{in}$};
		\node[] at ($(VA)+(-1.4,0)$) (b) {$b$};
		\node[] at ($(VA)+(-1.4,-0.5)$) (a) {$a$};

		\draw (0.5, 0.25) -- ++(0.4,0);
		\draw (0.5, -0.75) -- ++(0.4,0);

		\draw (-1, 0.25) -- ++(-0.4,0);
		\draw (-1, -0.25) -- ++(-0.4,0);
		\draw (-1, -0.75) -- ++(-0.4,0);

		\node at (0,-1.5) {}; % Nur fürs positionieren
	\end{tikzpicture}
	\caption{Volladdierer -- Schaltnetz und Schaltsymbol}
	\label{fig:volladdierer}
\end{figure}

\textit{Hinweis:} Für die Verknüpfung von $c_{out_1}$ und $c_{out_2}$ zu $c_{out}$ wäre eigentlich ein \texttt{XOR} notwendig. Da aber der Fall $c_{out_1} = c_{out_2} = 1$ (also beide Eingänge des \texttt{XOR} \enquote{1}) nie auftritt, reicht ein \texttt{OR}.

\section{Paralleladdierer (4-Bit-Ripple-Carry-Paralleladdierer RC-PA)} \index{Paralleladdierer!RC-PA}
Der \acs{RC-PA} ist ein mehrstelliger Addierer für Binärzahlen. In den folgenden Beispielen ist er ein Addierer vierstelliger Binärzahlen $a_3a_2a_1a_0$ und $b_3b_2b_1b_0$. Das Ergebnis ist $s_4s_3s_2s_1s_0$ und somit eine 5-stellige Zahl. $s_4$ ist der Überlauf.

\autoref{fig:paralleladdierer_rc} zeigt das Schaltnetz und Schaltsymbol eines Paralleladdierers.
\newline

\begin{figure}[ht]
	\centering
	\begin{tikzpicture}[font=\sffamily]
		\foreach \a in {0,...,3} {
			% Calculate the index
			\def\b{{\pgfmathparse{3-\a}  % Evaluate the expression
				\pgfmathprintnumber[     % Print the result
				fixed,
				fixed zerofill,
				precision=0
			]{\pgfmathresult}}}

			\node at (\a*3 - 0.75,2) {$a_{\b}$};
			\draw (\a*3 - 0.75,1.7) -- (\a*3 - 0.75,1);
			\node at (\a*3,2) {$b_\b$};
			\draw (\a*3,1.7) -- (\a*3,1);

			\draw[black, thick] (-1 + \a*3,-1) rectangle (\a*3 + 1,1);

			\ifnum\a<3
				\node at (\a*3 + 1,2) {$c_{in_\b}$};
				\draw (\a*3 + 0.75,1.7) -- (\a*3 + 0.75,1);
				\draw (\a*3 + 0.75,1.7) -- (\a*3 + 1.25,1.7) -- (\a*3 + 1.5,-1.5)
					 -- (\a*3 + 2.5,-1.5) -- (\a*3 + 2.5,-1);
				\node[font=\huge\sffamily] at (\a*3, 0) {VA};
			\fi
			\ifnum\a>2
				\node[font=\huge\sffamily] at (\a*3, 0) {HA};
			\fi

			\node at (\a*3 + 0.25,-2) {$s_\b$};
			\draw (\a*3 + 0.25,-1.7) -- (\a*3 + 0.25,-1);
		}
		\node at (-0.5,-2) {$s_4$};
		\node[font=\small\sffamily] at (-1,-2.5) {\enquote{Überlauf}};
		\draw (-0.5,-1.7) -- (-0.5,-1);
	\end{tikzpicture}
	\vspace{1cm}
	\begin{tikzpicture}[font=\sffamily]
		\draw[black, thick] (0,0) rectangle (10,2);

		\foreach \a in {0,...,3} {
			\node at (\a + 1,3) {$a_\a$};
			\draw (\a + 1,2.7) -- (\a + 1,2);
			\node at (\a + 6,3) {$b_\a$};
			\draw (\a + 6,2.7) -- (\a + 6,2);
		}
		\foreach \a in {0,...,4} {
			\node at (\a*2 + 1,-1) {$s_\a$};
			\draw (\a*2 + 1,-0.7) -- (\a*2 + 1,0);
		}
		\node[font=\huge\sffamily] at (5, 1) {4-Bit-RC-PA};
	\end{tikzpicture}

	\caption{RC-Paralleladdierer -- Schaltnetz und Schaltsymbol}
	\label{fig:paralleladdierer_rc}
\end{figure}

\begin{Hinweis}
	Ein $n$-Bit \acs{RC-PA} ist ein Schaltnetz, kein Schaltwerk! Eine zeichnerische Anordnung mit Verbindungen nur nach unten ist nämlich möglich.
\end{Hinweis}

\subsection{Hardwareaufwand des 4~Bit RC-PA}

\noindent\begin{tabular}{@{}l@{}ll}
	für \acs{HA}: & 2 Transistoren für $c_{out}$ und 6 Transistoren für $s$ & $\Rightarrow$  8 Transistoren              \\
	für \acs{VA}: & 2 \acs{HA} und 2 Transistoren für $c_{out}$                   & $\Rightarrow$  $2\cdot8+2=18$ Transistoren
\end{tabular}

\textit{Für den 4~Bit \acs{RC-PA} werden benötigt:}

\begin{tabular}{@{}lcl}
	1 \acs{HA} + $(n-1)$ \acs{VA} & $\Rightarrow$ & 8 Transistoren + $(n-1) \cdot 18~\text{Transistoren}$      \\
	                              & $\Rightarrow$ & $8 + (18n - 18) $~Transistoren  $ = 18n - 10$~Transistoren \\
	                              &     $ = $     & $O(n)$
\end{tabular}

Dies heißt, dass der \acs{HW}-Aufwand linear mit der Breite der Summanden steigt. Dies ist gut, denn besseres (also weniger Aufwand) ist kaum zu erwarten.

\subsection{Zeitaufwand des 4~Bit RC-PA}

für \acs{HA}: max. 2 \acfp{GLZ} (\enquote{Tiefe 2}, siehe \autoref{fig:halbaddierer} auf \autopageref{fig:halbaddierer}) \newline
für \acs{VA}: max. 4 \acfp{GLZ}

Beim \acs{RC-PA} liegen die einzelnen $s_i$ nach unterschiedlicher Zeit an. $s_i$ wird nach $(i+1)\cdot 2$ \acs{GLZ} erreicht.
Das längste $s_i$ ist bei $n$-Bit-\acs{RC-PA} $i=n-1$ und damit ergibt sich ein Zeitaufwand bei $n$-Bit-\acs{RC-PA} von $2n$~\acs{GLZ}!

Dies ist ein schlechter Zeitaufwand bei einem Paralleladdierer, denn zu erwarten wäre $O(1)$! \newline
\textit{Auswirkung}: Beim Wechsel von 32- auf 64-Bit-\acs{CPU} hätte sich die Taktfrequenz halbiert. Daraus lässt sich folgern, dass kein 64-Bit-\acs{RC-PA} in der \acs{CPU} verbaut ist.

\begin{Hinweis}
	Anmerkung zum \acs{RC-PA}: Die $2n$ \acs{GLZ} Zeitaufwand werden nur im \enquote{schlimmsten Fall} bei einer ununterbrochene Kette von $c_{out}$-Ausgängen, welche sich \textbf{alle} im Laufe  der Berechnung von \texttt{0} auf \texttt{1} ändern, erreicht.

	Diese Zeit muss aber trotzdem abgewartet werden.
\end{Hinweis}

\section{Paralleladdierer (4-Bit-Carry-Look-Ahead-Paralleladdierer CLA-PA)} \index{Paralleladdierer!CLA-PA}
\textit{Idee}: Der $c_{in}$-Eingang wird nicht von vorausgehenden \acs{VA} (oder \acs{HA}) übernommen, sondern durch ein \enquote{magisches CLA-Schaltnetz} nachberechnet. \textit{Genauer}: Für die Berechnung von $c_{in_i}$ müssen alle vorherigen Eingänge $a_j, b_j, j < i$ berücksichtigt werden. \autoref{fig:paralleladdierer_cla} zeigt dieses \enquote{magische CLA-Schaltnetz}.

\begin{figure}[ht]
	\centering
	\begin{tikzpicture}[font=\sffamily]
	\foreach \a in {0,...,3} {
		% Calculate the index
		\def\b{{\pgfmathparse{3-\a}  % Evaluate the expression
				\pgfmathprintnumber[     % Print the result
				fixed,
				fixed zerofill,
				precision=0
				]{\pgfmathresult}}}

		\node at (\a*3 - 0.75,2) {$a_{\b}$};
		\draw (\a*3 - 0.75,1.7) -- (\a*3 - 0.75,1);
		\node at (\a*3,2) {$b_\b$};
		\draw (\a*3,1.7) -- (\a*3,1);

		\draw[black, thick] (-1 + \a*3,-1) rectangle (\a*3 + 1,1);

		\ifnum\a<3
		\draw (\a*3 + 0.55,2.2) rectangle (\a*3 + 0.95,1.7);
		\node at (\a*3 + 0.75,1.9) {?};
		\node at (\a*3 + 1.2,1.4) {$c_{in_\b}$};
		\draw (\a*3 + 0.75,1.7) -- (\a*3 + 0.75,1);
		\node[font=\huge\sffamily] at (\a*3, 0) {VA};
		\fi
		\ifnum\a>2
		\node[font=\huge\sffamily] at (\a*3, 0) {HA};
		\fi

		\node at (\a*3 + 0.25,-2) {$s_\b$};
		\draw (\a*3 + 0.25,-1.7) -- (\a*3 + 0.25,-1);
	}
	\node at (-0.5,-2) {$s_4$};
	\node[font=\small\sffamily] at (-1,-2.5) {\enquote{Überlauf}};
	\draw (-0.5,-1.7) -- (-0.5,-1);
	\end{tikzpicture}
	\caption{Carry-Look-Ahead-Paralleladdierer -- Schaltnetz}
	\label{fig:paralleladdierer_cla}
\end{figure}

Aber wie sieht das Schaltnetz (und die boolesche Formel) für die Berechnung von $c_{in_i}$ aus?
\begin{align*}
	\text{\acs{HA}}:~ c_{out} & = a\wedge b                                                                                                  &                          \\
	s_{out}                   & = a\overline{b}\vee\overline{a}b                                                                             &                          \\
	\text{\acs{VA}}:~ c_{out} & = (a\wedge b)\vee(c_{in}\wedge(a\overline{b}\vee\overline{a}b))                                              &                          \\
							  &                                                                                                              &                          \\
	c_{in_1} = c_{out_0}      & = a_0\wedge b_0                                                                                              & \textit{\qquad \acs{HA}} \\
	c_{in_2} = c_{out_1}      & = (a_1\wedge b_1)\vee(\textcolor{Blue}{c_{in_1}} \wedge (a_1\overline{b}_1\vee\overline{a}_1b_1))                              & \textit{\acs{VA}}        \\
							  & =(a_0\wedge b_1)\vee(\textcolor{Blue}{a_0\wedge b_0} \wedge(a_1\overline{b}_1\vee\overline{a}_1b_1))                            & \textit{Einsetzen}       \\
	c_{in_3} = c_{out_2}      & = (a_2\wedge b_2)\vee(\textcolor{OliveGreen}{c_{in_2}} \wedge(a_2\overline{b}_2\vee\overline{a}_2b_2))                                & \textit{\acs{VA}}        \\
							  & = (a_2\wedge b_2)\vee \textcolor{OliveGreen}{((a_0\wedge b_1)\vee(a_0\wedge b_0\wedge(a_1\overline{b}_1\vee\overline{a}_1b_1))} \wedge & \textit{Einsetzen}       \\
							  & \hspace{4mm} (a_2\overline{b}_2\vee\overline{a}_2b_2))                                                                    &                          \\
	\cdots                    &                                                                                                              &
\end{align*}

\subsection{Zeitaufwand}
Für die Berechnung der $c_{in_i}$ kann jeweils eine \acs{DNF}, \acs{DMF} oder jede andere DxF (oder KxF) verwendet werden. Diese haben jeweils nur genau (bzw. maximal) 2~\acs{GLZ} Zeitaufwand.

Insgesamt hat jedes $s_i$ beim \acs{CLA-PA} genau 6~\acs{GLZ} Zeitaufwand (außer $s_0$:~2~\acs{GLZ}, $s_1$:~5~\acs{GLZ}). \newline
Somit haben wir einen konstanten Zeitaufwand von $O(1)$.

\subsection{Hardwareaufwand des 4~Bit CLA-PA}
Für den Aufwand für die $c_{in_i}$-Berechnung gilt die Annahme, das Schaltnetz wäre eine Realisierung der \acs{DNF}.

\begin{itemize}[noitemsep]
	\item[$\Rightarrow$] Für jedes $c_{in_i}$ gibt es insgesamt $2i$ Eingänge.
	\item[$\Rightarrow$] Insgesamt gibt es max. $2^{2i}$ verschiedene Vollkonjunktionen, welche in der \acs{DNF} auftreten können. \newline
		Jede dieser Vollkonjunktionen wird mit $2i$ Transistoren realisiert.
	\item[$\Rightarrow$] Falls alle Vollkonjunktionen verwendet werden müssten, wäre der Hardwareaufwand \newline
	$2^{2i}\cdot 2i$ Transistoren.\todo{Evtl. nicht korrekt. Die 15er haben da was anderes...}
\end{itemize}

In der Realität werden natürlich nicht alle Vollkonjunktionen benötigt, sondern ein (vermutlich halbwegs konstanter) Anteil $0 < k < i$. Damit ist der Aufwand für $c_{in_i} = O(i\cdot4^i)$ und somit der Aufwand für $n$-Bit-\acs{CLA-PA}: $O(n^2\cdot2^n)$

\newpage % Für das Layout
\begin{Achtung}
	Im folgenden wird fälschlicherweise von einem Aufwand $O(n^2\cdot 2^n)$ ausgegangen. Richtig wäre $O=(n^2\cdot 4^n)$. Herr Röthig hat die $O$-Notation falsch vereinfacht. Der 2015er Jahrgang hat dies \enquote{noch falscher} gemacht und zu $O(4^n)$ vereinfacht.
\end{Achtung}

Der Hardwareaufwand steigt beim $n$-Bit-\acs{CLA-PA} überexponentiell mit $n$.
Beim Wechsel von $32$-Bit auf 64-Bit-\acs{CLA-PA} wäre der 16~Trillionen-fache Aufwand an Transistoren nötig gewesen.

\begin{tabular}{@{}l@{}c@{}c@{}l}
	Bei $n=4$: \quad $4^2\cdot 2^4=$~ & $16\cdot 16$~  $=$ &       $256$       & ~Transistoren                      \\
	Bei $n=8$: \quad $8^2\cdot 2^8=$~ &   $64\cdot 256=$   & ~ \circa{$16384$} & ~Transistoren (64-fache von $n=4$) $\Rightarrow$ \textit{zu viel für die \acs{CPU}}
\end{tabular}
\todo{Vergleichen: Siehe Notizen, etc.}


\subsection{Kombination mehrerer kleinen \acsp{CLA-PA}}

Der 32-Bit Addierer wird in acht 4-Bit-\acs{CLA-PA} gesplittet (siehe \autoref{fig:casc_cla_ca}).

$\Rightarrow$ hintereinander geschaltet nach RC-Prinzip \newline
$\Rightarrow$ damit ist das $n$ der nicht-\acs{CLA-PA} noch klein $\Rightarrow$  erträglicher Hardwareaufwand \newline

\begin{figure}[ht]
	\centering
	\begin{tikzpicture}[font=\sffamily,scale=1.3]
		\foreach \a in {0,...,3} {
			% Calculate the index
			\def\b{{\pgfmathparse{3-\a}  % Evaluate the expression
					\pgfmathprintnumber[ % Print the result
					fixed,
					fixed zerofill,
					precision=0
					]{\pgfmathresult}}}
			\def\cstart{{\pgfmathparse{(3-\a)*4}
					\pgfmathprintnumber[
					fixed,
					fixed zerofill,
					precision=0
					]{\pgfmathresult}}}
			\def\cend{{\pgfmathparse{(3-\a)*4+3}
					\pgfmathprintnumber[
					fixed,
					fixed zerofill,
					precision=0
					]{\pgfmathresult}}}

			\node[font=\small] at (\a*3 - 0.9,1.5) {$a_{\cend}$};
			\draw (\a*3 - 0.9,1.2) -- (\a*3 - 0.9,0.5);
			\node[font=\small] at (\a*3 - 0.5,1.5) {$b_\cend$};
			\draw (\a*3 - 0.5,1.2) -- (\a*3 - 0.5,0.5);

			\node[font=\small] at (\a*3 + 0.8,1.5) {$b_{\cstart}$};
			\draw (\a*3 + 0.8,1.2) -- (\a*3 + 0.8,0.5);
			\node[font=\small] at (\a*3 + 0.4,1.5) {$a_\cstart$};
			\draw (\a*3 + 0.4,1.2) -- (\a*3 + 0.4,0.5);

			\node[font=\small] at (\a*3,1.5) {\ldots};
			\draw (\a*3,1.2) -- (\a*3,0.5);

			\draw[black, thick] (-1 + \a*3,-1) rectangle (\a*3 + 1,0.5);

			\ifnum\a<3
				\draw (\a*3 + 0.95,1.1) -- (\a*3 + 0.95,0.5);
				\draw (\a*3 + 0.95,1.1) -- (\a*3 + 1.25,1.1) -- (\a*3 + 1.5,-1.5)
						-- (\a*3 + 2.5,-1.5) -- (\a*3 + 2.5,-1);

				\node[font=\small\sffamily] at (\a*3, 0) {kaskadierbarer};
				\node[font=\small\sffamily] at (\a*3, -0.4) {4~Bit~CLA-PA};
			\fi
			\ifnum\a>2
				\node[font=\small\sffamily] at (\a*3, -0.2) {4~Bit~CLA-PA};
			\fi

			\node[font=\small] at (\a*3 - 0.35,-2) {$s_\cend$};
			\draw (\a*3 - 0.35,-1.7) -- (\a*3 - 0.35,-1);
			\node[font=\small] at (\a*3 + 0.8,-2) {$s_\cstart$};
			\draw (\a*3 + 0.8,-1.7) -- (\a*3 + 0.8,-1);
			\node[font=\small] at (\a*3 + 0.2,-2) {\ldots};
			\draw (\a*3 + 0.2,-1.7) -- (\a*3 + 0.2,-1);
		}
		\node[font=\small] at (-0.9,-2) {$s_{16}$};
		\node[font=\small\sffamily] at (-1.2,-2.5) {\enquote{Überlauf}};
		\draw (-0.9,-1.7) -- (-0.9,-1);
	\end{tikzpicture}
	\caption{Kaskadierbarer 4-Bit-CLA-PA}
	\label{fig:casc_cla_ca}
\end{figure}

\newpage % Für das Layout

\section{Serielladdierer} \index{Serielladdierer}
\textit{Idee}: Angelehnt an die Verfahrensweise des Menschen sollen die Stellen der beiden Summanden nacheinander (und nicht gleichzeitig) addiert werden. Dadurch wird nur \textbf{ein} \acs{VA} und mehrere \acf{SR} benötigt. Daher ist der \acf{SA} ein Schaltwerk, kein Schaltnetz! \autoref{fig:serielladdierer} zeigt das Schaltwerk eines Serielladdierer.

\begin{figure}[h!]
	\centering
	\includegraphics[width=13cm]{Bilder/Serielladdierer.png}
	\caption{Serielladdierer}
	\label{fig:serielladdierer}
\end{figure}\todo{Als Tikz übernehmen}

\subsection{Zeitaufwand ($n$-Bit-SA)}

Der Zeitaufwand für einen $n$-Bit-\acs{SA} beträgt $n$ Taktzyklen, also $O(n)$

\textit{Ist dies wie beim \acs{RC-PA}?} \newline
Jein, denn $1$ Taktzyklus dauert deutlich mehr als doppelt solang wie die Berechnung des \acs{VA} (Sicherheitsmargen!). Beispiel: 1 Taktzyklus > \circa{10}~\acs{GLZ} $\Rightarrow$ fünffache Berechnungszeit des \acs{RC-PA}

\subsection{Hardwareaufwand ($N$-Bit-SA)}

\begin{tabular}{@{}l@{}l}
	1 \acs{VA}                & $=18$ Transistoren                                                                     \\
	2 \acs{D-FF} = $2\cdot 6$ & $=12$ Transistoren. \textit{(siehe \autoref{fig:serielladdierer_2} rechts)}            \\
	3 $n$-Bit-\acs{SR}        & $=4\cdot 6n = 18n$ Transistoren \textit{(siehe \autoref{fig:serielladdierer_2} links)} \\
	Takterzeugung~~           & \textit{(im folgenden nicht näher betrachtet)}                                         \\
	gesamt                    & $18n+30$ Transistoren
\end{tabular}

Zum Vergleich: \acs{RC-PA}: $18n-10$, \dash der \acs{SA} braucht 40 Transistoren mehr (bei längerer Bearbeitungszeit)!


\begin{figure}[h!]
	\centering
	\includegraphics[width=15cm]{Bilder/Serielladdierer_2.png}
	\caption{Schieberegister und D-Flip-Flop}
	\label{fig:serielladdierer_2}
\end{figure}

\begin{Achtung}
	Die Takterzeugung muss in der Klausur für den \acl{SA} auf jeden Fall genannt werden, auch wenn sie hier nicht weiter betrachtet wird!
\end{Achtung}


\subsection{Hardwareoptimierung des Serielladdierers}

\begin{figure}[ht]
	\centering
	\includegraphics[width=12cm]{Bilder/Serielladdierer_3.png}
	\caption{Serielladdierer mit Hardwareoptimierung}
	\label{fig:serielladdierer_hw_optimierung}
\end{figure}

Wie in \autoref{fig:serielladdierer_hw_optimierung} zu sehen ist, wird ein Schieberegister weniger  benötigt $\Rightarrow 12n+36$ Transistoren

\subsubsection{Vergleich eines RC-PA mit dem verbesserten SA}
\begin{table}
	\centering
	\begin{tabular}{c|c|c}
		n & \acs{RC-PA} (18n – 10) & \acs{SA} (12n +36) \\ \midrule
		1 &           8            &         48         \\
		2 &           26           &         60         \\
		3 &           44           &         72         \\
		4 &           62           &         84
	\end{tabular}
	\caption{Vergleich von Hardwareaufwand eines \acs{RC-PA} mit dem verbesserten \acs{SA}}
	\label{tbl:vergleich_rcpa_sa}
\end{table}

Tabelle \autoref{tbl:vergleich_rcpa_sa} vergleicht einen \acs{RC-PA} mit dem verbesserten \acs{SA}.

Break-Even (\enquote{\textit{Gewinnschwelle}}): $18n -10 = 12n + 36 \Rightarrow 46 = 6n \Rightarrow n = 7\frac{2}{3} $ \newline
\hspace*{5mm} $\Rightarrow$ Ab 8-Bit lohnt sich der \acs{SA}

\textbf{Mögliche Anwendung eines \acl{SA}}:
\begin{itemize}[noitemsep]
	\item nicht im Rechenwerk der \acs{CPU} (aufgrund der Geschwindigkeit)!
	\item aber möglicherweise in \enquote{Embedded System}, falls \zB Sensordaten sowieso seriell angeliefert werden
	\item[$\Rightarrow$] eventuell sind sogar weitere Hardware-Einsparungen möglich!
\end{itemize}


\section{Subtraktion} \index{Subtraktion}
Es ist kein spezieller Hardware-Subtrahierer notwendig. Eine Subtraktion wird über die Addition des 2er-Komplements realisiert:

\begin{enumerate}[noitemsep]
	\item Bits invertieren (Inverter)
	\item $+1$ addieren (Addierer)
\end{enumerate}

\begin{figure}[ht]
	\centering
	\includegraphics[width=13cm]{Bilder/Subtrahierer.png}
	\caption{Schaltnetz Subtrahierer}
	\label{fig:subtraktion}
\end{figure}

\newpage % Nur für's Layout

\section{Multiplikation} \index{Multiplikation}

\columnratio{0.17}
\begin{paracol}{2}
	\begin{tabular}{c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}}
		4 &         7         &         1         &         1         &     $\times$      & 8 & 1 & 5 \\ \midrule
		  & \textit{\small 3} & \textit{\small 5} &                   &                   &   &   &   \\
		  &         6         &         7         &         6         &         8         & 8 &   &   \\
		  &                   &                   &         4         &         7         & 1 & 1 &   \\
		  &                   &                   & \textit{\small 2} & \textit{\small 3} &   &   &   \\
		  &                   &                   &         2         &         3         & 5 & 5 & 5 \\ \midrule
		  &         3         &         8         &         3         &         9         & 4 & 6 & 5
	\end{tabular}
	\switchcolumn
	\textbf{\textsf{Mögliche Probleme / Schwierigkeiten}}
	\begin{enumerate}[noitemsep]
		\item kleines $1\times 1$ ist ein wenig Lernaufwand
		\item Überträge beim kleinen $1\times 1$ sind möglich
		\item Addition von mehr als zwei Ziffern gleichzeitig
		\item mehrstellige Überträge bei der Summenbildung möglich
		\item \label{lst:item:zwischensumme_stellen} für jede Zwischensumme muss der Addierer eine Stelle mehr verarbeiten
	\end{enumerate}
\end{paracol}

\autoref{lst:item:zwischensumme_stellen} wird deutlich durch eine Multiplikation einer 6- und 4-stelligen Zahl im Binärsystem \enquote{von links nach rechts}, wie sie in \autoref{tbl:multi_lr} dargestellt wird.
\begin{table}[ht]
	\centering
	\begin{tabular}{c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}l}
		1 & 0 & 1 & 0 & 1 & 0 & $\times$ & 1 & 0 & 1 & 0 & \quad ($42\times 10$)                \\ \midrule
		  &   & 1 & 0 & 1 & 0 &    1     & 0 &   &   &   &                                      \\
		  &   &   & 0 & 0 & 0 &    0     & 0 & 0 &   &   & \quad \textit{7-stellige Addition}   \\ \midrule
		  &   & 1 & 0 & 1 & 0 &    1     & 0 & 0 &   &   & \quad \textit{Zwischensumme}         \\
		  &   &   &   & 1 & 0 &    1     & 0 & 1 & 0 &   & \quad \textit{8-stellige Addition}   \\ \midrule
		  &   & 1 & 1 & 0 & 1 &    0     & 0 & 1 & 0 &   & \quad \textit{Zwischensumme}         \\
		  &   &   &   &   & 0 &    0     & 0 & 0 & 0 & 0 & \quad \textit{9-stellige Addition}   \\ \midrule
		  &   & 1 & 1 & 0 & 1 &    0     & 0 & 1 & 0 & 0 & \quad \textit{10-stelliges Ergebnis}
	\end{tabular}
	\caption{Schriftliche Multiplikation \enquote{von links nach rechts}}
	\label{tbl:multi_lr}
\end{table}

\columnratio{0.17}
\begin{paracol}{2}
	\bigskip
	\begin{center}
		\begin{tabular}{cc|c}
			b & a & ab \\
			\midrule
			0 & 0 & 0  \\
			0 & 1 & 0  \\
			1 & 0 & 0  \\
			1 & 1 & 1
		\end{tabular}
	\end{center}
	\switchcolumn
	\textbf{\textsf{Abhilfe}}
	\begin{enumerate}[noitemsep]
		\item Kleines $1\times 1$ im Binärsystem ist ein einfaches \code{UND}
		\item Es gibt keine Überträge beim kleinen $1\times 1$ im Binärsystem
		\item Bilden von Zwischensummen
		\item keine mehrstelligen Überträge bei Addition von zwei Summanden
		\item rechten Faktor beginnend mit niederwertigster Stelle abarbeiten, siehe \autoref{tbl:multi_rl}
	\end{enumerate}
\end{paracol}

\begin{table}[ht]
	\centering
	\begin{tabular}{c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c}
		1 &            0            &            1            &            0            &            1            &            0            &        $\times$         &            1            &           0            &            1            &             0             & ($42\times 10$) \\ \midrule
		  &                         &                         &                         &                         &            0            &            0            &            0            &           0            &            0            &   \textcolor{purple}{\textbf{0}}   &                 \\
		  &                         &                         &                         &            1            &            0            &            1            &            0            &           1            &            0            & \textcolor{purple}{$p_0$} &                 \\ \midrule
		  &                         &                         &                         &            1            &            0            &            1            &            0            &           1            &   \textcolor{OliveGreen}{\textbf{0}}   &                           &                 \\
		  &                         &                         &            0            &            0            &            0            &            0            &            0            &           0            & \textcolor{OliveGreen}{$p_1$} &                           &                 \\ \midrule
		  &                         &                         &            0            &            1            &            0            &            1            &            0            &   \textcolor{BrickRed}{\textbf{1}}   &                         &                           &                 \\
		  &                         &            1            &            0            &            1            &            0            &            1            &            0            & \textcolor{BrickRed}{$p_2$} &                         &                           &                 \\ \midrule
		  &   \textcolor{blue}{0}   &   \textcolor{blue}{1}   &   \textcolor{blue}{1}   &   \textcolor{blue}{0}   &   \textcolor{blue}{1}   &   \textcolor{blue}{0}   &   \textcolor{blue}{0}   &                        &                         &                           &                 \\
		  & \textcolor{blue}{$p_9$} & \textcolor{blue}{$p_8$} & \textcolor{blue}{$p_7$} & \textcolor{blue}{$p_6$} & \textcolor{blue}{$p_5$} & \textcolor{blue}{$p_4$} & \textcolor{blue}{$p_3$} &                        &                         &                           &
	\end{tabular}
	\caption{Schriftliche Multiplikation \enquote{von rechts nach links}}
	\label{tbl:multi_rl}
\end{table}

\newpage % Nur für's Layout

\subsection{Multiplikation mit Paralleladdierer}

Ein $n\times m$-Bit-\acf{PM}, bspw. ein $5\times 4$-Bit-\acl{PM} ist in \autoref{fig:parallelmultiplizierer} dargestellt.

\begin{figure}[ht]
	\centering
	\includegraphics[width=13cm]{Bilder/Parallelmultiplizierer.png}
	\caption{5-Bit Parallelmultiplizierer}
	\label{fig:parallelmultiplizierer}
\end{figure}

\begin{Achtung}[frametitle={Hinweis zur Abbildung}]
	Unbedingt auf die \enquote{0} als Eingang achten! Ansonsten gibt es in der Klausur punktabzug!
\end{Achtung}

\begin{Hinweis}
	In der Klausur muss evtl. ein 4-Bit \acl{PM} gezeichnet werden, also nicht mit 5 oder 6~Bit.
\end{Hinweis}

\subsubsection{Analyse: Hardwareaufwand für die Multiplikation mit Paralleladdierer}
\textit{Benötigt werden}:

\begin{itemize}[noitemsep]
	\item $m-1$ ~ $n$-Bit-\acs{PA}
	\item  $n\cdot m$ ~~ \code{UND} mit jeweils 2 Eingängen $\Rightarrow$ $2\cdot n\cdot m$ Transistoren
\end{itemize}

\textit{Somit ergibt sich bei\ldots}
\begin{enumerate}%[leftmargin=0pt]
	\item[\ldots] Verwendung eines \textbf{\acs{RC-PA}}:
		\begin{itemize}[noitemsep]
			\item[$\Rightarrow$] $n$-Bit-\acs{RC-PA}: ~ $18n-10$ Transistoren
			\item[$\Rightarrow$] davon $m-1$:  $(m-1)(18n-10)$ Transistoren = $18nm-18n-10m+10$ Transistoren
			\item[$\Rightarrow$] Insgesamt: ~~~ $20nm-18n-10m+10$ Transistoren $\Rightarrow O(n)$
		\end{itemize}

	\item[\ldots] Verwendung eines \textbf{\acs{CLA-PA}}
		\begin{itemize}[noitemsep]
			\item $n$-Bit-\acs{CLA-PA}: $\approx O(n\cdot 2^n)$
			\item $\Rightarrow$  davon $m-1$: ~ $(m-1)\cdot O(n\cdot 2^n) = O(n\cdot m\cdot 2^n)$
		\end{itemize}
\end{enumerate}

Hier bei verschieden großen Faktoren also besser $m>n$ bei \ac{CLA-PA}) für geringeren \acs{HW}-Aufwand.

Demgegenüber bei Verwendung von \acs{RC-PA}: Besser $n>m$ für geringeren \acs{HW}-Aufwand. \todo{Besser umformulieren}

\subsubsection{Analyse: Zeitaufwand für die Multiplikation mit Paralleladdierer}
1 \acs{GLZ} für einstellige Multiplikation (\code{UND}-Gatter) sowie $(m-1)~\times$ Berechnungszeit($n$-Bit-\acs{PA})

\begin{enumerate}
	\item Annahme: \acs{PA} sind $n$-Bit-\acs{RC-PA}. \newline
		Berechnungszeit eines $n$-Bit-\acs{RC-PA}: $2n$ \acs{GLZ} \newline
		Insgesamt: $1+(m-1)\cdot 2n=2nm-2n+1$ \acs{GLZ} \newline
		Damit besser $n>m$ bei Verwendung von \acs{RC-PA} um geringeren Zeitaufwand zu bekommen.

	\item Annahme: \acs{PA} sind $n$-Bit-\acs{CLA-PA} \newline
		Berechnungszeit eines $n$-Bit-\acs{CLA-PA}: $6$ \acs{GLZ} \newline
		Insgesamt: $1 + (m-1)\cdot 6$ \acs{GLZ} $=6m-5$ \acs{GLZ} $=O(m)$ \newline
		damit: besser $n>m$ bei Verwendung von \acs{CLA-PA}, um geringeren Zeitaufwand zu bekommen \newline
		$\lightning$ zu großer \acs{HW}-Aufwand (wächst exponentiell mit $n$)
\end{enumerate}\todo{Kontrollieren...}

\begin{Hinweis}[frametitle={Hinweis für die Klausur}]
	Logarithmischen Aufwand für \acs{CLA-PA} auf \href{https://de.wikipedia.org/wiki/Paralleladdierer_mit_\%C3\%9Cbertragsvorausberechnung}{Wikipedia} nachschauen. Dies wird wahrscheinlich in der Klausur abgefragt! Unserer Variante hat exponentiellen Hardwareaufwand und konstanten Zeitaufwand. Die Variante auf \href{https://de.wikipedia.org/wiki/Paralleladdierer_mit_\%C3\%9Cbertragsvorausberechnung}{Wikipedia} nicht.
\end{Hinweis}

\subsection{Seriellmultiplizierer}
Motivation: Noch engere Anlehung an das schriftliche Multiplikationsverfahren, um den Aufwand für die Addierglieder gering zu halten.

Siehe \autoref{fig:seriellmultiplizierer}.

\begin{figure}[ht]
	\centering
	\includegraphics[width=13cm]{Bilder/Seriellmultiplizierer.png}
	\caption{5-Bit Seriellmultiplizierer}
	\label{fig:seriellmultiplizierer}
\end{figure}

\bigskip
\begin{Hinweis}
	Vor dem ersten Takt müssen alle D-FF auf \code{0} gesetzt werden \newline
	(\enquote{Reset-Eingang} oder ähnliches)
\end{Hinweis}

\subsubsection{Analyse: Hardwareaufwand für $n\times m$-Seriellmultiplizierer}
\textit{Benötigt werden:}

\begin{tabular}{c@{}ll}
	\textbullet~ & $n$-Bit-\acs{PA} $\Rightarrow$ $n$-Bit-\acs{RC-PA} & $\Rightarrow$ $18n-10$ Transistoren \\
	\textbullet~ & $n$ \code{UND} mit jeweils 2 Eingängen             & $\Rightarrow$ 2 Transistoren        \\
	\textbullet~ & $2n$ \acsp{D-FF}                                   & $\Rightarrow$ $12n$ Transistoren    \\
	\textbullet~ & $2m$-Bit-\acs{SR}                                  & $\Rightarrow$ $12m$ Transistoren    \\
	\textbullet~ & \multicolumn{2}{l}{Takterzeugung (wird im folgenden nicht berücksichtigt)}
\end{tabular}

gesamt: $18n-10+2n+12n+12m=32n+12m-10$ Transistoren % stimmt so; verglichen mit 15er

\qquad $\Rightarrow$ $O(n+m)$

\subsubsection{Analyse: Zeitaufwand für $n\times m$-Seriellmultiplizierer mit RC-PA}
Zeitaufwand: $m$ Taktzyklen

Mindestdauer eines halben Taktzyklus: Berechnungszeit \enquote{innen}

\begin{tabular}{rl}
	$\frac{1}{2}$ Taktzyklus   & $\gtrsim$ Auslesezeit(\acs{SR}) + \code{UND} + $n$-Bit-\acs{PA} + Einlesezeit(\acs{SR}) \\
	                           & $= 1+1+2n+1=2n+3$ \acs{GLZ}                                                             \\
	$\Rightarrow$ 1 Taktzyklus & $\gtrsim$ $4n+6$ \acs{GLZ}                                                              \\
	gesamt:                    & $\gtrsim m\cdot(4n+6)=4mn+6m=O(nm)$
\end{tabular}\todo{Kontrollieren}



\section{Division} \index{Division}
\columnratio{0.24}
\begin{paracol}{2}
	\begin{tabular}{c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}c@{\,}}
		4 & 7 & 1 & 1 & $:$ & 1 & 3 & $=0362,\ldots$ \\
		0 &   &   &   &     &   &   &         \\ \cline{1-2}
		4 & 7 &   &   &     &   &   &         \\
		3 & 9 &   &   &     &   &   &         \\ \cline{1-3}
		  & 8 & 1 &   &     &   &   &         \\
		  & 7 & 8 &   &     &   &   &         \\ \cline{1-4}
		  &   & 3 & 1 &     &   &   &         \\
		  &   & 2 & 6 &     &   &   &         \\ \cline{3-4}
		  &   &   & 5 &     &   &   &
	\end{tabular}
	\switchcolumn
	Die Division wird runter gebrochen auf mehrere Divisionen mit einstelligen Ergebnissen.

	Dies ist recht komplex bei einem großem Divisor. Aber im Binärsystem ist es ein einfacher Größenvergleich, da das einstellige Ergebnis nur \code{1} oder \code{0} sein kann. \newline
	(besser wäre Integration in anschließend notwendiger Subtraktion)

	Trotzdem bleiben einige Schritte zu tun, was aufwändig ist. In heutigen \acsp{CPU} ist deshalb (meist) kein Hardware-Dividierer eingebaut.
\end{paracol}

\begin{tabular}{rp{13.5cm}}
	      \textit{Grund}: & Die Division wird deutlich seltener als Addition, Subtraktion und Multiplikation gebraucht.                                                                                                                                                                                                                    \\
	\textit{Stattdessen}: & Division \enquote{in Software}/\enquote{als Programm}, \zB als Bibliotheksroutine (\enquote{Funktion}), evtl. bereitgestellt vom Betriebssystem oder als Mikroprogramm, welches Bestandteil der \acs{CPU} ist und aufgerufen wird, wenn ein entsprechender Maschinensprachenbefehl ausgeführt werden soll.
\end{tabular}



\section{CPUs} \index{RISC} \index{CISC}
In \autoref{tbl:risc_cisc} werden \acs{RISC} und \acs{CISC} verglichen.
\begin{table}[ht]
	\centering
	\hspace*{-6mm}
	\begin{tabular}{cp{7.55cm}|cp{7.55cm}}
		\multicolumn{2}{p{8.2cm}|}{\textbf{\acf{RISC}}}
		& \multicolumn{2}{p{8.2cm}}{\textbf{\acf{CISC}}}
		\\ \midrule

		\multicolumn{2}{p{8.2cm}|}{für jeden Maschinensprachenbefehl gibt es eine \enquote{passende} Hardwareeinheit}
		& \multicolumn{2}{p{8.2cm}}{manche Maschinensprachenbefehle werden als Mikroprogramm ausgeführt}
		\\ \midrule

		$\oplus$ & Einheit für Mikroprogrammausführung kann bei der Produktion entfallen \newline
		(CPU weniger komplex)
		& $\oplus$ & komfortables Programmieren in Maschinensprache \\

		$\ominus$ & \acs{CPU} wird komplex, falls die Forderung nach komplexen Befehlen in Maschinensprache realisiert, besteht.
		& $\ominus$ & bei manchen Befehlen (welche als Mikroprogramm ausgeführt werden) ist die Bearbeitungszeit sehr groß und variabel.
		\\

		$\oplus$ & jeder Befehl kann in wenigen (und jeweils einer festen Zahl an) Taktzyklen ausgeführt werden.
		& $\ominus$ & Mikroprogramme sind Software, komplex und fehleranfällig, ggf. Austausch der \acs{CPU} für \enquote{Bugfix} notwendig (vgl. \href{https://de.wikipedia.org/wiki/Pentium-FDIV-Bug}{Intel Pentium FDIV Bug})
		\\
	\end{tabular}
	\medskip
	\hspace*{-6mm}
	\begin{tabular}{p{8.2cm}|p{8.2cm}}
		\multicolumn{2}{c}{\textbf{Einsatz}} \\ \midrule

		PowerPC-\acs{CPU} in Apple-Rechnern bis vor 10 Jahren
		& Intel-\acsp{CPU} in heutigen Universalrechnern (und AMD-Äquivalent)
		\\

		oft in \enquote{embedded systems} (Bsp. ARM)

	\end{tabular}
	\caption{Vergleich von RISC und CISC}
	\label{tbl:risc_cisc}
\end{table}


\section{Speicher in Computern} \index{Speicher}

\subsection{Speicherhierarchie}
\autoref{tbl:speicherhierarchie} zeigt die Speicherhierarchie in modernen Universalrechnern

\begin{table}[ht]
	\centering
	\begin{tabular}{p{29mm}|p{36mm}|p{17mm}|p{34mm}|p{23mm}}
		Speicher                             & von-Neumann-Rechner                      & Persistenz     & Größe                                                                                       & Zugriffszeit                                                                                                          \\ \midrule
		\acs{CPU}-Register                   & Zentraleinheit (Rechen- und Steuerwerk)  & flüchtig       & $<1kB$ Byte                                                                                 & $\approx$ 200ps                                                                                                       \\ \midrule
		Cache \newline (\enquote{CPU-Cache}) & nicht vorhanden                          & flüchtig       & \circa{4}MB \newline L1$\approx$64KB \newline L2$\approx$512KB                              & $\approx$ 10ns                                                                                                        \\ \midrule
		Hauptspeicher/ Primärspeicher        & Speicherwerk                             & flüchtig       & \circa{8}GB                                                                                 & $\approx$ 100ns \newline L1 schneller                                                                                 \\ \midrule
		Sekundärspeicher                     & Peripheriegeräte an Ein- und Ausgabewerk & nicht flüchtig & HDD: 3T \newline SSD: 512GB \newline opt.~\acs{LW}: bis~100GB \newline \acs{BLW}: wenige TB & HDD~$\approx10ms$ \newline SSD~$\approx 10\mu s$\newline opt.~\acs{LW}~$\approx 1s$ \newline \acs{BLW}~$\approx 1min$
	\end{tabular}
	\caption{Speicherhierarchie und -Daten}
	\label{tbl:speicherhierarchie}
\end{table}

\subsection{Sekundärspeicher}
Motivation für Sekundärspeicher: nicht-flüchtig, \dash der Speicherinhalt bleibt auch bei Stromausfall erhalten.

\textbf{Anwendungen:}

\begin{itemize}[noitemsep]
	\item Programmcode (Betriebsystem, Anwendungsprogramme)
	\item Nutzdaten
	\item virtuelle Erweiterung des Speicherwerks (Swap-Datei/-Partition)
	\item Hibernation (\enquote{Ruhezustand})
\end{itemize}

\subsection{CPU-Cache}
\begin{figure}[ht]
	\centering
	\begin{tikzpicture}
		% CPU
		\draw (-3, -0.5) rectangle ++(6,1);
		\node at (0, 0) (SW) {Speicherwerk};

		\draw (-2.5, 1.5) rectangle ++(5,1);
		\node at (0, 2) (Ca) {CPU-Cache};

		\draw (-2, 3.5) rectangle ++(4,1);
		\node at (0, 4) (CPU) {Zentraleinheit (CPU)};

		\draw ($(CPU)+(0,-0.5)$) -- ($(Ca)+(0,0.5)$) ($(Ca)+(0,-0.5)$) -- ($(SW)+(0,0.5)$);
	\end{tikzpicture}
	\caption{...}
	\label{fig:cpu_cache}
\end{figure}

Temporärer, flüchtiger, schneller Zwischenspeicher, um auf Informationen aus dem Hauptspeicher schneller zugreifen zu können.

Eigenschaften des Cache:
\begin{itemize}[noitemsep]
	\item flüchtig
	\item kleiner als das zu cachende Medium (Hauptspeicher)
	\item schneller als das zu cachende Medium (Hauptspeicher)
	\item transparent, \dash es wird nicht auf den Cache, sondern auf das zu cachende Medium logisch zugegriffen (die \acs{CPU} adressiert den Hauptspeicher und nicht den Cache)
	\item konsistent, \dash alle Instanzen derselben \acf{HSA} haben denselben Wert
	\item kohärent, \dash beim Zugriff auf eine \acs{HSA} wird immer der aktuelle Wert geliefert
\end{itemize}

\bigskip
\begin{Hinweis}[frametitle={Anmerkung: Kohärenz und Konsistenz}]
	Kohärenz ist Pflicht und Konsistenz ist Wunsch, da aus Konsistenz Kohärenz folgt. Zeitweise kann aber auf Konsistenz verzichtet werden.
\end{Hinweis}

Lokalität des Zugriffmusters \newline
$\Rightarrow$ verantwortlich dafür, dass der Cache Geschwindigkeitsvorteile bringen kann.
