Ryan Fleury's banner
Ryan Fleury's profile picture

Ryan Fleury

@rfleury • 23,352 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,126 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,672 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,974 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,418,947 views • 5 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

42,884 views • 20 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 • 5 months ago

More excellence
0:23
rfleury's profile picture

More excellence

Ryan Fleury

182,604 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,167 views • 2 months 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,229 views • 3 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

620,160 views • 2 years 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,692 views • 1 month ago

Scope ending annotations
0:48
rfleury's profile picture

Scope ending annotations

Ryan Fleury

14,164 views • 22 days ago

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

On the deletion of accounts

Ryan Fleury

23,648 views • 1 month ago

Getting closer.
0:42
rfleury's profile picture

Getting closer.

Ryan Fleury

76,195 views • 6 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,539 views • 9 months 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 • 1 month 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,766 views • 1 month 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

76,935 views • 1 year 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,205 views • 6 months ago

Why is panel layout such a special-case concept in so many programs?
0:42
rfleury's profile picture

Why is panel layout such a special-case concept in so many programs?

Ryan Fleury

65,451 views • 1 year ago

After some excellent work by NIKITA, we have a first pass of DWARF -> RAD debug info conversion up and running on Windows! A big step towards native Linux debugging.
0:49
rfleury's profile picture

After some excellent work by NIKITA, we have a first pass of DWARF -> RAD debug info conversion up and running on Windows! A big step towards native Linux debugging.

Ryan Fleury

31,579 views • 8 months ago

Why settle for a "command palette", when you could have an "everything palette"?
1:56
rfleury's profile picture

Why settle for a "command palette", when you could have an "everything palette"?

Ryan Fleury

43,124 views • 1 year ago

Breakpoint syncing progress
0:21
rfleury's profile picture

Breakpoint syncing progress

Ryan Fleury

27,166 views • 11 months ago