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.
Herr Röthig meint hier 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.
\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).
Ein 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.
\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}.
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
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.
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.
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.
\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
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 für ein $c_{in_i}$, welche in der \acs{DNF} auftreten können (\enquote{Zeilen in der Wertetabelle}). \newline
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\cdot n\cdot4^n)=O(n^2\cdot4^n)$
Im folgenden wird fälschlicherweise von einem Aufwand $O(n^2\cdot2^n)$ ausgegangen. Richtig wäre $O=(n^2\cdot4^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\cdot2^4=$~ &$16\cdot16$~ $=$&$256$& ~Transistoren \\
Bei $n=8$: \quad$8^2\cdot2^8=$~ &$64\cdot256=$& ~ \circa{$16384$}& ~Transistoren (64-fache von $n=4$) $\Rightarrow$\textit{zu viel für die \acs{CPU}}
\end{tabular}
\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$};
\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}\acf{VA} und mehrere \acf{SR} benötigt. Daher ist der \acf{SA} ein Schaltwerk, kein Schaltnetz! \autoref{fig:serielladdierer} zeigt das Schaltwerk eines Serielladdierer.
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}
\textbf{\textsf{Mögliche Probleme / Schwierigkeiten}}
\begin{enumerate}[noitemsep]
\item kleines $1\times1$ ist ein wenig Lernaufwand
\item Überträge beim kleinen $1\times1$ 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.
Unbedingt auf die \enquote{0} als Eingang achten! Ansonsten gibt es in der Klausur punktabzug! Bei unterschiedlicher Stellenanzahl sind Nullen aufzufüllen.
Den 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.
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.
$\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})
