4 - Virtuelle Maschinen [ID:10978]
50 von 707 angezeigt

Die Technik läuft, wird er in der Maschine, gibt es Fragen.

Dann hacken wir heute noch weiter, was Assembler-Programmierung angeht.

Ihr habt letztes Mal gesehen, wenn man eine virtuelle Maschine schreibt, muss man Assembler-Instruktionen nachsimulieren.

Ein Teil davon müsstet ihr gehabt haben in GAA.

Ihr macht das besser in der Übungsaufgabe.

Es war definitiv zu wenig für das, was wir hier brauchen.

Ihr müsst natürlich wissen, wie das Kodiertes und das Carrybit berechnet ist.

Was wir hier am Anfang machen, ist Intel, AMD, Xyrex und so weiter.

Einmal die Assembler-Programmierung an sich.

Was man noch dazu wissen muss, sind Geschichten mit Interrupts, Trebs oder Exceptions, wie auch man man sie nennt.

Was wir nicht machen, sind die MMX, SSE und sonstige Erweiterungen.

Wer Lust hat, kann es alles gerne machen.

Wir machen es nur in 32-bit bzw. protected-Modus.

Warum mache ich es erst einmal und ausführlich für Intel?

Die meisten virtuellen Maschinen sind die, die Intel Prozessor nachmachen.

Man hat eine Maschine, wo man mal gucken kann, wie das Ding funktioniert.

Ihr werdet es noch merken, wenn man das Manual vor die Nase kriegt und da mal liest, was die Additionen macht.

Das meiste kann man sich denken, was eine Addition tut.

Aber wenn ich euch frage, wie ist das Overflow-Flag bei der Addition gesetzt?

Dann ist es so eindeutig nicht mehr.

Wenn man sich die Manuals anguckt, steht da zwar was drin.

Im Intel-Fall steht dann drin, die Overflow-Flag ist set according to the result.

Das sagt einem jetzt auch nicht wirklich mehr.

Man kann es noch eine halbe Stunde im Manual blättern, findet es aber auch nicht wirklich.

Man kann bei Google gucken, da steht dann irgendwas mit dem Overflow-Flag.

Viel einfacher ist es, man hat eine echte Kiste da stehen und schreibt sich ein 3-Zehler in Assembler.

Man schaut einfach mal, was rauskommt, ob man es verstanden hat, ob das richtig sein könnte.

Wenn man eine virtuelle Maschine gebaut hat, kann man sich dann auch aufnehmen, z.B. Zip-Pool-Rechner, kleine Testprogrammchen bauen.

Da gibt es dann den GCC, dann kann man ZIP-Programme schreiben oder es gibt den GNU-Assembler.

Da kann man halt Assembler-Programmchen schreiben zum Testen.

Wie gesagt, wenn jemand AMD oder so machen will, wir machen einen kleinen Minicrash-Kurs auch noch für AMD.

Ihr werdet merken, es ist nicht der große Unterschied.

Ich habe AMD gedacht, AMD eigentlich.

Okay, ja, haut mich.

Okay, jetzt gibt es gerade in der Intel-AMD-Welt, da gibt es dummerweise zwei Varianten, wie man schreiben kann.

Es gibt einmal das, was Intel selber rausbringt, bzw. AMD und Cyrix und so dann abgekupfert haben.

Da ist es so gemacht, die Befehle stehen wie in der sogenannten AT&T-Syntax auch auf der linken Seite.

Parameter rechts, soweit klar.

Nur ihr seht hier, hier kommt erst ein X und dann ein A1, AL.

Hier kommt erst RL und gerade umgekehrt.

Also ihr seht bei beiden, bei allen Beispielen Source und sogenanntes Destination ist umgedreht.

Ja, was heißt das? Das heißt, ich, also hier heißt es, ich addiere den Wert der Speicherzelle X zum Registerinhalt von AL.

Ja, das heißt genau das Gleiche, nur halt anders geschrieben.

Ja, die Intel-Leute sagen, ja damit man das Register von der Speicher, vom Speicherzellennamen unterscheiden kann,

dann machen wir halt um den Speicherzellennamen eckige Klammern.

Die AT&T-Leute haben gesagt, damit man Registernamen von Speicherzellennamen unterscheiden kann, schreiben wir vor das Register 1%.

Ja, muss man halt wissen. Und hier bei der Registerindirekt-Adressierung, Intel-Leute schreibt eckige Klammern um Register und addiert den Wert drauf.

AT&T macht runde Klammern ums Register und schreibt die 8 davor.

Ja, oder hier Registerindirekt mit BaseAdress, IndexRegister und ScaleFaktor.

Hier wird es einfach in eine eckige Klammer geschrieben, hier wird Parameter schreibweise in runden Klammern.

Teil einer Videoserie :

Zugänglich über

Offener Zugang

Dauer

01:25:03 Min

Aufnahmedatum

2015-10-28

Hochgeladen am

2019-05-06 13:59:02

Sprache

de-DE

Vorgestellt werden verschiedene Virtualisierungs-Ansätze:

  • Emulation

  • Just-In-Time-Compiler

  • Para-Virtualisierung

  • Bibliotheks-basierte Virtualisierung

  • OS-Virtualisierung

Lernziele und Kompetenzen:

Studierende, die das Modul erfolgreich abgeschlossen haben:

  • erläutern verschiedene Motivationen für den Einsatz von VMs

  • unterscheiden verschiedene VMs

  • klassifizieren verschiedene Ziele unterschiedlicher VMs (z.B. Performance, Konfigurierbarkeit, Genauigkeit, ...)

  • hinterfragen verschiedene Simulationansätze für MMUs

  • erstellen virtuelle Komponenten und Busse

  • strukturieren Callbacks und entsprechendes Forwarding und Caching

  • unterscheiden zwischen Architektur, Chip und Komponente

  • klassifizieren unterschiedliche Just-In-Time-Compiler-Ansätze

  • erzeugen JIT Code aus vorgefertigten Code-Teilen

  • bewerten unterschiedliche JIT-Code-Optimierungen

  • erläutern Probleme bei der JIT-Code-Invalidierung

  • nennen JIT Probleme mit Exceptions/Interrupts sowie berechnete Sprüngen und Return-Instruktionen

  • unterscheiden verschiedene JIT Cache-Verwaltungen

  • beschreiben Möglichkeiten der Fehlerinjektion durch VMs

  • entwickeln ein an JIT angepasstes virtuelles "Hardware"-Design

  • erläutern die Java-VM Instruktionssatz-Architektur

  • nutzen Hardware-basierte Virtualisierung

  • entwickeln Verfahren zum Ausfiltern bestimmter Befehle

  • erläutern Probleme der Speicherverwaltung bei HW-basierter Virtualisierung

  • nutzen User-Mode-Emulation zur Paravirtualisierung

  • diskutieren Möglichkeiten von Debuggern für die Umleitung von System-Calls und die Ausfilterung von Befehlen

  • nutzen einen Hypervisor zur Paravirtualisierung

  • unterscheiden verschiedene Ansätze zur Geräteverwaltung in paravirtualisierten Systemen

  • erläutern Betriebssystem-basierte Virtualisierung

  • entwickeln unterschiedliche Bibliotheks-basierte Virtualisierungen

  • erläutern Probleme beim Speicher-Layout bei Bibliotheks-basierte Virtualisierung

  • konzipieren Personalities für Bibliotheks-basierte Virtualisierungen

  • beurteilen Probleme bei der korrekten Zeit-Simulation

  • nennen Ideen für die dynamische Anpassung der Zeit-Simulation

  • klassifizieren bekannte VMs (z.B. VICE, FAUmachine, QEMU, Bochs, JVM, KVM, User-Mode-Linux, Xen, VServer, Wine)

  • diskutieren in der Gruppe Vor- und Nachteile von bestimmten VM-Ansätzen

  • entwickeln selbst CPU-Emulationen

  • entwickeln selbst Geräte-Emulationen

  • verteilen Implementierungsaufgaben in ihrer Gruppe

Einbetten
Wordpress FAU Plugin
iFrame
Teilen