Ryan Fleury's banner
Ryan Fleury's profile picture

Ryan Fleury

@rfleury • 24,055 subscribers

RJF // @dgtlgrove // Making RAD Debugger at @radgametools in @epicgames (opinions my own)

Shorts

This is a huge bang-for-buck improvement you can add to your UIs.

This is a huge bang-for-buck improvement you can add to your UIs.

157,495 views

So many programs need a tab open in order to keep a window open, and it is a really annoying design trend. It makes more sense, and it is much nicer to use, to allow empty windows.

So many programs need a tab open in order to keep a window open, and it is a really annoying design trend. It makes more sense, and it is much nicer to use, to allow empty windows.

157,351 views

In RADDBG, the "Step Out" command has been upgraded to support block stepping! It now lets you step through blocks, out of loops, or (the traditional behavior) out of function frames.

In RADDBG, the "Step Out" command has been upgraded to support block stepping! It now lets you step through blocks, out of loops, or (the traditional behavior) out of function frames.

27,882 views

Almost fully ported the renderer to OpenGL during the last bit of the day This is not for Windows

Almost fully ported the renderer to OpenGL during the last bit of the day This is not for Windows

30,985 views

Huge upgrade to loading speeds coming soon, especially with DLL-heavy codebases like UE! The primary reason PDB -> RDI conversion (or PDB parsing in debuggers more generally) is a big bottleneck in startup time is because they must be converted/parsed/loaded _serially_. This may seem surprising, since intuitively it'd seem like they can be converted/parsed/loaded/etc. in parallel. This is not true in the general case due to breakpoints, and how they relate to an API like `LoadLibrary`, and how it translates into debug events. When a debuggee runs `LoadLibrary`, the debugger will receive a debug event informing the debugger that the associated module was loaded. Any time a debug event is sent to the debugger, the debuggee stops running entirely. This is so that the debugger can make decisions about how the debuggee should proceed. For example, if I have a breakpoint on `foo.c:123`, that file name and line number can only be correctly interpreted (meaning resolved into code addresses) using debug information. The debugger only knows about that debug information from the PDB - without it, that file/line combo is meaningless. But importantly, the debugger cannot *resume* the debuggee until it has resolved that breakpoint - otherwise the debuggee may execute code which *would've* hit the breakpoint, *if* it were resolved in time. So, the debugger needs to ensure that all breakpoints are fully resolved before resuming. This is a correctness detail that everyone has to pay for, basically because `LoadLibrary`s are received one-at-a-time. Obviously, if it were instead an API like `LoadLibraries`, then the debugger could prepare all of the debug info in one batch before resuming - but it doesn't know what that batch would be, given just an initial `LoadLibrary`. This is unfortunate, because *generally* you are not debugging the code loading a bunch of DLLs, but the debugger can't really know that. (It is probably a good idea to provide a `raddbg_load_libraries` API at some point, so that we can resolve this issue on the debuggee side). In any case, RADDBG now resolves breakpoints much more quickly by avoiding 99% of debug info conversion work to do a common case of breakpoint resolution - you might call this "breakpoint disqualification". Basically, if a breakpoint is set, and we can quickly determine that that breakpoint's information (file location, expression, condition, etc.) *cannot apply* to some module's debug info - more quickly than doing a *full* PDB -> RDI conversion (which entails a full parse & a bunch of work) - then we can simplify the very common case in DLL-heavy cases: you put a breakpoint on `foo.c:123`, when 99% of the DLLs do not have any line info for that file, so the debugger can resume *knowing* that breakpoint will not resolve within that file. In this demo video, you can see I place a breakpoint that only resolves within the executable's debug info - it does not resolve within any of the 100 DLLs that are loaded serially. Within the `Modules` tab, you can see that as I run the target, most of the debug info is not loaded initially, even though the debuggee is running. That debug info is loading in parallel, as the debugger knows it does not need to wait for that debug info to be prepared for this breakpoint.

Huge upgrade to loading speeds coming soon, especially with DLL-heavy codebases like UE! The primary reason PDB -> RDI conversion (or PDB parsing in debuggers more generally) is a big bottleneck in startup time is because they must be converted/parsed/loaded _serially_. This may seem surprising, since intuitively it'd seem like they can be converted/parsed/loaded/etc. in parallel. This is not true in the general case due to breakpoints, and how they relate to an API like `LoadLibrary`, and how it translates into debug events. When a debuggee runs `LoadLibrary`, the debugger will receive a debug event informing the debugger that the associated module was loaded. Any time a debug event is sent to the debugger, the debuggee stops running entirely. This is so that the debugger can make decisions about how the debuggee should proceed. For example, if I have a breakpoint on `foo.c:123`, that file name and line number can only be correctly interpreted (meaning resolved into code addresses) using debug information. The debugger only knows about that debug information from the PDB - without it, that file/line combo is meaningless. But importantly, the debugger cannot *resume* the debuggee until it has resolved that breakpoint - otherwise the debuggee may execute code which *would've* hit the breakpoint, *if* it were resolved in time. So, the debugger needs to ensure that all breakpoints are fully resolved before resuming. This is a correctness detail that everyone has to pay for, basically because `LoadLibrary`s are received one-at-a-time. Obviously, if it were instead an API like `LoadLibraries`, then the debugger could prepare all of the debug info in one batch before resuming - but it doesn't know what that batch would be, given just an initial `LoadLibrary`. This is unfortunate, because *generally* you are not debugging the code loading a bunch of DLLs, but the debugger can't really know that. (It is probably a good idea to provide a `raddbg_load_libraries` API at some point, so that we can resolve this issue on the debuggee side). In any case, RADDBG now resolves breakpoints much more quickly by avoiding 99% of debug info conversion work to do a common case of breakpoint resolution - you might call this "breakpoint disqualification". Basically, if a breakpoint is set, and we can quickly determine that that breakpoint's information (file location, expression, condition, etc.) *cannot apply* to some module's debug info - more quickly than doing a *full* PDB -> RDI conversion (which entails a full parse & a bunch of work) - then we can simplify the very common case in DLL-heavy cases: you put a breakpoint on `foo.c:123`, when 99% of the DLLs do not have any line info for that file, so the debugger can resume *knowing* that breakpoint will not resolve within that file. In this demo video, you can see I place a breakpoint that only resolves within the executable's debug info - it does not resolve within any of the 100 DLLs that are loaded serially. Within the `Modules` tab, you can see that as I run the target, most of the debug info is not loaded initially, even though the debuggee is running. That debug info is loading in parallel, as the debugger knows it does not need to wait for that debug info to be prepared for this breakpoint.

17,527 views

Videos

LIVE
1.2k

Anya Rossi

sweetdream.ai

SweetDream.aiSponsored•Livecam
Streaming Now

Watch Anya Live

Anya is streaming live right now! Join her private show and enjoy exclusive content.

HD live stream
Exclusive private shows
1.2k viewers online

Free preview available • Premium content

This is not a real company
0:32
rfleury's profile picture

This is not a real company

Ryan Fleury

4,420,292 views • 6 months ago

And here is editing a 1+ GB text file using this mechanism
0:23
rfleury's profile picture

And here is editing a 1+ GB text file using this mechanism

Ryan Fleury

54,202 views • 10 days ago

Here’s ~9 GB (close to 500M lines). I clipped out the initial load time (it’s something like 30 seconds, a lot of it is single threaded — should improve a lot on the next pass). But once the file is loaded, edits remain ~instant.
0:25
rfleury's profile picture

Here’s ~9 GB (close to 500M lines). I clipped out the initial load time (it’s something like 30 seconds, a lot of it is single threaded — should improve a lot on the next pass). But once the file is loaded, edits remain ~instant.

Ryan Fleury

35,573 views • 9 days ago

Many people have commented on the relatively smaller sizes, faster startup time, better performance, and smoother interactivity of projects like the RAD Debugger or File Pilot. The “secret” is literally just writing things sensibly from scratch. Just stop importing things, and actually solve the problem yourself.
2:25
rfleury's profile picture

Many people have commented on the relatively smaller sizes, faster startup time, better performance, and smoother interactivity of projects like the RAD Debugger or File Pilot. The “secret” is literally just writing things sensibly from scratch. Just stop importing things, and actually solve the problem yourself.

Ryan Fleury

232,912 views • 7 months ago

More excellence
0:23
rfleury's profile picture

More excellence

Ryan Fleury

182,830 views • 6 months ago

Left: From-scratch debug build, launching target, and stepping with RADDBG. Right: Launching target & stepping with Visual Studio 2022.
0:25
rfleury's profile picture

Left: From-scratch debug build, launching target, and stepping with RADDBG. Right: Launching target & stepping with Visual Studio 2022.

Ryan Fleury

647,705 views • 2 years ago

Easy to miss if you get lost in the noise in online programming discourse, but straightforward programming in a systems language like C can provide high performance, modern UI, without much hassle.
2:08
rfleury's profile picture

Easy to miss if you get lost in the noise in online programming discourse, but straightforward programming in a systems language like C can provide high performance, modern UI, without much hassle.

Ryan Fleury

117,408 views • 5 months ago

“native has nothing to offer” No, you’ve just either never bothered to seriously try it, or you just suck.
2:25
rfleury's profile picture

“native has nothing to offer” No, you’ve just either never bothered to seriously try it, or you just suck.

Ryan Fleury

91,252 views • 4 months ago

Source-inline display of auto watch expressions, computed by determining which addresses are read from / written to by a particular range of instructions, and mapping that back to variables via location info within debug into.
0:42
rfleury's profile picture

Source-inline display of auto watch expressions, computed by determining which addresses are read from / written to by a particular range of instructions, and mapping that back to variables via location info within debug into.

Ryan Fleury

44,611 views • 2 months ago

Getting closer.
0:42
rfleury's profile picture

Getting closer.

Ryan Fleury

76,247 views • 8 months ago

Someone mentioned to me that they missed a file tree view in the RAD Debugger, so they could easily browse their project folder hierarchy. I then realized I had inadvertently already implemented it in the watch window.
1:00
rfleury's profile picture

Someone mentioned to me that they missed a file tree view in the RAD Debugger, so they could easily browse their project folder hierarchy. I then realized I had inadvertently already implemented it in the watch window.

Ryan Fleury

30,763 views • 3 months ago

Palettes should be first class functionality provided by the operating system for any program.
0:55
rfleury's profile picture

Palettes should be first class functionality provided by the operating system for any program.

Ryan Fleury

85,588 views • 11 months ago

On the deletion of accounts
1:00
rfleury's profile picture

On the deletion of accounts

Ryan Fleury

23,721 views • 2 months ago

I just asked Cursor to remake the Visual Studio debugger but better, look at what it made🤯🤯 Programmers are cooked... 💀
2:09
rfleury's profile picture

I just asked Cursor to remake the Visual Studio debugger but better, look at what it made🤯🤯 Programmers are cooked... 💀

Ryan Fleury

77,105 views • 1 year ago

Memory view support for mutation and copy/paste
0:45
rfleury's profile picture

Memory view support for mutation and copy/paste

Ryan Fleury

20,822 views • 3 months ago

Some visual upgrades to listers
0:49
rfleury's profile picture

Some visual upgrades to listers

Ryan Fleury

11,089 views • 1 month ago

Scope ending annotations
0:48
rfleury's profile picture

Scope ending annotations

Ryan Fleury

14,329 views • 2 months ago

Memory view "peek types" - enter a list of any type expressions, and interpret memory quickly as those types.
2:01
rfleury's profile picture

Memory view "peek types" - enter a list of any type expressions, and interpret memory quickly as those types.

Ryan Fleury

18,832 views • 3 months ago

RADDBG now allows disambiguating global variable evaluations by compilation unit, as well as module or debug info name, regardless of where your selected thread happens to be. It picks module, debug info, compilation unit, and - for local statics - containing function based on the selected thread's position, but those are no longer required, meaning you can evaluate any global variable, in any module, in any unit, from anywhere.
0:35
rfleury's profile picture

RADDBG now allows disambiguating global variable evaluations by compilation unit, as well as module or debug info name, regardless of where your selected thread happens to be. It picks module, debug info, compilation unit, and - for local statics - containing function based on the selected thread's position, but those are no longer required, meaning you can evaluate any global variable, in any module, in any unit, from anywhere.

Ryan Fleury

12,670 views • 2 months ago

I could only resist implementing cursor trails for so long.
0:35
rfleury's profile picture

I could only resist implementing cursor trails for so long.

Ryan Fleury

37,254 views • 8 months ago