Irix > Programmieren, Kompilieren

Runtime Code Generation?

(1/5) > >>

majix:
Mal wieder eine Frage: Als ein ultimatives Optimierungstool stelle ich mir im Augenblick einen "runtime code compiler" vor, d.h. einen compiler, der zur Laufzeit eines Programmes neuen Code erzeugen kann.

Was will ich damit machen? Ich habe ein Programm geschrieben, das 3DS Files laden und mittels OpenGL darstellen kann (im Augenblick nur utner Windows). Jetzt hat so ein Modell natürlich verschiedene Texturen etc, d.h. ich muss in einer Schleife alle Meshes einzeln durchlaufen und dann abchecken, welche OpenGL States neu zu setzen sind und dann das Mesh rendern. Aber eigentlich ändern sich diese Entscheidungen ja nie, welche States wann neu zu setzen sind.

Meine Idee ist es nun, zur Laufzeit des Programmes diekt nach dem Laden des Modells Code zu erzeugen, der dann mehr oder weniger nur noch OpenGL Aufrufe enthält. D.h. dieses lästige Schleife würde vollständig entfallen.

Nur: Wie erzeuge ich zur Laufzeit Code, und dazu noch in einer portierbaren Art und Weise? Meine Vorstellung wäre irgendwie so, dass ich zur Laufzeit einen ASCII-Text mit Quellcode erzeuge, den dann durch einen Compiler jage, und den erzeugten Code dann einfach aufrufe. Java und .NET kann sowas wohl, aber beides ist für meine Zwekce ungeeignet.

Googeln brachte durchaus zu Tage, dass ich nicht der einzige bin, der sich für solche Techniken interessiert, es gibt da einige Forschungs- und Entwicklungsarbeit, und auch ein paar Projekte. Nur was richtig passendes habe ich leider noch nicht gefunden.

Meine Anforderungen wären:
- Das Tool/Die Library sollte portabel sein (Windows, Linux, IRIX, Mac OS X)
- Man sollte irgendwie einen Quelltext als Eingabe reinstecken können, und eine fertig compilierte Funktion herausbekommen.
- Man muss auf jeden Fall OpenGL Funktionen aufrufen können

Hat da jemand Erfahrung und kennt ein passendes Tool?

Grüße,
Kaya

Brombaer:
Hallo Kaya,

soweit ich weiss gibt es sowas nicht. Ich kann mir auch nicht vorstellen, dass es wirklich viel Sinn ergibt da viel Zeit reinzustecken, denn in Zukunft wird eher die CPU zum Bottleneck, da machts Deine Schleife auch nicht aus. Zusätzlich optimieren alle ordentlichen Graphikprogramme die Statechanges, da ein Statechange eine maximal teuer und damit zu vermeidende Operation ist. Was Du suchst funktioniert auch nur für statische Objekte, bei dynamischen Szenen rentiert sich der Aufwand nicht mehr.

Eine Möglichkeit wäre einfach 1x zu rendern und den OpenGL-Stream abzugreifen (oder sich ne Dummy GL-Schnittstelle zu schreiben). Viel Spass wird das aber sicher nicht machen, denn die GL hat recht viele Befehle mittlerweile.

Gruß

Matthias

majix:
Klar, das hilft nur bei statischen Objekten - aber das sind ja die meisten Objekte.

Momentan habe ich mir eine Art Command-Stream gebastelt, da steckt man Anfangs lauter Meshes rein, dann sagt man "bitte einmal optimieren", dann wird daraus eine Befehlsfolge erzeugt, die die Statechanges minimiert (durch umsortieren der Meshes etc). Nur diese Befehlsfolge muss ich im Augenblick noch interpretieren (switch case-Konstruktion). Mir wäre es lieber, wenn der Command-Stream ein fertiges Programm für die CPU wäre.

Im Prinzip will ich sowas wie eine Display-List für jedes Modell, allerdings mit etwas mehr Optionen: Ich kann z.B. in den Command-Stream auch Zeiger auf Matrizen einbauen, so dass dann jedes der jeweils aktuelle Wert einer Matrix gesetzt wird. So kann man durchaus auch animierte Objekte derart optimieren.

Mein ideales Ziel ist nämliches folgendes: Die CPU dreht die Däumchen, während die GPU ins Schwitzen kommt. Denn erstens sehe ich nicht ein, wieso man eine schnelle CPU für Grafik braucht, zweitens kann ich die CPU Zeit dann für Simulation verwenden.

Grüße,
Kaya

sgt_barnes:
Hola! DAS klingt mal richtig interessant!  :D

Also wenn es kein Problem ist, diese Text-Datei zu erzeugen, und zu kompilieren, dann linke das ganze doch einfach zu einer DLL (bzw. eine schared object) und lade es nach (unter Windoof mit LoadLibrary() und unter UNIX mit dlopen() ).

Alles was Du dann noch brauchst, ist ein Interface, mit dem Du leben kannst. Für's erste sollte eine "render()"-Funktion reichen. Später wirst Du wohl auch andere Parameter dynamisch gestalten wollen.

Das ist der typische Plugin-Ansatz, und der hat bekanntlich mehrere Vorteile:

- genauso schnell wie der Rest des Programms (weil native code und kein Interpreter)
- flexibel ohne Ende
- der dynamische Linker erledigt den Grossteil der Arbeit für Dich

Das einzige Problem ist, dass es nicht ganz so einfach ist, das plattformunabhängig hinzukriegen. Das ist aber auch lösbar.

Ich werde immer gespannter drauf, was Du da produzierst...

MfG,
Tilmann

majix:
@sgt_barnes:
An den Ansatz habe ich auch gedacht - ist auf jeden Fall gangbar, allerdings setzt das dann immer eine vollständige C++-Installation auf Anwenderseite voraus.

Aber da fällt mir ein: Gibt es denn nicht irgendwelche andere (Skript)-Sprachen, die OpenGL unterstützen und direkt compilieren?

Das einzige Projekte, das in etwa dem Nahe kommt, was ich will, ist http://www.dyninst.org/. Aber das scheint mir sehr auf Debugging zugeschnitten zu sein... insbesondere kann man damit wohl gut ein Programm modifizieren, aber keine Subroutine vollkommen neu erstellen.

Grüße,
Kaya

Navigation

[0] Themen-Index

[#] Nächste Seite