Today I Learned

Zig's GeneralPurposeAllocator.deinit performance impact

2025-03-16

I thought that calling deinit on a GeneralPurposeAllocator in Zig just frees any allocated memory you forgot to free. But, by default, it actually it makes your code significantly slower because it adds checks for memory leaks. The allocator performs a full scan of its internal structures to ensure all allocated memory has been properly freed.

So it probably generally makes sense to only call deinit() in debug builds.

However, you can disable this behaviour by setting the safety field of the GPA to false at initialization. Example:

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{
        .safety = false, // if true, deinit() will be slower
    }){};
    defer {
        const check = gpa.deinit();
        if (check.leaked) std.debug.print("Memory leak detected!\n", .{}); // nothing will print if safety is false.
    }

    const allocator = gpa.allocator();
    // Use allocator...
}

I also asked Claude on how runtime memory leak detection works in Zig. Here is the output:

Zig’s GeneralPurposeAllocator memory leak detection works like this:

1. Tracking mechanism:
   • Maintains a hash table that maps each allocated memory address to metadata
   • Each allocation adds an entry to this table
   • Each free removes the corresponding entry
   • Any entries remaining at deinit() represent leaks
2. Data structures used:
   • Hash table with allocated pointers as keys
   • Metadata for each allocation includes size and optional stack traces
   • Additional bookkeeping may track allocation patterns
3. Performance impact:
   • Adds overhead to every allocation and free operation
   • Each allocation/free requires hash table operations
   • Approximately 2x slower than using raw pointers
   • Consumes extra memory for the tracking table (16-24 bytes per allocation)
4. During program execution:
   • Every time you call allocator.alloc(), it adds to the tracking table
   • Every time you call allocator.free(), it removes from the tracking table
   • This continuous tracking is what adds overhead throughout your program’s execution

   The leak detection isn’t just an end-of-program check - it’s actively tracking throughout your entire program’s lifecycle, which is why it affects performance.

Rabin fingerprints are used for deduplication

2025-03-16

I learned about the Rabin fingerprint in university in the context of the Rabin-Karp algorithm for string matching. But now, while working on zchunk I’ve learned that the same fingerprint is useful for content-defined hashing. This makes sense because the same benefits of the fingerprint that make it suitable for string-searching make it suitable for chunking a file. Namely, the fact that a rolling hash can be computed relatively cheaply.

du on the command line

2025-03-08

du is a command line tool that shows the disk usage of a directory.

du -B1 {filename}

This will show the size of the file in bytes.

du -h {filename}

This will show the size of file in a “human readable” format i.e. (e.g., 1K 234M 2G)

CSS Custom Properties/Variables

2025-02-16

You can define global variables to use throughout a CSS file:

:root {
    --primary-color: #3F6346;
    --accent-color: #BF9B30;
    --bg-color: #FFFEF5;
    --text-color: #2C2C2C;
    --border-color: #E8E4D5;
    --hover-color: #C4A750;
    --table-stripe: #F9F7F0;
}

To use it:

.til {
  border: 1.5px solid var(--accent-color);
}

MacOS defaults all terminals as login shells

2025-02-16

See the excellent writeup in the Ghostty Documentation.