25 - Virtuelle Maschinen [ID:10999]
50 von 815 angezeigt

Die erste Frage ist wieder von mir. Ihr kennt das, es gibt Fragen.

Dann geht es weiter mit einem Thema Zeit. Es klingt jetzt erstmal so, Zeit in der

Maschine soll möglichst schnell gehen und die Uhr soll richtig gehen. Und wo ist jetzt das Problem?

Einerseits sage ich wir haben gar kein Problem wirklich. Im Sinne von möglichst schnell.

Das gilt ja nicht nur für Wörter in der Maschine, das gilt bei euch glaube ich auch und bei mir genauso,

wie bei einem echten Rechner genauso. Möglichst schnell. Man kauft sich das, was man gerade so für Geld

kriegen kann. Möglichst schnell und so besser, je schneller. Und dass die Uhr richtig geht,

das kann ja so schlimm eigentlich nicht sein. Man kann ja die echte Uhr fragen bei der Simulation,

wie wird es einem dann sagen, wie spät es ist. Ja, wir werden sehen, Zeit ist schon fast mit der schwierigsten

Kapitel im Sinne von Wörter in der Maschine. Jo, zunächst einmal, was bedient jetzt alles Zeit?

Zum einen würde man sagen, wenn ich jetzt wirklich eins zu eins einen Rechner nachmachen will.

Also bisher haben wir mal gesagt, die funktionalen Eigenschaften haben wir nachgemacht.

Also wenn er die Addition ausführt, dann soll er die auch so ausführen, wie die Addition halt ist.

Die nicht funktionalen Eigenschaften wie Toleranz, Wärmeerzeugung, Zeitbedingungen, das ganze Zeug

haben wir bisher ja unter den Teppich gekehrt. Wenn wir jetzt sagen, diese nicht funktionale Eigenschaft

zeigt, die gucken wir uns jetzt mal an. Wo spielt das alles rein? Zum einen natürlich könnte man sagen,

so und so viele CPU Instruktionen sind pro Zeiteinheit auszuführen. Ja, ihr wisst selber, so einfach ist

allein das schon nicht. Das weiß man ja von vielen modernen Rechnern gar nicht, wie viele Instruktionen

pro Zeiteinheit sind das jetzt eigentlich? Gut, wenn man dann irgendwie einen Fly-Mico-Controller hat

mit einfacher Pipeline, dann kriegt man das vielleicht noch hin, dann kann man sagen, wir geben Tag eine

und das Ding läuft mit 24 Mhz. Oh klar, okay klar, wissen wir es. Aber so bei einem typischen

Pentium, Spark, Superskalar, irgendwas, da weiß der Henker, wie viele Instruktionen der pro Sekunde

durchkriegt. Das ist ja, wovon hängt das ab? Das hängt logischerweise erstmal vom Takt ab, das ist das,

was man gesagt kriegt. Aber ja, zum Teil variabel ist, ihr wisst, das ist schon nicht ganz so eine

Konstante. Wie viele Instruktionen werden pro Takt ausgeführt? Da weiß auch keiner so genau.

Da steht dann drin bis zu 4 oder irgend sowas. Bis zu, sagt dann jetzt wieder nicht wirklich was.

Das kann 0 und 4 schwanken. Dann kommt es natürlich drauf an, bis zu 4 könnte heißen, ich will 4

holen, aber dann kommt es auf den Cache drauf an. Hat er die Daten? Hat er sie nicht? Wie schnell

kriegt er die Daten? Das wissen wir auch meistens nicht. Oder wisst ihr, wie schnell euer

First-Level-Cache in eurem Rechner ist? Ein Takt, zwei Takt, drei Takt. Schon schwierig auszufinden.

Second Level das gleiche. Also Anzahl der ausgeführten CPU Instruktionen pro Zeiteinheit.

Also nachzumachen ist schon ein Problem, aber überhaupt an die Info ranzukommen, wie es eigentlich im

Original ist, ist schon gar nicht so einfach. Gleiche gilt natürlich für die Grafikkarte.

Auch die hat natürlich irgendwelche, mal eine Dreiecke. Wie viele Dreiecke pro Sekunde kann sie malen?

Wie funktioniert der Shader? Wie funktioniert die Pipeline des Shaders? Keine Ahnung.

Wie lange dauert es eine Platte zu beschreiben, einen Blog zu lesen? Das eigentliche Lesen und Schreiben,

das kriegt man vielleicht sogar noch raus. Man weiß, wie schnell sich das Ding dreht. Man weiß, wie viele

Sektoren auf der Platte sind und dann kann man es so grob. Wie das jetzt allerdings aussieht mit der

Armbewegung. Wie lange braucht der Arm jetzt von einem Sektor zum anderen? Das ist bei modernen Platten

nicht einmal eine Konstante. Da sagt er nur, er weiß, er ist auf Spur 3 und er will auf Spur 5,

dann gibt er dem Arm einen Schutz und während er so rüber gleitet, liest er schon Spuren und bremst

dann ab, wenn er sich der Spur nähert. Ja, also trivial sicher nicht. Netzwerk, senden, empfangen.

Ja, gut, ihr habt ein Gigabit Netzwerk, dann müsst ihr wie viele Bits pro Sekunde drüber gehen,

wie die kodiert sind, was passiert bei Kollisionen, wenn der Hub die jetzt gerade nicht annimmt,

weil er gerade mit dem anderen beschäftigt ist. Auch nicht so einfach. Das Einzige, was man leidlich

simulieren kann oder wo man zumindest weiß, wie man simulieren müsste, das sind die Dinge, die jetzt

die Zeit im Rechner wirklich vorgeben, nämlich Uhrenbaustein bzw. Timerbaustein.

Die sind logischerweise natürlich genau spezifiziert. Da kann ich mir eine Uhr anfangen, die nicht

spezifiziert ist, was die Zeit angeht. Das macht keinen Sinn. Timerbaustein genauso, da kann ich sagen,

wenn ich das und das in den Configregister reinschreibe, dann tickt der Timerbaustein mit 100 Hz.

Teil einer Videoserie :

Zugänglich über

Offener Zugang

Dauer

01:31:14 Min

Aufnahmedatum

2016-01-27

Hochgeladen am

2019-05-07 20:59:04

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