From af23c0e576346a7ae42fbb5a985b8debf487d53c Mon Sep 17 00:00:00 2001 From: Andre Meyering Date: Mon, 13 Nov 2017 12:39:02 +0100 Subject: [PATCH] =?UTF-8?q?[Kapitel]=20Neueste=20Inhalte=20erg=C3=A4nzt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kapitel/02_Rechner.tex | 176 ++++++++++++++++++++++- Rechnerarchitektur_Roethig_Skript_AM.tex | 8 +- 2 files changed, 182 insertions(+), 2 deletions(-) diff --git a/Kapitel/02_Rechner.tex b/Kapitel/02_Rechner.tex index 0a89204..dcf02b1 100644 --- a/Kapitel/02_Rechner.tex +++ b/Kapitel/02_Rechner.tex @@ -941,6 +941,180 @@ Siehe \autoref{fig:seriellmultiplizierer}. \label{fig:seriellmultiplizierer} \end{figure} +\bigskip \begin{Hinweis} - Vor dem ersten Takt müssen alle D-FF auf \code{0} gesetzt werden (\enquote{Reset-Eingang} oder ähnliches) + 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. diff --git a/Rechnerarchitektur_Roethig_Skript_AM.tex b/Rechnerarchitektur_Roethig_Skript_AM.tex index aa91ccf..849a142 100644 --- a/Rechnerarchitektur_Roethig_Skript_AM.tex +++ b/Rechnerarchitektur_Roethig_Skript_AM.tex @@ -39,8 +39,10 @@ \chapter{Abkürzungsverzeichnis} \begin{acronym}[xxxxxxxx] + \acro{BLW}{Bandlaufwerk} + \acro{CISC}{Complex Instruction Set Computer} \acro{CLA-PA}{Carry-Look-Ahead-Paralleladdierer} - \acro{CPU}{central processing unit} + \acro{CPU}{Central Processing Unit} \acro{D-FF}{D-Flip-Flop} \acro{DMF}{Disjunktive Minimalform} \acro{DNF}{Disjunktive Normalform} @@ -49,11 +51,15 @@ \acro{GLZ}{Gatterlaufzeit} \acrodefplural{GLZ}[GLZs]{Gatterlaufzeiten} \acro{HA}{Halbaddierer} + \acro{HS}{Hauptspeicher} + \acro{HSA}{Hauptspeicheradresse} \acro{HW}{Hardware} + \acro{LW}{Laufwerk} \acro{PC}{Personal Computer} \acro{PA}{Paralleladdierer} \acro{PM}{Parallelmultiplizierer} \acro{RC-PA}{Ripple-Carry-Paralleladdierer} + \acro{RISC}{Reduced Instruction Set Computer} \acro{SA}{Serielladdierer} \acro{SR}{Schieberegister} \acro{UNIVAC}{Universal Automatic Computer}