181
Netboot Windows 11 with iSCSI and iPXE
Notes on installing and netbooting Windows 11 over iSCSI
182
I uncovered an ACPI bug in my Dell Inspiron 5567. It was plaguing me for 8 years
Imagine you close your laptop lid to put it to sleep, but instead of pausing, it reboots. Not every time, just often enough to be infuriating. You try to save your work, but the machine decides to start over.
183
The MiniPC Revolution
Reasons why you should consider breaking your hardware up into MiniPCs.
184
CPU cache-friendly data structures in Go
False sharing, AoS vs SoA, random access, branch prediction: re-measured with go test -bench on two machines. Some claims held, some didn't.
185
Turning the database inside-out (2015)
Databases are global, shared, mutable state. That’s the way it has been since the 1960s, and no amount of NoSQL has changed that. However, most self-respecting developers have got rid of mutable global variables in their code long ago. So why do we tolerate databases as they are?
186
When you deleted /lib on Linux while still connected via SSH (2022)
Let's first not talk about why this can happen, but deleting /lib, /usr/lib, or some other essential runtime files happens quite a lot (as you can see: here, here, here, and here). In this post, I will only discuss what happens when you delete /lib on Linux and how to recover from that. The easy
187
SIMD within a register: How I doubled hash table lookup performance
It started with a simple thought: four bytes in a hash table bucket look just like an integer. Luckily, this one idea led to a deep dive into bit-twiddling and a 2x performance boost.
188
Why I run FreeBSD for my home servers (2024)
Why FreeBSD instead of Linux for home servers? Exploring ZFS, jails, stability, and the reasons behind choosing FreeBSD for a home infrastructure.
189
Memory access is O(N^[1/3])
In computer science, we often compare the efficiency of algorithms by describing their runtime as a function of the size of the input. Sorting is O(n * log(n)), meaning that sorting a list of N items takes an amount of time proportional to the number of items multiplied by its logarithm. Matrix multiplication is…
190
Demystifying the (Shebang): Kernel Adventures
Clarifying the shebang (#!) mechanism: A step-by-step look using strace and kernel code shows how Linux handles script execution directly, revealing the shell isn't involved initially.
191
We'd be better off with 9-bit bytes
A number of 70s computing systems had nine-bit bytes, most prominently the PDP-10, but today 1 [ 1 Apparently, it was the System/360 that really set the standard here. ] all systems use 8-bit bytes and that now seems natural. 2 [ 2 Though you still see RFCs use "octet", and the C standard has a CHAR_BITS macro, to…
192
Running a million-board chess MMO in a single process
How one million chessboards works
193
Branchless UTF-8 Encoding
I know how to decode UTF-8 using bitmath and some LUTs (see https://github.com/skeeto/branchless-utf8 ), but if I want to to go from a codepoint to UTF-8, is there a way to do it without branches?
194
Notes on the Pentium's microcode circuitry
Most people think of machine instructions as the fundamental steps that a computer performs. However, many processors have another layer of ...
195
Idempotency keys for exactly-once processing
In distributed systems, there’s a common understanding that it is not possible to guarantee exactly-once delivery of messages. What is possible though is exactly-once processing. By adding a unique …
196
Why we need SIMD
tl/dr: it can deliver big performance speedups at modest area cost
197
Too Many Open Files
Recently I’ve been working on a pretty big rust project and to my surprise Icouldn’t get tests to work properly.
198
Strategies for Fast Lexers
Making compilation pipelines fast, starting with the tokenizer
199
Understanding the Go Scheduler
Go Scheduler
200
Linux kernel cgroups writeback high CPU troubleshooting
Read on to learn how we used network packet captures and BPF to debug web server performance, ultimately uncovering a Linux kernel performance issue. This investigation was a collaboration between myself and my colleagues.
201
Demystifying Debuggers
An introduction to a new post series covering debugger basics.
202
Why Castrol Honda Superbike crashes on (most) modern systems
A friend cleaned up and gave me a copy of a game I've not heard about before: Castrol Honda Superbike World Champions , a motorbike racing game for PC, released 1998 by Interactive Entertainment Ltd. and Midas Interactive Entertainment.
203
Isn't WSL2 just a VM?
My take on Windows NT subsystems and the thin line between VMs and subsystems.
204
Serving 200M requests per day with a CGI-bin
In the early 2000s, we used to write a lot of CGI programs. This was the primary way to make websites dynamic at the time. These CGI programs were usually written in Perl, but sometimes in C to increase performance. The CGI mechanism is conceptually simple but powerful. When the web server receives an incoming request…
205
Under the hood: Vec<T>
Let's look at Vec<T> to get a better understanding of its inner structure.
206
Hypervisor 101 in Rust
This is a day long course to quickly learn the inner working of hypervisors and techniques to write them for high-performance fuzzing.
207
From 400 Mbps to 1.7 Gbps: A WiFi 7 Debugging Journey
Upgraded to WiFi 7 expecting 1.7 Gbps speeds. Got 400 Mbps instead. Here's what was actually wrong and how I fixed it.
208
The Canva outage: another tale of saturation and resilience
Today’s public incident writeup comes courtesy of Brendan Humphries, the CTO of Canva. Like so many other incidents that came before, this is another tale of saturation, where the failure mod…
209
Faster Index I/O with NVMe SSDs
The Marginalia Search index has been partially rewritten to perform much better, using new data structures designed to make better use of modern hardware. This post will cover the new design, and will also touch upon some of the unexpected and unintuitive performance characteristics of NVMe SSDs when it comes to read…
210
What the hell is a target triple?
Cross-compiling is taking a computer program and compiling it for a machine that isn’t the one hosting the compilation. Although historically compilers would only compile for the host machine, this is considered an anachronism: all serious native compilers are now cross-compilers.