diff --git a/Bilder/4_16_Dekoder.png b/Bilder/4_16_Dekoder.png new file mode 100644 index 0000000..3879886 Binary files /dev/null and b/Bilder/4_16_Dekoder.png differ diff --git a/Bilder/HS_Kondensator.png b/Bilder/HS_Kondensator.png new file mode 100644 index 0000000..bafde67 Binary files /dev/null and b/Bilder/HS_Kondensator.png differ diff --git a/Bilder/Matrix_Decoder.png b/Bilder/Matrix_Decoder.png new file mode 100644 index 0000000..a5baf7b Binary files /dev/null and b/Bilder/Matrix_Decoder.png differ diff --git a/Bilder/Matrix_Multiplexer.png b/Bilder/Matrix_Multiplexer.png new file mode 100644 index 0000000..d8e7e1a Binary files /dev/null and b/Bilder/Matrix_Multiplexer.png differ diff --git a/Bilder/Schaltnetz_MUX.png b/Bilder/Schaltnetz_MUX.png new file mode 100644 index 0000000..55b2491 Binary files /dev/null and b/Bilder/Schaltnetz_MUX.png differ diff --git a/Bilder/Seriellmultiplizierer.png b/Bilder/Seriellmultiplizierer.png index cff9316..8322738 100644 Binary files a/Bilder/Seriellmultiplizierer.png and b/Bilder/Seriellmultiplizierer.png differ diff --git a/Kapitel/03_Speicher.tex b/Kapitel/03_Speicher.tex index 4a668f1..32a6019 100644 --- a/Kapitel/03_Speicher.tex +++ b/Kapitel/03_Speicher.tex @@ -624,7 +624,7 @@ In \autoref{fig:cpu_mehrprozessor} besitzt jeder Kern einen eigenen Cache. Mögl & $\ominus$ & Dieselben Daten müssen ggf. mehrfach in den Caches gehalten werden. \\ [4ex] - $\ominus$ & komplexer Bus mit Zugriffsprotokoll (Zeitverlust zumindest bei Zugriffskollision) + $\ominus$ & komplexer Bus mit Zugriffsprotokoll\newline(Zeitverlust zumindest bei Zugriffskollision) & $\oplus$ & einfache 1:1-Verbindungen (kein komplexes Zugriffsprotokoll) \\ [2ex] @@ -634,7 +634,7 @@ In \autoref{fig:cpu_mehrprozessor} besitzt jeder Kern einen eigenen Cache. Mögl \label{tbl:mehrprozessor_cache} \end{table} -Abhilfe für Inkonsistenz bei mehreren Caches und Mehrprozessorsystemen: +Abhilfe für Inkonsistenzen bei mehreren Caches und Mehrprozessorsystemen: \begin{itemize}[noitemsep] \item gemeinsamer Cache (ungünstige Performance aufgrund eines Bus) @@ -642,3 +642,171 @@ Abhilfe für Inkonsistenz bei mehreren Caches und Mehrprozessorsystemen: \end{itemize} Tatsächlich haben moderne \acsp{CPU} beim L1-Cache getrennte Caches für jeden Kern und beim L3-Cache einen gemeinsamen Cache. Ob eine Snoop-Logik verwendet wird, ist davon abhängig, ob es für das Level notwendig ist oder nicht. + +\section{Hauptspeicher-Organisation} +Ein \acl{HS}-Wort wird über eine \acl{HSA} (binäre, ganze, nicht negative Zahl) angesprochen. +Jedes \acl{HS}-Wort hat eine feste Wortbreite (im besten Fall gleich der \acs{CPU}-Wortbreite, also 64-Bit). + +Im folgenden gehen wir von 1-Bit-Worten aus: +\begin{center} + $0\leq \text{\acs{HSA}} \leq (\text{\acs{HS}-Größe in Worten}) - 1$ +\end{center} + +Ein 1-Bit-Kondensatorspeicher wird in \autoref{fig:hs_kondensator} gezeigt. Für jedes \acl{HS}-Wort gibt es eine Select-Leitung. Für jedes Bit des Wortes gibt es einen Kondensator und einen Transistor. Diese werden dann parallel geschaltet. + +Mehrere 1-Bit-Worte hängen an der selben Datenleitung, werden aber über unterschiedliche Select-Leitungen angesteuert. + +\begin{figure}[!ht] + \centering + \includegraphics[width=\textwidth-4cm]{./Bilder/HS_Kondensator.png} + \caption{Hauptspeicher -- 1-Bit-Kondensatorspeicher} + \label{fig:hs_kondensator} +\end{figure} + +Um aus der $n$-Bit-\acs{HSA} $2^n$ Select-Leitungen zu erzeugen, welche die Bits abfragen, ist ein $n:2^n$-Decoder notwendig. + +In \autoref{fig:4_16_dekoder} wird ein 4:16-Decoder mit entsprechender Wertetabelle gezeigt. + +\begin{figure}[!ht] + \centering + \includegraphics[width=7cm]{./Bilder/4_16_Dekoder.png} + \medskip + \begin{tabular}{cccc|cccccccccccccccc} + $a_3$ & $a_2$ & $a_1$ & $a_0$ & $s_{15}$ & $s_{14}$ & $s_{13}$ & $s_{12}$ & $s_{11}$ & $s_{10}$ & $s_{9}$ & $s_{8}$ & $s_{7}$ & $s_{6}$ & $s_{5}$ & $s_{4}$ & $s_{3}$ & $s_{2}$ & $s_{1}$ & $s_{0}$ \\ \midrule + 0 & 0 & 0 & 0 & & & & & & & & & & & & & & & & 1 \\ + 0 & 0 & 0 & 1 & & & & & & & & & & & & & & & 1 & \\ + 0 & 0 & 1 & 0 & & & & & & & & & & & & & & 1 & & \\ + 0 & 0 & 1 & 1 & & & & & & & & & & & & & 1 & & & \\ + 0 & 1 & 0 & 0 & & & & & & & & & & & & 1 & & & & \\ + 0 & 1 & 0 & 1 & & & & & & & & & & & 1 & & & & & \\ + 0 & 1 & 1 & 0 & & & & & & & & & & 1 & & & & & & \\ + 0 & 1 & 1 & 1 & & & & & & & & & 1 & & & & & & & \\ + 1 & 0 & 0 & 0 & & & & & & & & 1 & & & & & & & & \\ + 1 & 0 & 0 & 1 & & & & & & & 1 & & & & & & & & & \\ + 1 & 0 & 1 & 0 & & & & & & 1 & & & & & & & & & & \\ + 1 & 0 & 1 & 1 & & & & & 1 & & & & & & & & & & & \\ + 1 & 1 & 0 & 0 & & & & 1 & & & & & & & & & & & & \\ + 1 & 1 & 0 & 1 & & & 1 & & & & & & & & & & & & & \\ + 1 & 1 & 1 & 0 & & 1 & & & & & & & & & & & & & & \\ + 1 & 1 & 1 & 1 & 1 & & & & & & & & & & & & & & & + \end{tabular} + \caption{Hauptspeicher -- 1-Bit-Kondensatorspeicher} + \label{fig:4_16_dekoder} +\end{figure} + +Es müssen alle Minterme gebildet werden. +Die \acs{DNF} ist für jedes $s_i$ gleichzeitig die \acs{DMF} (da sie aus nur einem Minterm besteht). \newline +Somit besteht der $n:2^n$ Decoder aus genau $2^n$ Mintermen mit jeweils $n$ Literalen. + +\begin{tabular}{@{}ll} + \textsf{\textbf{Zeitaufwand}}: & 1~\acs{GLZ} ($O(1)$) und damit perfekt \\ [1ex] + \textsf{\textbf{Hardwareaufwand}}: & $n\cdot 2^n$ Transistoren +\end{tabular} + +\textbf{\textsf{Hardwareaufwand für Speicher und Decoder}}: \newline +Am Beispiel vom Apple \RNum{2}/C64/\ldots: 16~Bit~\acs{HSA}, 8~Bit~Worte +\begin{itemize} + \item[$\Rightarrow$] $2^{16}$ 8-Bit-Worte: 65536~Byte = 512~kBit Speicher + \item[$\Rightarrow$] für Speicher: 1 Mio. Bauelemente \newline + für $16:2^{16}$ Decoder: $16\cdot 2^{16}$ Transistoren $\approx$ 1 Mio. Transistoren + \item[$\Rightarrow$] der Decoder hat denselben Aufwand wie der Speicher! +\end{itemize} + +\newpage % Nur für's Layout + +\acs{PC} mit 32~Bit~\acs{CPU}: +\begin{itemize}[noitemsep] + \item[] 32~Bit = 4~Byte \acl{HS}-Wertgröße + \item[] 32~Bit-\acs{HSA}: $2^{32}$ \acs{HS}-Werte $\approx$ 4~Mrd. \acs{HS}-Werte +\end{itemize} +\bigskip + +\begin{Tipp} + Intel-\acsp{CPU} adressieren nach wie vor jedes einzelne Byte und nicht \acl{HS}-Werte der Größe 4 oder 8~Byte. +\end{Tipp} + +Eine Ideale 32~Bit~\acs{CPU} hätte $2^{32}$ Werte je 32~Bit: +\begin{itemize}[noitemsep] + \item[$\Rightarrow$] $2^{32}\cdot 32$~Bit $\approx$ 128~Mrd.~Bit Speicher + \item[$\Rightarrow$] 256 Mrd. Bauelemente Hardwareaufwand für \acl{HS} + \item[$\Rightarrow$] Hardwareaufwand für einen $32:2^{32}$ Decoder: $32\cdot 2^{32}$ Tr. = 128~Mrd. Transistoren. +\end{itemize} + +Ideale 64~Bit~\acs{CPU} hätte $2^{64}$ Werte je 64~Bit: +\begin{itemize}[noitemsep] + \item[$\Rightarrow$] $2^{64}\cdot 64$~Bit $=2^{70}$ $\approx$ 1~Trilliarde~Bit + \item[$\Rightarrow$] 2 Trilliarden Bauelemente Hardwareaufwand für \acs{HS}. + \item[$\Rightarrow$] $64:2^{64}$ Decoder: $64\cdot 2^{64}$ Transistoren $\approx$ 1 Trilliarde Transistoren +\end{itemize} + +In jedem Fall ist der Hardwareaufwand für den Decoder in derselben Größenordnung wie für den eigentlichen Hauptspeicher und damit sehr (zu) groß! + +\textit{Abhilfe}: matrixförmige Speicherorganisation + +\section{Matrixförmige Speicherorganisation} +Eine matrixförmige Speicherorganisation: zweidimensionale Anordnung der Speicherwerte in Zeilen und Spalten, siehe \autoref{fig:matrix_decoder} auf \autopageref{fig:matrix_decoder}. + +\begin{figure}[!ht] + \centering + \includegraphics[width=\textwidth-5cm]{./Bilder/Matrix_Decoder.png} + \caption{Matrixdecoder} + \label{fig:matrix_decoder} +\end{figure} + +$a_3a_2$ gibt die Zeilennummer an und $a_1a_0$ die Spaltennummer. Somit reicht es statt eines 4:16-Decoder einen 2:4 Zeilen- und einen 2:4 Spalten-Decoder zu verwenden. + +\textbf{Aufwand} \newline +Anstatt eines 4:16-Decoder mit 64 Transistor, zwei 2:4-Decoder mit $2\cdot 8$ Transistoren = 16 Transistoren. + +64-Bit \acs{HSA}: als $64:2^{64}$ Decoder: $2^{70}$ Transistoren \newline +als Matrix mit $2^{32}$ Zeilen und $2^{32}$ Spalten: \newline +$32:2^{32}$ Decoder mit jeweils $32\cdot 2^{32}$ Transistoren=$2^{37}$ Transistoren \newline +2 Stück: $2^{38}$ Transistoren: 256 Mrd. Transistoren + +In linearer Organisation betrüge der Decoder-Aufwand das 4-Mrd.-fache! Damit ergibt sich eine große Einsparung beim Decoder-Aufwand! + +\textit{Aber}: für die Realisierung des 2. Select-Eingangs wird ein weiterer Transistor je Bit benötigt \newline +$\Rightarrow$ dieselbe Größenordnung Zusatzaufwand wie Einsparung? + +Statt eines Spalten-Decoders werden die Datenleitungen aller Speicherbits einer Spalte zusammengeschaltet (als jeweils eine Spalten-Datenleitung). Von diesen wird aber über einen Spalten-Multiplexer ein Spalten-Daten-Signal ausgewählt. Dies wird in \autoref{fig:matrix_multiplexer} dargestellt. + +\begin{figure}[ht] + \centering + \includegraphics[width=\textwidth-4cm]{./Bilder/Matrix_Multiplexer.png} + \caption{Matrixmultiplexer} + \label{fig:matrix_multiplexer} +\end{figure} + +\begin{description} + \item[$2^n:1$-MUX] Baustein, welcher aus $2^n$-Dateneingängen anhand einer $n$-stelligen Adresse eine Datenleitung auswählt und ausgibt. +\end{description} + +$2^4:1$-MUX: Hat 4 Adresseingänge und $2^4=16$ Dateneingänge + +\begin{figure}[!ht] + \centering + \includegraphics[width=\textwidth-2cm]{./Bilder/Schaltnetz_MUX.png} + \caption{Schaltnetz eines $4:1$-MUX} + \label{fig:schaltnetz_MUX} +\end{figure} + +Realisierung über $2:4$ Decoder sowie 4 \code{UND} mit jeweils 2 Eingängen und ein \code{ODER} mit 4 Eingängen + +$2^n:1$ MUX: \newline +\hspace*{5mm}ein $n:2^n$ Decoder \newline +\hspace*{5mm}$2^n$ \code{UND} mit jeweils 2 Eingängen \newline +\hspace*{5mm}ein \code{ODER} mit $2^n$ Eingängen \newline +\hspace*{5mm}Gesamtaufwand: \newline +\hspace*{5mm}$n\cdot 2^n+2\cdot 2^n+2^n$ Transistoren \newline +\hspace*{5mm}$=(n+3)\cdot 2^n$ Transistoren \newline\todo{Formatieren} + +Insgesamt braucht man für einen kleinen Decoder und einem kleinen Multiplexer immer noch deutlich weniger Hardwareaufwand wie für einen großen Decoder. + +Vor den Multiplexer kann ein Cache geschaltet werden, sodass eine ganze \acs{HSS} (=Matrixzeile) eingelesen werden kann. + +\subsection{Gründe für Matrixorganisation} +\begin{enumerate} + \item weniger Aufwand für Adresscodecodierung + \item Einlesen einer ganzen \acs{HSS} (=Matrixzeile) in den Cache + \item zeilenweiser Refresh des \acs{HS} (wortweiser Refresh-Zyklus dauert viel zu lange) +\end{enumerate} \ No newline at end of file