TI2/Rechnerarchitektur-Tutorium, 27.10.2016

Organisatorisches

Kontakt

  • Jonas Cleve
  • jonas.cleve [Klammeraffe] fu-berlin.de
  • Bitte [TI2] oder [RA] an den Anfang des E-Mail-Betreffs schreiben

  • https://page.mi.fu-berlin.de/jonascleve/ss15-ti2/

  • Koordination des Übungsbetriebs: Simon Schmitt (simon.schmitt [Klammeraffe] fu-berlin.de)

Veranstaltung/Modul bestehen

  • 3 Säulen (Klausur, aktive/passive Teilnahme)
  • Klausur
    • Modulnote = Klausurnote
  • passive Teilnahme
    • n-2 Tutorien besuchen
    • Anwesenheitspflicht
  • aktive Teilnahme
    • n-2 Übungszettel bestehen
    • und einmal vorrechnen

Übungszettel

Abgabezyklus
Abgabezyklus
  • Wöchentliche Ausgabe der Zettel
  • 2 Wochen Bearbeitungszeit
  • Abgabe: Freitags 10:15 Uhr
  • Bearbeitung und Abgabe in 2er-Gruppen
  • Namen auf allen Abgaben

Abgabe der Übungszettel

  • Papierabgabe
    • In mein Fach (1. OG)
    • Tackern!
    • Namen und Tutorium (Wochentag) auf der Abgabe
    • Bei Rechercheaufgaben: Quellen angeben
  • Elektronische Abgabe
    • Im KVV hochladen (nur einer aus der Gruppe)
    • Nur notwendige Dateien (in der Regel nur die Assembler-Datei)
    • Nicht gezippt o.ä. sondern direkt hochladen
    • Namen und Tutorium (Wochentag) als Kommentar im Kopf
    • Entwicklung unter 64bit-Linux
    • Programme müssen auf andorra kompilieren und laufen
  • Plagiate: Aberkennung der aktiven Teilnahme

Bewertung der Übungszettel

  • 3-Punkte-System
  • Jeweils 2 Aufgaben pro Zettel
  • Theorie-Aufgaben
    • 1 Punkt: Ansatz zu erkennen
    • 2 Punkte: Gut (nur kleinere Fehler)
    • 3 Punkte: Perfekt / Klausurreif
  • Programmier-Aufgaben
    • 1 Punkt: Ansatz zu erkennen
    • 2 Punkte: Programm kompiliert hat jedoch kleinere Fehler
    • 3 Punkte: Programm kompiliert und erfüllt Aufgabenstellung
  • Jede bewertete Aufgabe: mindestens 1 Punkt
  • Insgesamt: mindestens 3 Punkte

Klausur

  • Klausurtermin steht (meines Wissens) noch nicht fest
  • neue Prüfungsordnung: 120 min Klausur
    • 60 min TI2 / Rechnerarchitektur
    • 60 min TI3 / Betriebs- und Kommunikationssysteme
  • alte Prüfungsordnung: 90 min Klausur
    • TI2-Teil aus der 120min-Klausur + zusätzliche Aufgabe(n)
  • Lehramt, Nebenfach (?): 60 min Klausur
    • TI2-Teil aus der 120min-Klausur
  • Anmeldung im Campus-Management absolut notwendig

Wunschkonzert

  • Läuft im Rahmen des Mentoring-Programms
  • Durchgeführt von Thomas
  • Freitag, 12-14 Uhr
  • Raum: SR 051
  • Beginn: 28.10.2016
  • Konzept:
    • Ihr kommt mit Fragen zum Wunschkonzert
    • Thomas beantwortet eure Fragen
    • Vor allem auch für weitergehende oder Grundlagen-Fragen, die in den Tutorien nicht unbedingt besprochen werden können

Vorlesung

Allgemein

  • Vorlesung befasst sich mit dem theoretischen Teil der Rechnerarchitektur
  • Kein Assembler in der Vorlesung
  • Tutorium: Praktische Umsetzung durch Assembler-Programmierung

Assembler

Simples C-Programm

1
2
3
4
5
6

#include <unistd.h>

int main() {
    write(1, "Hello, World!\n", 14);
    _exit(0);
}

Kompiliert mit gcc -o hello hello.c sieht der Teil der main-Methode so aus:

ba0e000000bef4054000bf01000000
e8c2feffffbf00000000e8a8feffff

Maschinenbefehle

Man kann das Programm auch wieder disassemblieren (mit objdump -M intel-mnemonic -d hello). Der Teil der main-Methode sieht dann folgendermaßen aus:

1
2
3
4
5
6

ba 0e 00 00 00           mov    edx,0xe
be f4 05 40 00           mov    esi,0x4005f4
bf 01 00 00 00           mov    edi,0x1
e8 c2 fe ff ff           call   400420 <write@plt>
bf 00 00 00 00           mov    edi,0x0
e8 a8 fe ff ff           call   400410 <_exit@plt>

Allgemeines

Installation testen

  • Zum Testen, ob nasm funktioniert könnt ihr diese Zip-Datei runterladen:

    jonas@arch ~ti2t % wget https://page.mi.fu-berlin.de/jonascleve/data/download/nasm_test.zip
jonas@arch ~ti2t % unzip nasm_test.zip
Archive:  nasm_test.zip
   creating: nasm_test/
  inflating: nasm_test/hello.asm
  inflating: nasm_test/bar.c
  inflating: nasm_test/foo.asm
  inflating: nasm_test/Makefile
jonas@arch ~ti2t % cd nasm_test
jonas@arch ~ti2t/nasm_test % make all
nasm -f elf64 foo.asm
gcc -o foo foo.o
nasm -f elf64 hello.asm
gcc -o hello hello.o bar.c
jonas@arch ~ti2t/nasm_test % ./foo
Hello, world!
jonas@arch ~ti2t/nasm_test % ./hello
Test Here!
Hello from Assembly!

Vorbesprechung Übungszettel

Erstes Assembler-Programm

Idee

Wir wollen eine kleines Programm schreiben, dass drei Ganzzahlen entgegennimmt und von der Summe der ersten beiden die letzte Zahl abzieht. Also f(a, b, c)=a + b − c.

Wir schreiben ein C-Programm, dass unsere später in Assembler geschrieben Funktion aufruft und das Ergebnis ausgibt.

C-Programm

bar.c:

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>

extern int foo(int, int, int);

int main()
{
    int i = foo(42,1337,2047);
    printf("i hat den Wert: %d\n",i);
    return 0;
}

Bei Ausführung sollte i hat den Wert: -668 herauskommen.

Assembler-Funktion

Eine erste Assembler-Funktion, die nicht macht, was wir wollen, aber wir können es zumindestens ausführen.

foo.asm:

1
2
3
4

section .text ; Jetzt kommt Programmcode
global foo    ; Funktion kann aus C-Programm aufgerufen werden
foo:          ; Hier beginnt die Funktion foo
    ret       ; Beende die Funktion foo

Kompilieren und Ausführen

jonas@arch ~ti2t % nasm -f elf64 foo.asm
jonas@arch ~ti2t % gcc -o run foo.o bar.c
jonas@arch ~ti2t % ./run
i hat den Wert: 4195601

Woher kommt der Wert für i? Lösung: Calling Conventions

“The first six integer […] arguments are passed in registers RDI, RSI, RDX, RCX, R8, and R9 […] and the return value is stored in RAX.”

Etwas vernünftiges zurückgeben

Wir wollen zunächst einen festen Wert zurückgeben:

1
2
3
4
5

section .text
global foo
foo:
    mov rax, 1234 ; Bewege Wert 1234 in das Register rax
    ret
jonas@arch ~ti2t % nasm -f elf64 foo.asm
jonas@arch ~ti2t % gcc -o run foo.o bar.c
jonas@arch ~ti2t % ./run
i hat den Wert: 1234

Etwas vernünftiges zurückgeben

Mit dem Wissen, was in welchem Register steht können wir nun auch die komplette Funktion implementieren:

1
2
3
4
5
6
7

section .text
global foo
foo:
    add rdi, rsi ; rdi = rdi + rsi
    sub rdi, rdx ; rdi = rdi - rdx
    mov rax, rdi ; rax = rdi
    ret
jonas@arch ~ti2t % nasm -f elf64 foo.asm
jonas@arch ~ti2t % gcc -o run foo.o bar.c
jonas@arch ~ti2t % ./run
i hat den Wert: -668