ZFX + Developia

Folgende Frage brennt mir grad unter den Nägeln:

Gibt es vielleicht ein Debugger Tool, das in der Lage ist, Variablen-Werte (oder Memory-Bereiche) "live" anzuzeigen - und zwar während das Programm läuft?
Ich verwende seit einiger Zeit den RemedyBG Debugger der mir soweit sehr gut gefällt (wer von euch nutzt ihn auch?) - doch dieses Feature scheint es nicht zu geben. Und meine kurzen Recherchen ergeben, dass dies anscheinend auch kein anderer Debugger beherrscht.

Bislang habe ich einfach printf verwendet, aber so richtig toll ist das natürlich nicht, da ich so immer den Code verändern muss und die Funktion auch stark auf die Performance schlagen kann.
So ein Feature wäre unheimlich praktisch. Ich bin mir aber nicht sicher, ob sich das technisch überhaupt so ohne weitere realisieren liesse. Vielleicht der Grund, weshalb so etwas ist nicht zu bekommen ist?

Wie macht ihr das, wenn ihr Werte zur Laufzeit sehen/überwachen wollt?

Ich gehe davon aus, es geht um C oder C++?

Meinst du sowas?
https://learn.microsoft.com/en-us/visua ... ew=vs-2022

siehe auch https://github.com/x13pixels/remedybg-issues/issues/164

Das hier sieht ganz nett aus, um zu wissen, was man haben will: https://werat.dev/blog/what-a-good-debugger-can-do/

Ja, C(++) ist gemeint. :)

Ich sehe keine Option, wie man Werte "live" anzeigen lassen kann. Das Programm muss laufen, also kein break per Debugger.

Beispiel: Ich messe einen Time-Stamp und möchte diesen Werte live sehen, wenn das Programm läuft - ohne printf oder eine Veränderung des Programmcodes.
Idealerweise sogar ganze Memory-Blöcke in Hex, ohne dass das Programm durch den Debugger pausiert ist.

Also als ne Art Overlay? Puh, tja, keine Ahnung, ich wüsste nichts davon. Wie willst Du auch die Adresse von dem rauskriegen, was Du anzeigen willst? Trainer haben früher sowas gemacht, aber das war mühsam und für Einzelwerte, und heutzutage kollidiert das sowieso mit Speicherschutz und Prozess-Isolation und Adressraum-Virtualisierung...

Bau's Dir selbst, ehrlich. Wenn Du VisualStudio nimmst, dann kannst Du einen Breakpoint setzen und den Print live einbauen und danach weiterlaufen lassen. Und aus Erfahrung: ein freundlicher Debug-Renderer, dem Du Punkte, Linien, wasweißich unkompliziert zuwerfen kannst, ist auch viel wert.

https://learn.microsoft.com/en-us/visua ... ew=vs-2022 Tracepoints gehen in die Richtung.

Omniscient Debugger können das auch. Habe ich aber noch nie genutzt.

Vielleicht bekommst du ja https://scrutinydebugger.com/ bei Dir zum Laufen. Aber das ist halt immer noch eine Manipulation des Programms, nur dass Du sie nicht vornimmst.

Ansonsten gibt es Tools zum Speicherbereich anschauen, z.b. CheatEngine.

Danke fürs Feedback.
Ich meine nicht ein Overlay im eigenen Fenster, sondern den Wert im Fenster des Debuggers angezeigt. Man kennt das ja von Emulatoren, bei denen man im Memory-Window live sehen kann, wie sich die Daten verändern.
Ich hatte befürchtet, dass das die Fähigkeit eines Debuggers prinzipiell übersteigt. Meine Hoffnung: Wenn ein Debugger den Prozess pausieren kann, wenn ein bestimmter Bereich im Speicher gelesen wird (dazu muss er ja die Adresse genau kennen - trotz ASLR), dann kann er vielleicht auch diesen Speicherbereich "live" anzeigen. Aber das scheint nicht der Fall zu sein.

Edit:
Danke Chromanoid, mein Post ging vor deiner Antwort raus!

ja genau das sind ja tracepoints/watchpoints: https://www.jetbrains.com/help/clion/us ... oints.html

edit: hehe richtig traffic hier :))

So kommt man vielleicht doch noch auf den richtigen Trichter. :)

Ihr meint also einen Watchpoint auf einer Variable einrichten und dann vom Debugger loggen lassen, sobald sich etwas ändert?
Läuft dann das Programm jeweils automatisch weiter? Wenn ja, würde das einem "live-watch" a là Emulator-Memory-Window ja schon recht nahe kommen!

Bist du dir sicher, dass du den Wert nicht anders exportieren willst, z.B. als Metrik oder sowas? Du hast ja nicht aufgeschrieben, was genau du beobachten willst, aber das praktische Problem im Allgemeinen wird sein, dass interessante nicht wirklich fix irgendwo im Speicher sind und man erst zur Laufzeit an irgendeinem breakpoint Punkt sagen kann, wo sie sind.

Nachteil der Metrik ist natürlich, dass Metriken eine Frequenz haben; dein Auge hat aber auch eine, also ist das vielleicht kein echtes Problem.
Wenn du dir nur schnell irgendwas hinhacken willst, dann kannst du einfach einen deamonthread bauen, der den Wert auf die Konsole dumpt. Hab ich auch schon mehr als einmal gemacht.

Ja, das Hauptproblem ist ja, dass die Werte entweder auf dem Stack liegen und dann nur kurz existieren oder im Heap, aber z.B. wenn ein Array vergrößert wird ändert sich ja wo es liegt. Und wo es dann liegt weiß wiederum der Stack.
Anzeigen kann man das, einfach in die Disassembly View gehen - aber viel Spass beim Finden der Variablen im Speicher ;-P
Für einen Debugger eher schwer zu lösen.

Wenn es um ein Spiel geht, dann kannst du ja mittels Dear Imgui oder sowas eine Anzeige bauen, dann musst du auch nicht zwischen Spiel und Debugger wechseln, wenn du die Werte sehen willst. So machen das wohl die meisten.

Alternativ kann dein Programm einfach einen Webserver starten und dann kannst du mit dem Browser die Werte sehen, statt mit dem Debugger. Der Vorteil ist, du kannst sie auch rendern wie du sie haben willst und bestimmen wie sie angezeigt werden sollen.
Das ist oft besser als das kleine Fenster mit den Variablen in der IDE.

Der Scrutiny Debugger sieht cool aus, den kannte ich noch nicht :-)

Ja, also vielleicht erklärst du erstmal, warum du denkst, das zu brauchen. Du willst ja nicht wirklich den Wert wissen, sondern du willst den Wert wissen um damit irgendein Problem zu lösen.

Aber ich vermute, wenn du wirklich den live-Wert sehen willst, würde ich ganz stark NytroX zustimmen und einfach ImGUI verwenden. Damit kannst du mit einer Zeile Aufwand Werte vernünftig live Anzeigen und editieren und ganz gut überwachen, was gerade passiert. Ich benutze das viel zum Debuggen und Entwickeln, weil man halt auch super Dinge über Buttons triggern kann und so. Im Grunde genommen also für alles was über mehr als einen Frame geht.