\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 mechanisch vs elektrisch und digital vs analog.

Moderne \enquote{Rechner} (PC \& Co.) arbeiten elektrisch und digital. Dem gegenüber stehen elektrische Analogrechner (elektrisch und analog; um die 1920er).


\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 ENIAC besitzt als zentrales Bauteil eine Elektronenröhr. 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}

	\item[Moderne Rechner] Moderne transistorisierte Digitalrechner (\zB Uniac) 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}
In \autoref{fig:neumann_architektur} wird die von-Neumann-Architektur vereinfacht dargestellt.

\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[Ausgaberwerk] \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}
Die Harvard-Architektur ist ähnlich der 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} zeigt die Harvard-Architektur und wie sich diese von der 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 Seite~\pageref{tbl:vergleich_vn_hv} vergleicht die von-Neumann-Architektur mit der Harvard-Architektur.

\begin{table}[h]
	\hspace*{-7mm}
	\begin{tabular}{cp{7.6cm}|cp{7.6cm}}
		& \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 PCs: BIOS, CPU-Cache in modernen CPUs (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}}

\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
	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 im Binärsystem
\end{paracol}

\section{Schaltnetzsysnthese}

\subsection{Wiederholung/Grundlegendes}

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


\subsection{Halbaddierer}
Addition von zwei einstelligen Binärzahlen $a$ und $b$ zu einer zweistelligen Binärzahl $c_{out}s$ (Übertrag und Summe). Schaltsymbol und Schaltnetz des Halbaddierer 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$};

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

\subsection{Volladdierer}
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 beiden Eingänge des \texttt{XOR} \enquote{1}) nie auftritt, reicht ein einfaches \texttt{OR}.


\subsection{Paralleladdierer (4-Bit-Ripple-Carry-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.

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

\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.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{Paralleladdierer -- Schaltnetz und Schaltsymbol}
	\label{fig:paralleladdierer}
\end{figure}

\textit{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.

\textsf{\textbf{Schaltungsanalyse:}} \newline
Bestimmung des \enquote{Aufwands}. Aufwand kann sein:
\begin{itemize}[noitemsep]
	\item \enquote{Hardware-Aufwand} (in Transistoren)
	\item Zeitaufwand
\end{itemize}

\textsf{\textbf{Warum Zeitaufwand?}} \newline
Es wird der Zeitaufwand betrachtet, da Gatter Schaltzeiten haben, typischerweise \circa{10 Pikosekunden}. 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}}).

\textsf{\textbf{Hardwareaufwand des 4~Bit RC-PA}}

\noindent\begin{tabular}{@{}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 HA und 2 Transistoren für $c_{out}$                 & $\Rightarrow$  $2\cdot8+2=18$ Transistoren
\end{tabular}

\textit{Benötigt werden:} \newline
1 HA = 8 Transistoren \textit{plus}
$(n-1)$ VA = $(n-1) \cdot 18~\text{Transistoren} = (18n-18) \text{Transistoren}$ \newline
\quad $\Rightarrow$ insgesamt also: 8 + (18n - 18) = 18n - 10 Transistoren = $O(n)$

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.

\textsf{\textbf{Zeitaufwand des 4~Bit RC-PA}} \newline
für \acs{HA}: max. 2 Gatterlaufzeiten (\enquote{Tiefe 2}, siehe \autoref{fig:halbaddierer}) \newline
für \acs{VA}: max. 4 Gatterlaufzeiten

Beim \acs{RC-PA} liegen die einzelnen $s_i$ nach unterschiedlicher Zeit an. \newline
$s_i$ wird nach $(i+1)\cdot 2$ \acs{GLZ} erreicht. Das längste $s_i$ ist bei $n$~Bit-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! Zu erwarten wäre $O(1)$.

\textit{Auswirkung}: Beim Wechsel von 32- auf 64-Bit-CPU hätte sich die Taktfrequenz halbiert. Daraus lässt sich folgern, dass kein 64-Bit-\acs{RC-PA} in der 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 0 auf 1 ändern, erreicht.

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

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

\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{CLA-Paralleladdierer -- Schaltnetz}% und Schaltsymbol}
	\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*}\todo{Überprüfen, ob korrekt aufgeschrieben.}

Aber: Für die Berechnung der $c_{in_i}$ kann jeweils eine \acs{DNF}, \acs{DMF} oder jede andere DxF (wie auch eine KxF) verwendet werden. \newline
$\Rightarrow$ 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}).

$\Rightarrow$ konstanter Zeitaufwand $O(1)$

\textsf{\textbf{Hardwareaufwand des 4~Bit CLA-PA}} \newline
Aufwand für $c_{in_i}$-Berechnung: Annahme Schaltnetz wäre Realisierung der \acs{DNF}.\newline
für $c_{in_i}$ gibt es insgesamt $2i$ Eingänge\newline
$\Rightarrow$  insgesamt max $2^{2i}$ verschiedene Vollkonjunktionen, welche in der \acs{DNF} auftreten können.\newline
Jede dieser Vollkonjunktionen wird mit $2i$ Transistoren realisiert.\newline
$\Rightarrow$ falls alle Vollkonjunktionen verwendet werden müssten, wäre der Hardwareaufwand $2^{2i}\cdot 2i$ Transistoren.

In der Realität werden natürlich nicht alle Vollkonjunktionen benötigt, sondern ein (vermutlich halbwegs konstanter) Anteil $0 < k < i$.

$\Rightarrow$ damit ist der Aufwand für $c_{in_i} = O(i\cdot4^i) = O(i\cdot2^i)$
damit ist der Aufwand für $n$-Bit-\acs{CLA-PA}: $O(n^2\cdot2^n)$

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 halb-billionenfache Aufwand an Transistoren nötig gewesen. \textit{Das ist viel zu viel}. % Der Hardwareaufwand von 64~Bit im Gegensatz zu 32~Bit wäre viel zu groß und damit wird auch dieser Paralleladdierer nicht in der CPU verwendet.

\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$)
\end{tabular}\todo{Vergleichen: Siehe Notizen, etc.}

Addierer für 32-Bit: Aufsplitten in acht 4-Bit-\acs{CLA-PA}

\begin{figure}[h!]
	\centering
	\includegraphics[width=13cm]{Bilder/casc_cla_pa.png}
	\caption{Kaskadierbare 4-Bit-CLA-PA}
	\label{fig:casc_cla_ca}
\end{figure}\todo{Als Tikz übernehmen}

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


\subsection{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} nötig. 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}

\textsf{\textbf{Zeitaufwand ($N$-Bit-SA})}: $n$ Taktzyklen $\Rightarrow$  $O(n)$

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

\textsf{\textbf{Hardwareaufwand ($N$-Bit-SA})}

1 \acs{VA}: 18 Transistoren \newline
2 \acs{D-FF}. $2\cdot 6=12$ Transistoren. Siehe Grafik rechts:
3. $n$-Bit-\acs{SR}: Siehe Grafik links
Takterzeugung (im folgenden nicht näher betrachtet)
\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 er hier nicht weiter betrachtet wird!
\end{Achtung}
