Separatrix

C++ & Python

Structural testing framework for C/C++ codebases that localizes faults by scoring how much small input perturbations make control flow diverge, rather than by counting coverage. An LLVM instrumentation pass compiles targets to a behavioral graph (nodes are functions and basic blocks, edges carry branch conditions and source locations) and injects a runtime that records per-edge traversal counts into bucketed multisets. A chaos engine generates perturbations and a divergence detector diffs each node's outgoing-edge profile against baseline to produce a sensitivity map. The core mechanism is divergence localization: crediting every node whose profile diverges across the full corpus, not just the first bifurcation point, which collapses to near-chance on staged bugs. Validated on Magma fault benchmarks across three targets forming an alignment continuum: lua, where SBFL is inapplicable because debug-subsystem bugs don't surface in observable output, achieves region-level AUC 0.97 vs coverage 0.89 on a bug-blind corpus; sqlite3 shows divergence still beating coverage (0.61 vs 0.47) under weak corpus-fault coupling; md4c is the misaligned pole where input variation concentrates on a bug-irrelevant hot loop, matching SBFL rank at top 2% but not beating it.

View Project →

Agentc

Rust & Python

JIT optimization runtime that intercepts LLM API calls in multi-step agent pipelines and reduces token spend without touching application code. Ships three components: a profiler that monkey-patches provider clients at import time, capturing every inference call (full prompt/response, token counts, latency, model, cost) into a structured SQLite trace with OTel gen_ai.* semantic conventions and five waste detectors that surface dollar-denominated savings estimates; a semantic memoization layer using exact-hash lookup on the hot path and LSH over 256-dimensional embeddings as a secondary tier for semantically-similar prompts; and a JIT optimizer that applies cost-ranked rewrite rules (ContextCompress, ParallelBranch, ModelDowngrade, StateDrop) only after accumulating enough observations on hot call sites, with shadow-mode sampling at 2% providing ground-truth divergence to enforce per-rule accuracy budgets. Cold calls pass through unchanged; optimization engages only when the empirical cost model has real data to rank proposals. Rust core with PyO3 bindings handles trace ingestion and embedding capture; the profiler's redundant-call detector guides promotion of high-repetition sites into the memoization layer.

View Project →

tbjit-alloc

C++ & Python

A JIT specializing memory allocator that interposes on malloc/free via LD_PRELOAD and compiles per-call-site allocation routines at runtime. Each call site is identified by a hashed return address; a runtime profiler accumulates per-site histograms of request sizes and object lifetimes into sparse fixed-capacity tables, and once a site crosses a heat threshold the JIT emits a specialized fast path tuned to its observed behavior, picking among strategies like bump allocation and thread-local free lists. Memory is carved from 2 MiB segments backed by transparent hugepages, with a pagemap holding one bit per region to make free-path is_managed checks O(1) instead of a segment scan. A lifetime classifier tags sites Reap/Hold/Unknown to drive segment reclamation and a conditional-hugepage policy, while shadow-mode sampling continuously validates JIT'd paths against the generic allocator and deoptimizes on any divergence. Under realistic LD_PRELOAD deployment the interposition trampoline dominates and per-call latency lands at parity with glibc; the lifetime-aware THP policy cuts allocator RSS by up to 74% (41% end-to-end) on allocation-bound workloads where partially-filled segments would otherwise fault whole hugepages.

View Project →

Cache Explorer

C++

A full-stack cache profiling tool built on a custom LLVM instrumentation pass. Compiles C, C++, Rust, and Zig with injected memory tracing, runs the trace through a multi-core cache simulator with MESI coherence, TLB simulation, 3C miss classification, and prefetch modeling, and streams results to a Monaco-based web UI in real time. Hardware presets include Apple M-series, Intel Core, AMD Zen, and custom configurable hierarchies. Detects false sharing, supports selective instrumentation for large codebases, and sandboxes untrusted code via Docker.

View Project →

View all 15 projects →

Projects

Projects