Musik

Ok, dann begrüße ich alle wieder offiziell zur Virtualmaschinenvorlesung-Übung.

Heute nochmal ein bisschen Vorlesungszeugs und so werden wir am Ende noch ein bisschen was zum Übungsbetrieb schaffen.

Kleine Wiederholung, was haben wir letztes Mal Mittwoch zum Schluss gemacht.

Da ging es darum, dass wir jetzt unsere virtuellen Maschinen virtuell zusammenstöpseln wollen.

Sprich wir haben einzelne Komponenten und die einzelnen Komponenten koppeln wir an unseren Bus.

Und dann sollen die Komponenten dem Busbescheid sagen, ja mich gibt es auch.

Wenn auf dem Bus was los ist, dann benachrichtige mich doch auch mal.

Und dafür registrieren sie Callback-Funktionen und gegebenenfalls einen Zustandspointer,

dass der Bus sie dann wieder aufrufen kann mit ihrem entsprechenden Zustand.

Gut, ob man das jetzt so macht, wie man es in C hinschreibt oder ob man das mit C++ mit virtuellen Methoden macht,

das ist eine Geschmackssache. Wir programmieren und nicht nur wir, sondern die meisten anderen virtuellen Maschinen auch, sind in C geschrieben.

So nach dem Motto, da weiß man, was man tut.

Bei C++, da passiert so etliche untere Haube, da weiß man nicht ganz genau, wann, wo, welche Methode und vielleicht noch irgendwas anderes vorher macht.

Hier kann ich es explizit hinschreiben und da sehe ich auch ganz genau, wann, wo.

Das war unser eines Beispiel hier.

Da hole ich aus dieser Struktur, wo die ganzen Callbacks drinsteht, mir eine raus und rufe sie auf und hole dafür noch den State Pointer,

übergebe den an die Funktion und noch zusätzlich das, was die CPU eigentlich wollte, also sprich den Port und den Wert.

Zwei Fragen. Erstens ist es nicht eine absoluten Performance Killer, wenn man von jedem Gerät, das ein Bus angeschlossen ist, und dann die Funktion aufnimmt.

Ja.

Das ist ja ein Opfer, den man eigentlich vermeiden könnte, wenn man das direkt über den Bus...

Ja, ich kann ja nur zustimmen. Alles, was du gesagt hast, war richtig.

Dann ist die Frage nicht mehr.

Ja, ja, hier, du hast das gut zusammengefasst, was nämlich gleich kommt.

Da steht drin, das ist der Performance Overkill.

Kommt noch in zwei Seiten, genau das.

Ich wollte nur noch mal kurz wiederholen, was wir am Mittwoch gemacht haben und dann kommen die Probleme und dann kommt hoffentlich eine Idee, wie man es lösen kann.

Die Folie hatten wir auch schon, also die umgekehrte Richtung. Wenn die CPU vom Bus was lesen will, dann klappert der Bus der Reihe nach die Eingabegeräte durch.

Und einer wird hoffentlich antworten. Aber auch das ist natürlich der Reihe nach alle mal Fragen.

Wie viele I.O. Geräte gibt es im PC?

Da waren es eine Handvoll. Es sind nicht wenige. Also diese Schleife, die läuft also durchaus bis Größen 28 oder so was.

Kann schon eine Weile dauern. Hat schon richtig erkannt.

Wenn man das allerdings so machen würde, und jetzt kommen die positiven Dinge zunächst.

Initialisieren das System wäre dann relativ schön eindeutig, schön schreibbar.

Ich würde erst mal sagen, ich brauche einen neuen Bus.

Dann brauche ich eine neue CPU. Und die CPU kriegt übergeben, wo sie sich dran kabeln soll, den Bus.

Ich brauche einen neuen Rammbaustein. Der soll sich auch an den Bus kabeln.

Und er kriegt noch Parameter mit. Also zum Beispiel Startadresse und Länge oder irgend so was.

Und das gleiche gilt dann natürlich jetzt sagen wir mal für ROM, Serienische Schildstelle, Platte oder so.

Und was ich zurückkriege, sind jetzt immer irgendwelche Pointer auf diesen Zustand.

Also dieses New holt sich irgendwo Speicher her. Aufpannen, dass er nicht überlappt. Klar.

Von der Idee her ruft er einen New auf, intern oder ruft einen Malloc auf, wie auch immer das dann heißt.

So die Idee.

Und jetzt haben wir hier so einen Sack voll Zustandspointer.

Und wenn wir das System jetzt simulieren wollen, dann soll jetzt wieder jede Komponente ihren Schritt, ihren Zustandsübergang machen.

Und dafür muss er natürlich jetzt übergeben kriegen, ihren Zustand.

Also ich rufe die CPU-Simulation auf und sage hier ist dein Zustand, der aktuelle, mach mal 9 draus.

Dann kann er aus dem Zustand seine Register rauslesen oder so.

Zum Beispiel die Instruction Pointer kann sich von da die Instruktion holen, kann die Instruktion ausführen.

Dadurch ändern sich Register. Die Register werden dann wieder in diesem Zustand abgespeichert.