Four and a half years on both sides of the same problem. I build the C++, C, Python and Linux systems underneath AI infrastructure, and I design the adversarial problems and harnesses that decide whether generated code is actually correct.
Arun KumarSystems / AI / Embedded
Thanjavur, Tamil Nadu
01
Python → Pybind11 → C++17 → C11 arena
Most agent frameworks inherit the host language’s memory behaviour: allocate freely, pause for GC, pay for it in long sessions. Cerberus moves the hot path below that line, so a long-running session holds a flat memory profile instead of a sawtooth.
Read the architecture02
Accept → bounded queue → fixed worker pool
A thread per client means a thousand clients cost roughly eight gigabytes of stack before any work happens. A fixed pool behind a mutex-guarded queue keeps resource usage flat no matter how many connections arrive.
Read the case study03
STM32F429I · Cortex-M4 · no RTOS, no HAL
An FSM-driven engine on ARM Cortex-M4 with nothing between the game and the panel. Hand-written SPI and I2C drivers for the ILI9341 display and STMPE811 touch controller, and a hunt-and-target opponent seeded from the hardware RNG.
Read the case study
04
Multi-node · arbitration · RTOS timing
Four control modules on one differential pair, terminated at 120 ohm. Arbitration is decided bit by bit: the lower identifier holds the bus and the loser backs off, retries, and loses nothing.
Read the case studyI don’t just build systems. I measure them.
“A number without a method is marketing.” Working principle
Name the constraint before writing anything. Contention shape and failure mode decide the design, not the other way round.
Smaller surfaces, explicit failure paths, and comments that explain the constraint rather than the syntax.
Benchmark against a named baseline on a stated machine, keep the harness in the repo, and say plainly when a result is single-machine rather than rigorous.
Most latency tails I have chased came from allocation behaviour, not algorithms. Find what is holding the rail down, and prove it.
Arenas, slabs and explicit lifetimes make performance predictable, and make ASan and Valgrind output meaningful instead of noisy.
Cerberus versus LangChain on the same task, on the same machine. Resident memory sampled after the first completed agent step, so lazy imports and model-client initialisation are included on both sides.
Single-machine figures from my own Linux workstation, not a controlled lab. Directionally reliable and reproducible on request. I would not present them as vendor benchmarks.
Method & full benchmarks~2 ns
Arena allocation
Bump pointer, AVX2-aligned
< 0.5 ms
Context prune
O(1), independent of history
272k+
Hot-loop ops/sec
Core state machine, one thread
Systems / AI / Embedded engineer
I work at the boundary where software meets the machine it runs on. Before the systems work there were two years of board-level repair, which is where the habit came from: never replace a part you cannot first prove is wrong.
That habit is the same one I run on a profiler now, and it is why every performance number on this site arrives with the machine it was measured on.
Adversarial problem design and Docker-sandboxed evaluation harnesses for frontier model validation.
150+ C++, Python and Linux solutions reviewed; coding agents benchmarked head to head on systems tasks.
120+ C++ submissions reviewed and debugged, feeding structured assessments into fine-tuning datasets.
Full-time programme in Linux internals, RTOS, TCP/IP and ARM, ending in a multi-node CAN control project.
Board-level diagnostics and BIOS recovery across Intel, AMD and Apple hardware. Schematic tracing, not part swapping.