performance
Finding the actual bottleneck rather than the one you assumed.
-
Merging Concurrent Polls Without Ever Serving a Half-Built Graph
A console that polls host inventory, storage, network and alerting concurrently must never show a reader a graph where some sources landed and others did not. This walks through why updating shared state field by field under a mutex fails silently, and how to publish a fully-built snapshot with a single atomic swap instead, with a runnable Go program and a race-tested invariant to prove it.
-
fsGroup Recursive chown Hangs on Large Volumes
Setting fsGroup on a pod makes kubelet walk the entire volume at every mount, not just the first one, and on a volume with millions of files that walk can take hours. Here is why the second mount is the one that hurts, and how to stop paying for it on every restart.
-
Rootless BuildKit: What fuse-overlayfs Costs on a Cold Cache
The standard BuildKit container image needs privileged mode to use the kernel's overlayfs snapshotter, which is unwelcome on a cluster that flags privileged workloads. Rootless BuildKit avoids that by running its snapshotter in userspace via fuse-overlayfs instead, and this article measures, reproducibly, what that substitution costs on a build with a cold cache.
-
Running Ceph on Commodity Hardware: Failure Domains and the Four Things That Bite
Ceph replaces one expensive box with a support contract for replication across ordinary machines you already own, and the trade is real in both directions: it costs a fraction as much and it comes with a set of failure modes that appear only when things are already going wrong. This covers the four that will bite, and includes a runnable check that alerts on the fullest disk in the cluster rather than the average, which is the one that actually decides whether writes keep working.
-
Serving Several Local Models on One GPU with On-Demand Loading
One GPU can hold one large model at a time, but different tasks want different models and restarting a server by hand does not scale past a handful of requests. This describes a proxy that loads a model on first request, keeps it warm, and swaps it out for the next one automatically.
-
Sizing One GPU for Local LLM Inference: VRAM, Quantisation and KV Cache
Fitting a local language model onto one GPU means budgeting three separate pools of VRAM — weights, activations and a KV cache that grows with context length — and the wrong cache format can silently multiply latency without raising an error. This walks through the arithmetic and a way to measure it.
-
Preventing Overselling with a Database CHECK Constraint
Code that reads the remaining stock, decides there is enough, and then writes the new total is a race that two concurrent customers can both win, each believing they got the last unit. This article works through why check-then-decrement logic fails under a database's default isolation level, and builds a schema where a single atomic UPDATE together with a CHECK constraint makes overselling structurally impossible rather than merely unlikely, with a concurrency test to prove it.
-
A Shared Multi-Stage Base Image for a C++ Service Fleet
A dozen C++ services that each install and build the same HTTP framework and JSON library from source turn every Docker build into a multi-minute wait, for a change that touched one function. Here is a shared, versioned base image that compiles those dependencies once, and per-service Dockerfiles that only ever rebuild the service's own code against it.
-
Migrating Redis Consumers from Python to C++ on Constrained Hardware
A dozen Python processes each blocked on a Redis stream look harmless until you add up their idle cost on a small device. Here is how to replace just that consume loop with a C++ equivalent, built and run through Docker so you can measure the trade-off yourself instead of taking anyone's word for it.
-
Sizing Redis maxmemory Against a Stream Trim Threshold
Redis Streams trim themselves as a side effect of XADD, and XADD is refused once maxmemory is reached under the default eviction policy. That leaves a gap where a stream can hit the memory ceiling before it ever gets trimmed down, and stay stuck there. Here is how to reproduce that state, why maxmemory-policy will not save you, and how to size and sequence trimming so it cannot happen.
-
Tuning Ceph Recovery: The Trade Between Degraded Time and Client Latency
Recovery I/O competes with client I/O on the same disks exactly when hardware is already reduced, and the wrong balance either starves applications or leaves the cluster degraded for longer than the next failure can wait. This explains how the mClock scheduler's profiles replace the old manual throttles, and gives a reproducible cephadm setup for measuring the trade-off directly.
-
Capacity Planning Against the Fullest OSD, Not the Average
Ceph's full_ratio applies per OSD, so placement variance means the fullest disk in a cluster can be far ahead of the cluster-wide average, and one OSD crossing that threshold stops writes cluster-wide. This works through why the variance exists, how to see it before it becomes an incident, and gives a script that alerts on the tail of the distribution instead of the mean.
-
CRUSH Hybrid Rules: Pinning the Read Primary to SSD Without Rebalancing
Metadata-heavy pools suffer when their primary replica sits on a spinning disk, but re-pointing the whole pool at SSD means paying for all-flash capacity and triggering a full rebalance. This shows how to write a CRUSH rule that places only the primary on SSD and the remaining replicas on HDD, and how to test it with crushtool before touching a live map.
-
A Layered Storage Benchmark: Isolating Device, Network and Protocol Bottlenecks
A single throughput number from an RBD volume or a CephFS mount hides whether the limit is a slow disk, a saturated replication network, or overhead in Ceph's own protocol path, and each of those has a completely different fix. This builds a benchmark methodology that measures the device, the network and the protocol separately before measuring the full stack, using fio, iperf3 and rados bench against a single-node Ceph container a reader can run without a real cluster.
-
Multi-Stage Docker Builds: Shipping a Runtime Without the Toolchain
Building an application inside the same image you intend to ship means every runtime container carries a compiler, build cache and source tree it will never use again, inflating image size and attack surface for no benefit. This walks through a multi-stage Dockerfile that separates building from running, with a measured image-size comparison a reader can reproduce on a laptop.