24 - Virtuelle Maschinen [ID:10973]
50 von 637 angezeigt

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

Teil einer Videoserie :

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

Einbetten
Wordpress FAU Plugin
iFrame
Teilen