diff --git a/20230517/functions-01-O3.s b/20230517/functions-01-O3.s new file mode 100644 index 0000000000000000000000000000000000000000..24383d1b4cabc383c8e0cf574ddb9a423c3cc23c --- /dev/null +++ b/20230517/functions-01-O3.s @@ -0,0 +1,38 @@ + .file "functions-01.c" + .text + .p2align 4,,15 + .globl sum + .type sum, @function +sum: +.LFB11: + .cfi_startproc + leal (%rdi,%rsi), %eax + ret + .cfi_endproc +.LFE11: + .size sum, .-sum + .section .rodata.str1.1,"aMS",@progbits,1 +.LC0: + .string "c = %d\n" + .section .text.startup,"ax",@progbits + .p2align 4,,15 + .globl main + .type main, @function +main: ; #include <stdio.h> +.LFB12: ; + .cfi_startproc ; int sum (int a, int b) + subq $8, %rsp ; { + .cfi_def_cfa_offset 16 ; return a + b; + movl $10, %esi ; } + leaq .LC0(%rip), %rdi ; + xorl %eax, %eax ; int main (void) + call printf@PLT ; { + xorl %eax, %eax ; int c = sum (3, 7); + addq $8, %rsp ; printf ("c = %d\n", c); + .cfi_def_cfa_offset 8 ; return 0; + ret ; } + .cfi_endproc +.LFE12: + .size main, .-main + .ident "GCC: (Debian 8.3.0-6) 8.3.0" + .section .note.GNU-stack,"",@progbits diff --git a/20230517/functions-01.c b/20230517/functions-01.c new file mode 100644 index 0000000000000000000000000000000000000000..ee59b3fafaf0801c6249fc4039530b3a1c54b1b6 --- /dev/null +++ b/20230517/functions-01.c @@ -0,0 +1,13 @@ +#include <stdio.h> + +int sum (int a, int b) +{ + return a + b; +} + +int main (void) +{ + int c = sum (3, 7); + printf ("c = %d\n", c); + return 0; +} diff --git a/20230517/functions-01.s b/20230517/functions-01.s new file mode 100644 index 0000000000000000000000000000000000000000..2604b090a2e777632aa2331bc9360e207473ec19 --- /dev/null +++ b/20230517/functions-01.s @@ -0,0 +1,56 @@ + .file "functions-01.c" + .text + .globl sum + .type sum, @function +sum: +.LFB0: + .cfi_startproc + pushq %rbp + .cfi_def_cfa_offset 16 + .cfi_offset 6, -16 + movq %rsp, %rbp + .cfi_def_cfa_register 6 + movl %edi, -4(%rbp) + movl %esi, -8(%rbp) + movl -4(%rbp), %edx + movl -8(%rbp), %eax + addl %edx, %eax + popq %rbp + .cfi_def_cfa 7, 8 ; #include <stdio.h> + ret ; + .cfi_endproc ; int sum (int a, int b) +.LFE0: ; { + .size sum, .-sum ; return a + b; + .section .rodata ; } +.LC0: ; + .string "c = %d\n" ; int main (void) + .text ; { + .globl main ; int c = sum (3, 7); + .type main, @function ; printf ("c = %d\n", c); +main: ; return 0; +.LFB1: ; } + .cfi_startproc + pushq %rbp + .cfi_def_cfa_offset 16 + .cfi_offset 6, -16 + movq %rsp, %rbp + .cfi_def_cfa_register 6 + subq $16, %rsp + movl $7, %esi + movl $3, %edi + call sum + movl %eax, -4(%rbp) + movl -4(%rbp), %eax + movl %eax, %esi + leaq .LC0(%rip), %rdi + movl $0, %eax + call printf@PLT + movl $0, %eax + leave + .cfi_def_cfa 7, 8 + ret + .cfi_endproc +.LFE1: + .size main, .-main + .ident "GCC: (Debian 8.3.0-6) 8.3.0" + .section .note.GNU-stack,"",@progbits diff --git a/20230517/logo-hochschule-bochum-cvh-text-v2.pdf b/20230517/logo-hochschule-bochum-cvh-text-v2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8 --- /dev/null +++ b/20230517/logo-hochschule-bochum-cvh-text-v2.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum-cvh-text-v2.pdf \ No newline at end of file diff --git a/20230517/logo-hochschule-bochum.pdf b/20230517/logo-hochschule-bochum.pdf new file mode 120000 index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1 --- /dev/null +++ b/20230517/logo-hochschule-bochum.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum.pdf \ No newline at end of file diff --git a/20230517/pgslides.sty b/20230517/pgslides.sty new file mode 120000 index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64 --- /dev/null +++ b/20230517/pgslides.sty @@ -0,0 +1 @@ +../common/pgslides.sty \ No newline at end of file diff --git a/20230517/rtech-20230517.pdf b/20230517/rtech-20230517.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4745240253be6ca10e88b4de2cde2b6fdf961695 Binary files /dev/null and b/20230517/rtech-20230517.pdf differ diff --git a/20230517/rtech-20230517.tex b/20230517/rtech-20230517.tex new file mode 100644 index 0000000000000000000000000000000000000000..31035b20a80b504ee8c41c894085326ea63988bb --- /dev/null +++ b/20230517/rtech-20230517.tex @@ -0,0 +1,1081 @@ +% rtech-20230517.pdf - Lecture Slides on Computer Technology +% Copyright (C) 2012, 2013, 2014, 2021, 2022, 2023 Peter Gerwinski +% +% This document is free software: you can redistribute it and/or +% modify it either under the terms of the Creative Commons +% Attribution-ShareAlike 3.0 License, or under the terms of the +% GNU General Public License as published by the Free Software +% Foundation, either version 3 of the License, or (at your option) +% any later version. +% +% This document is distributed in the hope that it will be useful, +% but WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +% GNU General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this document. If not, see <http://www.gnu.org/licenses/>. +% +% You should have received a copy of the Creative Commons +% Attribution-ShareAlike 3.0 Unported License along with this +% document. If not, see <http://creativecommons.org/licenses/>. + +% README: Assembler-Programmierung: Redcode (Fortsetzung) + +\documentclass[10pt,t]{beamer} + +\usepackage{pgslides} +\usepackage{pdftricks} +%\usepackage[obeyfamily=false,mathrm=mathsf,textrm=sffamily]{siunitx} +%\usepackage{eurosym} +\usepackage{tikz} + +\newcommand{\Cin}{C\raisebox{-0.5ex}{\footnotesize in}} +\newcommand{\Cout}{C\raisebox{-0.5ex}{\footnotesize out}} + +\lstdefinestyle{asm}{basicstyle=\color{structure}, + language={}, + gobble=4} + +\begin{psinputs} + \usepackage[utf8]{inputenc} + \usepackage[german]{babel} + \usepackage[T1]{fontenc} + \usepackage{helvet} + \renewcommand*\familydefault{\sfdefault} + \usepackage{pstricks,pst-grad,pst-circ-pg} + \newcommand{\invisible}{\tiny\color{white}} + \psset{unit=1cm} + \psset{logicLabelstyle=\invisible} + \newcommand{\logicSymbol}{\small\boldmath\bf\rule{0pt}{0.5cm}} + \psset{logicSymbolstyle=\logicSymbol} + \newcommand{\Cin}{C\raisebox{-0.5ex}{\footnotesize in}} + \newcommand{\Cout}{C\raisebox{-0.5ex}{\footnotesize out}} +\end{psinputs} + +\title{Rechnertechnik} +\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski} +\date{17.\ Mai 2022} + +\begin{document} + +\maketitleframe + +\nosectionnonumber{\inserttitle} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer} + \item[\textbf{3}] \textbf{Assember-Programmierung} + \begin{itemize} + \color{medgreen} + \item[3.1] Struktur von Assembler-Programmen + \item[3.2] Beispiel: Redcode + \item[\dots] + \end{itemize} +% \color{gray} +% \item[\textbf{3}] \textbf{Architekturmerkmale von Prozessoren} +% \item[\textbf{4}] \textbf{Der CPU-Stack} +% \item[\textbf{5}] \textbf{Hardwarenahe Programmierung} +% \item[\textbf{6}] \textbf{Anwender-Software} +% \item[\textbf{7}] \textbf{Bus-Systeme} +% \item[\textbf{8}] \textbf{Pipelining} +% \item[\textbf{9}] \textbf{Ausblick} + \item[\textbf{\dots\hspace{-0.75em}}] + \end{itemize} + +\end{frame} + +\setcounter{section}{2} +\section{Assembler-Programmierung} +\subsection{Struktur von Assembler-Programmen} + +\begin{frame} + \showsection + \showsubsection + + \textbf{Maschinensprache:} Bits besagen, was in diesem Takt geschehen soll + + \begin{itemize} + \item + \textbf{arithmetisch-logische Befehle:}\\[\smallskipamount] + Daten aus Registern (oder Hauptspeicher) an ALU legen,\\ + Ergebnis in Register (oder Hauptspeicher) schreiben + \item + \textbf{Lade- und Speicher-Befehle:}\\[\smallskipamount] + Daten aus dem Hauptspeicher in Register einlesen\\ + oder aus Register in den Hauptspeicher schreiben + \item + \textbf{(unbedingter) Sprungbefehl:}\\[\smallskipamount] + Daten aus Register oder Hauptspeicher in das \lstinline{IP}-Register laden + \item + \textbf{(bedingter) Sprungbefehl:}\\[\smallskipamount] + Sprungbefehl nur dann, wenn im Status-Ausgang der ALU\\ + ein bestimmtes Bit gesetzt ist + \bigskip + \arrowitem + Der Computer kann "`alles"' -- \newterm{Turing-Vollständigkeit} + \end{itemize} +\end{frame} + +\begin{frame} + + \showsection + \showsubsection + + \textbf{Maschinensprache:} Bits besagen, was in diesem Takt geschehen soll + \begin{itemize} + \item + Lade- und Speicher-Befehle\\ + arithmetisch-logische Befehle\\ + unbedingte und bedingte Sprungbefehle + \arrowitem + Der Computer kann "`alles"' -- \newterm{Turing-Vollständigkeit} + \end{itemize} + + \medskip + + \textbf{\newterm{Assembler\/}-Sprache} + \begin{itemize} + \item + Maschinensprache = Zahlen \textarrow\ für Menschen schwer handhabbar + \arrowitem + Namen für die Befehle: \newterm{Mnemonics} + \end{itemize} + +% \pause + \medskip + + \textbf{Beispiele} + \begin{itemize} + \item + Intel 8086 \textcolor{red}{(emulierter 16-Bit-Rechner)} + \item + Atmel AVR \textcolor{red}{(Arduino, 8 Bit)} + \item + Intel IA-32 / AMD64 \textcolor{red}{(Notebook-PC, 64 Bit)} + \item + Redcode \textcolor{red}{(emulierter Rechner, Praktikumsversuch)} + \end{itemize} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Beispiel: IA-32-Assembler + \only<1>{-- \newterm{Befehl (Opcode)}}% + \only<2>{-- \newterm{Befehl (Opcode)} und \newterm{Operanden}}% + \only<3>{-- \newterm{Adressierungsarten}} + + \vspace{2cm} + + \begin{lstlisting} + addl $1, %eax + movb %al, b + cmpb (%ebx), %dl + jbe .L2 + \end{lstlisting} + + \begin{onlyenv}<1-2> + \begin{picture}(0,0) + \color{red} + \put(0.4,2.8){\vector(0,-1){0.7}} + \put(0.4,2.9){\makebox(0,0)[b]{Befehl}} + \only<1>{% + \put(1.4,2.8){\vector(-1,-1){0.7}} + \put(2.3,2.9){\makebox(0,0)[b]{Größen-Suffix}}} + \only<2>{% + \put(1.4,2.8){\vector(-1,-2){0.35}} + \put(1.4,2.8){\vector(1,-2){0.35}} + \put(2.0,2.9){\makebox(0,0)[b]{Operanden}}} + \end{picture} + \end{onlyenv} + \begin{onlyenv}<3> + \begin{picture}(0,0) + \color{red} + \put(1.4,2.8){\vector(-1,-2){0.35}} + \put(2.0,2.9){\makebox(0,0)[b]{unmittelbar}} + \put(3.0,1.8){\vector(-1,0){0.7}} + \put(3.1,1.8){\makebox(0,0)[l]{Register}} + \put(4.8,1.4){\vector(-1,0){2.7}} + \put(4.9,1.4){\makebox(0,0)[l]{Speicher (absolut)}} + \put(2.3,-0.0){\vector(-1,1){0.7}} + \put(3.5,-0.1){\makebox(0,0)[t]{indirekt mit Register}} + \put(0.8,-0.6){\vector(0,1){0.9}} + \put(0.0,-0.7){\makebox(0,0)[tl]{Speicher (relativ)}} + \end{picture} + \end{onlyenv} + +\end{frame} + +\subsection{Beispiel: Redcode} + +\begin{frame}[fragile] + + \showsubsection + + Beispiel: Redcode (ICWS '86) -- Core War[s] (Krieg der Kerne)\\ + Virtuelle Maschine: Memory Array Redcode Simulator (MARS) + + \bigskip + + \begin{minipage}[t]{7.2cm} + Instruktionen:\\[\smallskipamount] + \lstinline{dat B} -- Daten \only<1->{-- "`Du hast verloren!"'}\\ + \lstinline{mov A, B} -- kopiere A nach B\\ + \lstinline{add A, B} -- addiere A zu B\\ + \lstinline{sub A, B} -- subtrahiere A von B\\ + \lstinline{jmp A} -- unbedingter Sprung nach A\\ + \lstinline{jmz A, B} -- Sprung nach A, wenn B $=$ 0\\ + \lstinline{jmn A, B} -- Sprung nach A, wenn B $\ne$ 0\\ + \lstinline{djn A, B} -- "`decrement and jump if not zero"'\\ + \lstinline{cmp A, B} -- "`compare"': überspringe, falls gleich\\ + \lstinline{spl A} -- "`split"': Programm verzweigen + \end{minipage}\hfill + \begin{minipage}[t]{4.7cm} + Adressierungsarten:\\[\smallskipamount] + grundsätzlich: Speicher relativ\\[\smallskipamount] + \lstinline{#} -- unmittelbar\\ + \lstinline{$} -- direkt\\ + \lstinline{@} -- indirekt\\ + \lstinline{<} -- indirekt mit Prä-Dekrement + +% \pause[5] + \bigskip + Programm "`Nothing"': + \begin{lstlisting}[gobble=6] + jmp 0 + \end{lstlisting} +% \pause + \bigskip + Programm "`Knirps"': + \begin{lstlisting}[gobble=6] + mov 0, 1 + \end{lstlisting} + \smallskip + \textcolor{red}{Wie schreibt man\\knirpsresistente Programme?} + + \end{minipage} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Unbedingte Verzweigung + + Beispiel: Endlosschleife von "`Dwarf"' + + \begin{minipage}[t]{1.2cm} + \begin{lstlisting}[style=asm,gobble=6] + bomb + start + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3cm} + \begin{lstlisting}[style=asm,gobble=6] + dat #0 + add #4, bomb + mov bomb, @bomb + jmp start + end start + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{3.9cm} + \small + \bigskip + Instruktionen:\\[\smallskipamount] + \lstinline{dat B}\\ + \lstinline{mov A, B}\\ + \lstinline{add A, B}\\ + \lstinline{sub A, B}\\ + \lstinline{jmp A}\\ + \lstinline{jmz A, B} -- "`jump if zero"'\\ + \lstinline{jmn A, B} -- "`if not zero"'\\ + \lstinline{djn A, B} -- "`dec. \& jmn"'\\ + \lstinline{cmp A, B} -- vgl.\ \& überspr.\\ + \lstinline{spl A} -- verzweigen + \end{minipage}% + \begin{minipage}[t]{2.7cm} + \small + \bigskip + Adressierungsarten:\\[\medskipamount] + grundsätzlich:\\ + Speicher relativ\\[\medskipamount] + \lstinline{#} -- unmittelbar\\[\smallskipamount] + \lstinline{$} -- direkt\\[\smallskipamount] + \lstinline{@} -- indirekt\\[\smallskipamount] + \lstinline{<} -- indirekt mit\\ + \hspace*{0.52cm}Prä-Decrement + \end{minipage} + +% \pause + \bigskip + + Problem: Wenn die Speichergröße nicht durch 4 teilbar ist,\\ + \phantom{Problem: }bringt "`Dwarf"' sich selbst zum Absturz.\\[\smallskipamount] +% \pause + Lösung: \textcolor{red}{Haben Sie Ideen?} + \textcolor{red}{\textarrow\ Übungsaufgabe} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + \alt<2->{Mehrere Threads}{Bedingte Verzweigung} + + Beispiel: \alt<2->{Multithreading}{Kopierschleife} von "`Mice"' + + \begin{minipage}[t]{1.2cm} + \begin{lstlisting}[style=asm,gobble=6] + ptr + start + loop + + + + + dest + + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3cm} + \begin{lstlisting}[style=asm,gobble=6] + dat #0 + mov #12, ptr + mov @ptr, <dest + djn loop, ptr + spl @dest + add #653, dest + jmz start, ptr + dat #833 + end start + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{3.9cm} + \small + \bigskip + Instruktionen:\\[\smallskipamount] + \lstinline{dat B}\\ + \lstinline{mov A, B}\\ + \lstinline{add A, B}\\ + \lstinline{sub A, B}\\ + \lstinline{jmp A}\\ + \lstinline{jmz A, B} -- "`jump if zero"'\\ + \lstinline{jmn A, B} -- "`if not zero"'\\ + \lstinline{djn A, B} -- "`dec. \& jmn"'\\ + \lstinline{cmp A, B} -- vgl.\ \& überspr.\\ + \lstinline{spl A} -- verzweigen + \end{minipage}% + \begin{minipage}[t]{2.7cm} + \small + \bigskip + Adressierungsarten:\\[\medskipamount] + grundsätzlich:\\ + Speicher relativ\\[\medskipamount] + \lstinline{#} -- unmittelbar\\[\smallskipamount] + \lstinline{$} -- direkt\\[\smallskipamount] + \lstinline{@} -- indirekt\\[\smallskipamount] + \lstinline{<} -- indirekt mit\\ + \hspace*{0.52cm}Prä-Decrement + \end{minipage} + + \pause[3] + \bigskip + + Gegenmaßnahme: "`Zeitfalle"'\\ + \textarrow\ Programm "`Catcan"' + +% \smallskip +% +% Problem: Wenn die Speichergröße nicht durch 8 teilbar ist,\\ +% \phantom{Problem: }bringt "`Catcan"' sich selbst zum Absturz. + +\end{frame} + +\iffalse + +\begin{frame}[fragile] + + \showsubsection + + Selbstmodifizierender Code + + Beispiel: Selbsterkennung von "`Fini"' + + \begin{minipage}[t]{1.2cm} + \begin{lstlisting}[language={},gobble=6] + num + start + + pos + + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{0.9cm} + \begin{lstlisting}[language={},gobble=6] + dat #-2 + mov num, <pos + jmp start + dat #-3 + end start + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{3.9cm} + \small + \bigskip + Instruktionen:\\[\smallskipamount] + \lstinline{dat B}\\ + \lstinline{mov A, B}\\ + \lstinline{add A, B}\\ + \lstinline{sub A, B}\\ + \lstinline{jmp A}\\ + \lstinline{jmz A, B} -- "`jump if zero"'\\ + \lstinline{jmn A, B} -- "`if not zero"'\\ + \lstinline{djn A, B} -- "`dec. \& jmn"'\\ + \lstinline{cmp A, B} -- vgl.\ \& überspr.\\ + \lstinline{spl A} -- verzweigen + \end{minipage}% + \begin{minipage}[t]{2.7cm} + \small + \bigskip + Adressierungsarten:\\[\medskipamount] + grundsätzlich:\\ + Speicher relativ\\[\medskipamount] + \lstinline{#} -- unmittelbar\\[\smallskipamount] + \lstinline{$} -- direkt\\[\smallskipamount] + \lstinline{@} -- indirekt\\[\smallskipamount] + \lstinline{<} -- indirekt mit\\ + \hspace*{0.52cm}Prä-Decrement + \end{minipage} + +\end{frame} + +\fi + +\begin{frame}[fragile] + + \showsubsection + + \strut + + \strut\makebox(0,0)[bl]{\large\color{structure}\textbf{Praktikumsversuch}} + + \begin{minipage}[t]{5cm} + \medskip + Schreiben Sie ein\\ + Redcode-Programm,\\ + das die Gegner\\ + \file{Nothing}, \file{Knirps}\\ + und \file{Mice} besiegt. + + \medskip + + ICWS-86-Standard,\\ + max.\ 64 Prozesse,\\ + Speichergröße zufällig\\ + von 512 bis 8192 + + \medskip + + Teams bis zu 3 Personen\\ + sind zulässig. + \end{minipage}\hfill + \begin{minipage}[t]{3.9cm} + \small + \bigskip + Instruktionen:\\[\smallskipamount] + \lstinline{dat B}\\ + \lstinline{mov A, B}\\ + \lstinline{add A, B}\\ + \lstinline{sub A, B}\\ + \lstinline{jmp A}\\ + \lstinline{jmz A, B} -- "`jump if zero"'\\ + \lstinline{jmn A, B} -- "`if not zero"'\\ + \lstinline{djn A, B} -- "`dec. \& jmn"'\\ + \lstinline{cmp A, B} -- vgl.\ \& überspr.\\ + \lstinline{spl A} -- verzweigen + \end{minipage}% + \begin{minipage}[t]{2.7cm} + \small + \bigskip + Adressierungsarten:\\[\medskipamount] + grundsätzlich:\\ + Speicher relativ\\[\medskipamount] + \lstinline{#} -- unmittelbar\\[\smallskipamount] + \lstinline{$} -- direkt\\[\smallskipamount] + \lstinline{@} -- indirekt\\[\smallskipamount] + \lstinline{<} -- indirekt mit\\ + \hspace*{0.52cm}Prä-Decrement + \end{minipage} + +\end{frame} + +\subsection{Architekturmerkmale von Prozessoren} +\subsubsection{Speicherarchitekturen} + +\begin{frame} + + \showsubsection + + Oder: Jede Assembler-Sprache ist anders. + + \bigskip + + \showsubsubsection + + Bezeichnungen + \begin{itemize} + \item + \newterm{Bit\/} = 0 oder 1 -- kleinste Einheit an Information + \item + \newterm{Byte\/} = Zusammenfassung mehrerer \newterm{Bits}\\ + zu einer Binärzahl, die ein Zeichen (\newterm{Character\/}) darstellen kann,\\ + häufig 8 Bits (\newterm{Oktett\/}) + \item + \newterm{Speicherwort\/} = Zusammenfassung mehrerer Bits\\ + zu der kleinsten adressierbaren Einheit, häufig 1 Byte + \item + \newterm{RAM\/} = \newterm{Random Access Memory\/} = Hauptspeicher + \item + \newterm{ROM\/} = \newterm{Read Only Memory\/} = nur lesbarer Speicher + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsubsection + + Verschiedene Arten von Speicher + \begin{itemize} + \item + \newterm{Prozessor-Register}\\ + können direkt mit ALU verbunden werden,\\ + besonders schnell (Flipflops),\\ + überschaubare Anzahl von Registern + \item + \newterm{Hauptspeicher}\\ + kann direkt adressiert und mit Prozessor-Registern abgeglichen werden,\\ + heute i.\,d.\,R.\ dynamischer Speicher (Kondensatoren) + \item + \newterm{I/O-Ports}\\ + sind spezielle Speicheradressen, über die\\ + mit externen Geräten kommuniziert wird + \item + \newterm{Massenspeicher}\\ + liegt auf externem Gerät, wird über I/O-Ports angesprochen,\\ + Festplatte, Flash-Speicher, \dots + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsubsubsection + + \begin{itemize} + \item + \newterm{Von-Neumann-Architektur}\\ + Es gibt nur 1 Hauptspeicher, in dem sich sowohl die Befehle\\ + als auch die Daten befinden. + + \begin{onlyenv}<1> + \smallskip + + Vorteil: Flexibilität in der Speichernutzung + + Nachteil: Befehle können überschrieben werden.\\ + $\longrightarrow$ Abstürze und Malware möglich + \end{onlyenv} + + \pause + \item + \newterm{Harvard-Architektur}\\ + Es gibt 2 Hauptspeicher. In einem befinden sich die Befehle,\\ + im anderen die Daten. + + \begin{onlyenv}<2> + \smallskip + + Vorteil: Befehle können nicht überschrieben werden\\ + $\longrightarrow$ sicherer als Von-Neumann-Architektur + + Nachteile: Leitungen zum Speicher (Bus) müssen doppelt vorhanden sein,\\ + freier Befehlsspeicher kann nicht für Daten genutzt werden. + \end{onlyenv} + + \pause + \item + Weitere Kombinationen\\ + Hauptspeicher und I/O-Ports gemeinsam oder getrennt,\\ + Hauptspeicher und Prozessorregister gemeinsam oder getrennt + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsubsubsection + + Beispiele: + \begin{itemize} + \item + Intel IA-32, AMD64:\\ + Von-Neumann-Architektur (plus Speicherschutzmechanismen),\\ + Prozessorregister und I/O-Ports vom Hauptspeicher getrennt + \item + Atmel AVR (z.\,B.\ ATmega):\\ + Harvard-Architektur (Befehlsspeicher als Flash-Speicher grundsätzlich auch schreibbar),\\ + Prozessorregister und I/O-Ports in gemeinsamem Adressbereich mit Hauptspeicher + \item + 6502, Renesas-Mikro-Controller:\\ + Von-Neumann-Architektur,\\ + I/O-Ports in gemeinsamem Adressbereich mit Hauptspeicher,\\ + Prozessorregister und Hauptspeicher getrennt + \end{itemize} + +\end{frame} + +\subsubsection{Registerarchitekturen} + +\begin{frame}[fragile] + + \showsubsubsection + + \vspace*{-\medskipamount} + + \begin{itemize} + \item + Mehrere Register, einzeln ansprechbar + \item + \newterm{Akkumulator\/}: Nur 1 Register kann rechnen. + \item + \newterm{Stack-Architektur\/}: Stapel, "`umgekehrte Polnische Notation"' + \end{itemize} + + \pause + + Operationen: typischerweise nur + \lstinline{=}, \lstinline{+=}, \lstinline{-=}, \lstinline{*=}, \lstinline{/=}, \dots + + \pause + \medskip + + Beispiel: \lstinline{c = a + 2 * b;} + + \pause + \medskip + + \begin{minipage}[t]{2cm} + C, Java:\smallskip\par + \begin{lstlisting}[gobble=6] + R = b; + R *= 2; + R += a; + c = R; + \end{lstlisting} + \end{minipage}\pause + \begin{minipage}[t]{4cm} + Mehrere Register:\smallskip\par + \begin{lstlisting}[style=asm,gobble=6] + movl (b), %eax + imull $2, %eax, %eax + addl (a), %eax + movl %eax, (c) + \end{lstlisting} + \smallskip\par + (IA-32-Assembler) + \end{minipage}\pause + \begin{minipage}[t]{3cm} + Akkumulator:\smallskip\par + \begin{lstlisting}[style=asm,gobble=6] + load (b) + mul $2 + add (a) + store (c) + \end{lstlisting} + \smallskip\par + (Pseudo-Assembler) + \end{minipage}\pause + \begin{minipage}[t]{3cm} + Register-Stack:\smallskip\par + \begin{lstlisting}[style=asm,gobble=6] + push (a) + push (b) + push $2 + mul + add + pop (c) + \end{lstlisting} + \end{minipage} + +\end{frame} + +\begin{frame} + + \showsubsubsection + + Beispiele: + \begin{itemize} + \item + Intel IA-32, AMD64:\\ + Mehrere Register, für verschiedene Zwecke spezialisiert (unübersichtlich),\\[\smallskipamount] + Fließkommaregister: Stack-Architektur + \item + Atmel AVR (z.\,B.\ ATmega):\\ + 32 Register + \item + 6502, Renesas-Mikro-Controller:\\ + 3 Register: A, X, Y. Nur A kann rechnen $\longrightarrow$ Akkumulator + \item + Java Virtual Machine (JVM):\\ + Stack-Architektur + \item + Redcode:\\ + Jede Speicherzelle fungiert als Register + \end{itemize} + +\end{frame} + +\subsubsection{Befehlssätze} + +\begin{frame} + + \showsubsubsection + + \begin{itemize} + \item + \newterm{Reduced Instruction Set Computer (RISC)} + + \smallskip + + wenige, wenig mächtige Befehle + + \begin{onlyenv}<1> + \textarrow\ Programmierung in Assembler für Menschen unkomfortabel\\ + \textarrow\ schnelle Abarbeitung der Befehle + + \medskip + + Beispiel: Atmel AVR + \begin{itemize} + \item + Der ``load immediate''-Befehl funktioniert nur + für die Register 16 bis 31,\\ + nicht für die Register 0 bis 15. + \item + Die meisten Befehle werden in nur 1 Taktzyklus abgearbeitet. + \end{itemize} + + \medskip + + Beispiel: Redcode ICWS-86 + \begin{itemize} + \item + Es gibt indirekte Adressierung mit Prä-Dekrement,\\ + aber nicht mit Prä-Inkrement. + \item + Alle Befehle werden in nur 1 Taktzyklus abgearbeitet. + \end{itemize} + \end{onlyenv} + + \pause + \medskip + \item + \newterm{Complex Instruction Set Computer (CISC)} + + \smallskip + + Umfangreiche Befehlssätze, mächtige Befehle + + \begin{onlyenv}<2> + \textarrow\ komfortable manuelle Programmierung in Assembler\\ + \textarrow\ längere Abarbeitungszeit der einzelnen Befehle + + \smallskip + + Realisierung: "`Prozessor im Prozessor"' -- \newterm{Mikroprogramme} + + \medskip + + Beispiel: Intel IA-32, AMD64 + \begin{itemize} + \item + Es gibt spezielle Befehle für BCD- und String-Operationen. + \item + Befehle benötigen meistens 2 oder mehr,\\ + gelegentlich (z.\,B.\ Fließkomma-Operationen) auch über 100 Taktzyklen. + \end{itemize} + \end{onlyenv} + + \medskip + \pause + \item + \newterm{Very Long Instruction Word (VLIW)\/} und\\ + \newterm{Explicitly Parallel Instruction Computing (EPIC)} + + \smallskip + + mehrere Befehle gleichzeitig ausführbar + + \begin{onlyenv}<3> + \textarrow\ mehr Rechenleistung möglich\\ + \textarrow\ Programmierung sehr aufwendig + + \medskip + + Beispiel: Intel IA-64 + \end{onlyenv} + + \pause + \medskip + \item + \newterm{Orthogonaler Befehlssatz} + + \smallskip + + Jeder Befehl ist mit jeder Adressierungsart kombinierbar. + + \medskip + + Beispiel: Redcode + \end{itemize} + \vspace*{-4cm} + +\end{frame} + +\subsection{Der CPU-Stack\label{CPU-Stack}} +\addtocounter{subsection}{-1} +\subsubsection{Was ist ein Stack?} + +\begin{frame}[fragile] + + \showsubsection + \showsubsubsection + + \bigskip + +\iffalse + + \begin{minipage}[b]{6cm} + \begin{center} + "`First In -- First Out"' + + \bigskip + + \begin{picture}(6,4) + \thicklines + \color{structure} + \put(0.5,0){\line(1,0){5}} + + \put(3.5,0){\only<1-5>{\line(0,1){1}}} + \put(4.5,0){\only<1-4>{\line(0,1){1}}} + \put(3.5,1){\only<1-4>{\line(1,0){1}}} + \put(4.0,0.5){\only<1-4>{\makebox(0,0){\lstinline{3}}}} + \put(3.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}} + \put(3.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}} + + \put(2.5,0){\only<2-6>{\line(0,1){1}}} + \put(2.5,1){\only<2-5>{\line(1,0){1}}} + \put(3.0,0.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}} + \put(2.0,1.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}} + \put(2.0,1.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}} + + \put(1.5,0){\only<3-6>{\line(0,1){1}}} + \put(1.5,1){\only<3-6>{\line(1,0){1}}} + \put(2.0,0.5){\only<3-6>{\makebox(0,0){\lstinline{137}}}} + \put(1.0,1.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}} + \put(1.0,1.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}} + + \put(4.55,1.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}} + \put(5.00,1.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}} + + \put(3.55,1.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}} + \put(4.00,1.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}} + + \put(2.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}} + \put(3.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}} + \end{picture} + + \bigskip + + FIFO = Queue = Reihe + \end{center} + \end{minipage}\hfill + +\fi + + \begin{minipage}[b]{6cm} + \begin{center} + "`Last In -- First Out"' + + \bigskip + + \begin{picture}(6,4) + \thicklines + \color{structure} + \put(1.5,0){\line(1,0){3}} + + \put(2.5,0){\line(0,1){1}} + \put(3.5,0){\line(0,1){1}} + \put(2.5,1){\line(1,0){1}} + \put(3.0,0.5){\makebox(0,0){\lstinline{3}}} + \put(2.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}} + \put(2.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}} + + \put(2.5,1){\only<2-5>{\line(0,1){1}}} + \put(3.5,1){\only<2-5>{\line(0,1){1}}} + \put(2.5,2){\only<2-5>{\line(1,0){1}}} + \put(3.0,1.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}} + \put(2.0,2.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}} + \put(2.0,2.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}} + + \put(2.5,2){\only<3-4>{\line(0,1){1}}} + \put(3.5,2){\only<3-4>{\line(0,1){1}}} + \put(2.5,3){\only<3-4>{\line(1,0){1}}} + \put(3.0,2.5){\only<3-4>{\makebox(0,0){\lstinline{137}}}} + \put(2.0,3.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}} + \put(2.0,3.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}} + + \put(3.55,3.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}} + \put(4.00,3.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}} + + \put(3.55,2.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}} + \put(4.00,2.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}} + + \put(3.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}} + \put(4.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}} + \end{picture} + + \bigskip + + LIFO = Stack = Stapel + \end{center} + \end{minipage} + +% +% \dots + +\end{frame} +\subsubsection{Implementierung} + +\begin{frame} + + \showsubsection + \showsubsubsection + + Speicher, in dem Werte "`gestapelt"' werden: \newterm{Stack} + + \begin{itemize} + \item + Speicherbereich (ein array) reservieren + \item + Variable (typischerweise: Prozessorregister) als + \newterm{Stack Pointer\/} reservieren \textarrow\ \lstinline{SP} + \item + Assembler-Befehl \lstinline[style=asm]{push foo}: \quad + \lstinline{*SP++ = foo;} + \begin{itemize} + \item + In der Speicherzelle, + auf die der Stack Pointer \lstinline{SP} gerade zeigt,\\ + den Wert \lstinline{foo} speichern. + \item + Danach den Stack Pointer inkrementieren (um 1 erhöhen). + \end{itemize} + \item + Assembler-Befehl \lstinline[style=asm]{pop bar}: \quad + \lstinline{bar = *--SP;} + \begin{itemize} + \item + Zuerst den Stack Pointer dekrementieren (um 1 erniedrigen). + \item + Danach aus der Speicherzelle,\\ + auf die der Stack Pointer \lstinline{SP} gerade zeigt,\\ + einen Wert lesen und in der Variablen \lstinline{bar} speichern. + \end{itemize} + \end{itemize} + + \pause + \medskip + Speziell: Unterprogramme + +\end{frame} + +\subsubsection{Unterprogramme} + +\begin{frame}[fragile] + + \showsubsection + \showsubsubsection + + \begin{minipage}[t]{4.5cm} + Parameter: + \begin{itemize} + \item + Prozessorregister + \item + CPU-Stack + \end{itemize} + + \smallskip + + Rückgabewert: + \begin{itemize} + \item + Prozessorregister + \end{itemize} + \end{minipage}% + \begin{minipage}[t]{5cm} + Aufruf: + \begin{itemize} + \item + \lstinline[style=asm]{push IP}\\ + \lstinline[style=asm]{jmp foo} + {\color{red}\boldmath $\longleftarrow$ mov \#foo IP}\\ + \textarrow\ \lstinline[style=asm]{call foo} + \end{itemize} + Rücksprung: + \begin{itemize} + \item + \lstinline[style=asm]{pop IP}\\ + \textarrow\ \lstinline[style=asm]{ret} + \end{itemize} + \end{minipage} + +\end{frame} + +\iffalse + +\subsubsection{Register sichern} + +\begin{frame} + + \showsubsection + \showsubsubsection + + Ein Unterprogramm verändert Registerinhalte. + \begin{itemize} + \item + im Hauptprogramm nötigenfalls vor Aufruf sichern + \item + im Unterprogramm vor Benutzung sichern + \item + Kombinationen (manche Register so, manche so) + \end{itemize} + +\end{frame} + +\fi + +\end{document} diff --git a/20230517/rtech-20230517.txt b/20230517/rtech-20230517.txt new file mode 100644 index 0000000000000000000000000000000000000000..13efd31ab2cbcfbbe17eeeb8b2af37e69a12976a --- /dev/null +++ b/20230517/rtech-20230517.txt @@ -0,0 +1,10 @@ +Binär codiertes Dezimalsystem (BCD), 17.05.2023, 11:27:10 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Speicherzellen (hexadezimal): 0123 +--> dezimal: 1 · 256 + 2 · 16 + 3 = 291 + +komfortabler zum Lesen: Interpretation als Dezimalzahl 123 +--> Jede Hex-Ziffer wird als Dezimalziffer interpretiert. +--> bequem zu lesen (im Debugger) + bequem für die Ausgabe (z.B. beim Drucken)