Technik läuft. Moin moin allerseits. Jo, da waren wir letztes Mal. Wie war das noch?
Ah, also, kleine Rekalpiktubulation. Wir müssen letztendlich die Uhr in irgendeiner Form nachmachen
und nicht nur die Uhr im Sinne von Timerchip, sondern Uhr im Sinne von vielen Dingen. Im Prinzip
kann ich auch die Zeit messen, indem ich immer der Festplatte einen Auftrag gebe und gucke,
wann der Auftrag fertig ist und wie der Auftrag schickt und fertig und Auftrag und fertig und
Auftrag und fertig. Im Prinzip auch so eine Art Uhr. So ein Tick-Tack. Jo, die Uhr. Wie, da haben wir
jetzt zwei verschiedene Zeiten, die wir irgendwie beachten müssen, wollen. Einmal die Rahlzeit und
einmal die virtuelle Zeit. Und eigentlich, so war unsere Hoffnung, hätten wir eigentlich so eine
halbdiagonale virtuelle Zeit identisch zu aller Zeit. Das wäre ideal. Problem, mindestens ein
Problem. Es kann sein, dass unsere virtuelle Maschine in einer Zeitspanne mal gar nicht dran
ist. Die ist einfach schließlich weggeschedult. Weggeschedult heißt, unsere virtuelle Zeit kann
in der Zeit nicht vorangehen. Und damit wir nicht gar so einen großen Knick in der Zeit haben,
machen wir danach dann nicht da oben mit der Uhrzeit weiter. Dann würde die virtuelle Zeit
plötzlich springen in Nullzeit sozusagen. Und dann haben wir gesagt, naja, dann grober Daumen.
Irgendwie versuchen wir das ganze Ding wieder anzunähern. Jo, das war der Plan. Die Frage,
wie kriegen wir das hin? Jetzt Ideen von euch. Darauf hingewiesen hatte ich schon. Wir merken
eigentlich gar nicht, dass wir weggeschedult sind. Das kann ich nicht, sehe ich nicht. Ich rechne an
der Zeit nicht. Einzige, was ich vielleicht machen kann, ich kann mir zu verschiedenen Zeiten immer
mal wieder, ich laufe, hole ich mir die Realzeit, ich hole mir die Realzeit, ich hole mir die Realzeit,
ich hole mir die Realzeit. Ich hole sie mir nicht, kann ich nämlich gerade nicht, hier auch nicht,
da hole ich sie mir wieder. Und eventuell merke ich dann an einer relativ langen Spanne,
da muss auch mal passiert sein. Merke ich das überhaupt?
Da hast du recht. Du hast einen entscheidenden Punkt gesagt. Du kannst ab und zu die echte
Zeit holen. Erster Punkt ist wichtig, nicht ständig, das ist der Overkill, weil das ist
ein System Call. Und was ist dann ab und zu? Echte Takte, virtuelle Takte? Echte Takte geht
nicht, weil die haben wir nicht. Also wir können nur, immer wenn unsere virtuelle Zeit ein bisschen
vorangeschritten ist, dann können wir mal wieder die echte Uhrzeit holen. Die virtuelle Zeit schreitet
hier aber nicht voran, also holen wir uns nicht die reale Zeit. Irgendwann schreitet sie wieder
voran. Dann könnten wir uns die reale Zeit wiederholen. Das sind schon zwei wichtige Ideen.
Erster Punkt ab und zu mal. Und zweiter Punkt nicht anhand der Realzeit, weil die wissen wir nicht,
wir wollten uns ja gerade die Realzeit holen, aber anhand der virtuellen Zeit können wir uns das holen.
Das sind zwei wichtige Punkte. Was haben wir schon? Das haben wir auch. Und dann kommt sowas raus. Was
heißt das? Also folgende Idee. Ich fange mal nicht im Nullpunkt an, sondern ich fange einfach
mal woanders an. Was im Prinzip auch völlig wurscht ist, weil echte Zeit läuft sowieso. Ich fange
ja nicht beim Urknall an, sondern ich fange 2013 am 6.2. an. Also fangen wir mal da an und sagen,
ja, holen wir uns da einfach mal die Uhrzeit. Und dann sehen wir die Uhrzeit, naja, das wäre
eigentlich ja so das Stück. Da hätten wir eigentlich sein sollen, sind wir aber nicht. Okay,
dann sagen wir, wir wollen das, was uns fehlt, aufholen. Mit den nächsten, sagen wir mal,
wir machen das immer mit vier Schritten. Und das sind jetzt deine virtuellen Zeitticks.
Die Uhrzeit aufholen mit vier Zeitticks heißt, ich brauche die Steilheit sozusagen. Jeder virtuelle
Tick muss uns so weit in der Zeit voranbringen. Dann hätten wir die Uhrzeit aufgeholt. Während
wir die aber aufholen, haben wir natürlich wieder echte Zeit gebraucht. Jetzt gehen wir uns zu dem
Zeitpunkt. Jetzt wissen wir, wir haben die Uhrzeit aufgeholt. Dann gucken wir doch mal,
wie schaut jetzt die Uhrzeit aus, die echte. Dann merken wir wieder, wir sind der Zeit hinterher.
Dann bin ich Zufall. Okay, diesmal aber nicht so viel wie beim letzten Mal. Also können wir sagen,
ja, wenn wir das mit vier Schritten aufholen wollen, das können wir wieder tun. Aber mit
jedem virtuellen Zeitschritt muss die virtuelle Uhrzeit jetzt nicht so stark steigen wie gerade,
sondern ein bisschen weniger. Ja, dann machen wir diese vier Zeitschritte, die aber jetzt,
so wie ich es jetzt hingemalt habe, plötzlich lange dauern. Also lange im Sinne von echte
Zeit, weil wir zwischenzeitlich mal weggeschedult waren oder kann natürlich auch sein, weil einfach
Presenters
Zugänglich über
Offener Zugang
Dauer
01:31:58 Min
Aufnahmedatum
2012-02-07
Hochgeladen am
2019-05-05 22:09:32
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
-
untersuchen CPU-Emulationen
-
untersuchen Geräte-Emulationen