werat.dev

How conditional breakpoints work 🐢

Mon, 22 Jul 2024 17:42:00 +0200

Conditional breakpoints are extremely useful, but everyone knows [citation needed] that they’re super slow, to the point where people stop using them. Visual Studio recently did some good improvements and @ryanjfleury still dunked on it for being too slow. But even raddbg takes ~2 seconds to execute 10000 iterations of a simple loop with conditional breakpoints inside. For comparison, the same loop without breakpoints takes less than 1ms. So why is it so damn slow?

Let’s explore how conditional breakpoints are typically implemented in modern debuggers, where the performance problems come from and what can be done to make things go fast.

Learning about debuggers

Mon, 08 Jan 2024 13:00:00 +0200

Today’s article is a collection of materials to learn more about debuggers: how they work, which technologies are under the hood, what kind of problems exist in this area. There is of course a big overlap with related components like compilers and linkers, so get ready to learn lots of new things 😃.

Of course, the list is not exhaustive by any means. These are just the links I’ve accumulated over the years and found useful for myself. If you’d like to add anything to the list, let me know!

Note: many of the links here are blog posts – be sure to check out other articles in those blogs! They’re often worth reading even if not directly related to the topic.

Segmented stacks in Wine/Proton minidumps

Mon, 18 Sep 2023 12:00:00 +0200

Last year I was working on improving debugging experience for Wine/Proton and part of that work went into supporting process crashdumps. Supporting minidumps was particularly important and of course it turned out things were broken. I worked on this problem more than a year ago and things may have changed since then. This article is a reconstruction of my old notes since I find the story is quite entertaining even if it’s not so relevant today.

Automatic image size attributes in Hugo

Sun, 30 Apr 2023 12:00:00 +0100

It’s a good practice to always include width and height attributes on images and video elements. Without them the browser has no way of knowing how large the image is going to be and cannot reserve the space in advance when rendering the page. This often leads to the content moving around during the page load, since images take extra time to fetch. This is called Layout Shift and I find it extremely annoying!

What a good debugger can do 🔮

Fri, 10 Mar 2023 12:00:00 +0100

When people say “debuggers are useless and using logging and unit-tests is much better,” I suspect many of them think that debuggers can only put breakpoints on certain lines, step-step-step through the code, and check variable values. While any reasonable debugger can indeed do all of that, it’s only the tip of the iceberg. Think about it; we could already step through the code 40 years ago, surely some things have changed?

Tl;dr – in this episode of old-man-yells-at-cloud, you will learn that a good debugger supports different kinds of breakpoints, offers rich data visualization capabilities, has a REPL for executing expressions, can show the dependencies between threads and control their execution, can pick up changes in the source code and apply them without restarting the program, can step through the code backward and rewind the program state to any point in history, and can even record the entire program execution and visualize control flow and data flow history.

I should mention that the perfect debugger doesn’t exist. Different tools support different features and have different limitations. As usual, there’s no one-size-fits-all solution, but it’s important to understand what’s theoretically possible and what we should strive for. In this article, I will describe different debugging features and techniques and discuss the existing tools/products that offer them.

Disclaimer. In this article I mention various free and commercial products as examples. I’m not being paid or incentivised in any other way by the companies behind those products (although I will not say no to free swag should they decide to send me some cough-cough). My goal is to raise awareness and challenge the popular belief that “debuggers are useless, let’s just printf”.

Pretty Rust backtraces in raw terminal mode

Fri, 24 Feb 2023 13:00:00 +0100

In my efforts to get better at Rust I’ve recently been working on a terminal-based roguelike game 🦀. One of the first things terminal-based applications (e.g. games, text editors, tools like top) do at startup is switch the terminal into raw mode. This article is about a short journey of how-do-I-get-a-pretty-panic-backtrace-when-my-terminal-is-in-raw-mode.

Debugging Wine with LLDB and VSCode

Wed, 26 Oct 2022 15:20:00 +0100

In my previous post about Wine I mentioned working on a debugger that is capable of debugging both the Wine layer and the Windows application running with it. Time to share some details!

How Wine works 101 🍷

Mon, 10 Oct 2022 21:20:00 +0100

Wine is a compatibility layer capable of running Windows applications on several POSIX-compliant operating systems, such as Linux, macOS, & BSD (https://www.winehq.org).

If you have been using Linux for some time now, chances are you’ve used Wine at some point. Maybe to run that one very important Windows program that doesn’t have a Linux version or maybe to play World of Warcraft or some other game. Fun fact, Valve’s Steam Deck uses a Wine-based solution to run games (called Proton).

How to debug deadlocks in Visual Studio

Sat, 17 Sep 2022 12:21:00 +0100

There has been lots of discussions recently about the usefulness of debuggers (on Twitter/Reddit and probably other platforms). Some people brag about never using/needing one and some people can’t imagine their life without stepping through the code line by line. I’m both of these people at different times, so I’m not going to judge anyone. Instead, let me share a short debugging story and you can decide for yourself :)

Why are my PCHs out of date?

Sat, 04 Dec 2021 13:35:00 +0100

Last week I got an interesting bug report from a colleague. They were minding their own business and playing with Unreal Engine 5 when suddenly a wild build error appeared and said that some precompiled headers are out of date:

fatal error: file 'D:\toolchain\sysroot\usr\include\x86_64-linux-gnu\bits\wordsize.h' has been
modified since the precompiled header 'UE5\Engine\...\SharedPCH.CoreUObject.ShadowErrors.h.gch'
was built: mtime changed

Hmm, well, it looks like some source files have changed and a simple re-build would fix the issue. However, building Unreal Engine from scratch takes considerable time, so you can understand why we’d like to avoid that.

Installing Visual Studio extensions from MSI

Sat, 07 Aug 2021 09:23:00 +0100

Visual Studio extensions are typically distributed via VSIX packages. Visual Studio comes with an installer vsixinstaller.exe, which handles the actuall installation process. When you download the VSIX file from the extension gallery and then double-click it or when you install the extension from Visual Studio via the “Extensions and Updates” menu the above mentioned installer is invoked and does all the work. It’s also possible to use vsixinstaller.exe directly if you need to install the extensions programmatically (e.g. in a script that sets up a new developer machine).

Running benchmarks for Pull Requests via GitHub Actions

Mon, 28 Jun 2021 13:35:00 +0100

Benchmarks are often underestimated and don’t get the same attention as tests. However “performance is a feature” and when something is not tested it might as well be just broken. If the performance is not measured/tracked regressions are inevitable.

Modern tooling makes it really easy to write benchmarks. Some languages have built-in support, for example, Rust comes with cargo bench (docs) and Go has go test -bench (docs). For C++ there is google/benchmark – not as streamlined as having it built into the language infrastructure, but still definitely worth the effort.

Blazing fast expression evaluation for C++ in LLDB 🔥

Tue, 23 Mar 2021 00:00:00 +0000

Expression evaluation is an integral part of any modern debugger. It allows the user to inspect the program state using the familiar syntax of the target language, as well as perform modifications to the target process (if the side-effects are allowed). If you have ever used command-line debuggers, you’re probably familiar with it via commands like print/call in GDB or expr/p in LLDB. It is also used extensively by the IDEs to support typical UI workflows: Immediate Window, Watch Window, hovering over a variable, custom data visualizers (see NatVis), etc.

Debugging LLDB with source stepping

Sun, 11 Oct 2020 18:35:00 +0100

Sometimes you want to (or need to) debug a program that you didn’t build yourself and you don’t even know how exactly it was built. Depending on the specifics of your setup that could mean many different things:

Built on a build farm, running on a production server/container
Installed via apt or similar, running locally
…

This post is inspired by my experience of debugging LLDB. Debugging the debugger is always interesting and tricky, even without the additional difficulties like trying to get the source stepping to work :)

Happy ssh agent forwarding for tmux/screen

Sat, 04 Feb 2017 11:55:00 +0300

If you often use ssh+tmux combination and ssh keys forwarding, you’ve definitely been in an unpleasant situation:

connect to some remote machine via ssh and create a tmux session
use it happily
detach from tmux and disconnect from server
connect again (e.g. next day) and attach to the tmux session
push something to git (or connect to another server)…
…
Permission denied (publickey).

Let’s discuss why this is happening. The magic behind ssh forwarding is quite simple: ssh-agent creates a socket (on linux usually something like /tmp/ssh-hRNwjA1342/agent.1342) which is used by other applications to communicate with ssh-agent. Obviously these applications need a way to find this socket, so ssh-agent also sets an environment variable SSH_AUTH_SOCK, which contains path to the socket.