Projects

Note: I place most new projects on GitHub.

• autopiper, an open-source high-level hardware description language with an autopipelining compiler that produces Verilog. This was a side-project while I was at Google (hence its copyright). Its goal was to explore ways to build abstractions to describe common pipeline idioms (forms of flow control and queueing, flush/restart, speculation, renaming, and the like) without introducing unnecessary "magic" or large and unpredictable semantic gaps as in conventional (C-to-gates) high-level synthesis. It has reached a proof-of-concept stage of functionality but I (sadly) don't have the time to hack on it much these days.

• nk, a small "nanokernel" green-threads/workqueue runtime to support fine-grained parallelism on Linux/x86-64. The library also has message-passing and several synchronization primitives. Written as a small and simple runtime for my current (software parallelization) research at CMU.

• boolean_expression (docs), a library for building and evaluating Boolean expressions, BDDs (binary decision diagrams), and performing expression simplification via cubelists. Written in Rust. This was written to support a research project (maintaining Boolean predicates at runtime) but is also useful as a standalone library.

• x86oo (not public), a microarchitectural simulator that models recent out-of-order x86-64 cores. This simulator was developed in support of my Heterogeneous Block Architecture project at CMU. Unlike most academic microarchitectural simulators, x86oo's model is execute-at-execute, which means that it models pipeline stages and hardware algorithms with sufficient detail to actually execute the instructions (most academic simulators "cheat" by executing instructions first (execute-at-fetch) or reading a trace and then approximating timing with a simpler timing model). I have released x86instlib, the x86 model underlying x86oo's decode and execute stages (in turn based on parts of PTLsim).

• speck, the small, portable, efficiently-coded kernel: a hobby in 2001—2002. It runs on bare x86 and implements preemptive multitasking, message passing, and dynamic kernel-module loading.

• undergrad comparch tidbits: a pipelined CPU in Verilog, dynamic translation firmware for a custom ISA implementing a stack-based machine on RISC hardware, and some system-level tools (simulators, assemblers) from the Computer Architecture two-semester sequence at ND in 2007-2008.

• scomp, the Spreadsheet COMPiler. This is a little utility which takes a description of simulation experiment results (nominally, from a microarchitectural simulator, like a computer architect might use), parses them, and evaluates arbitrary expressions and user-defined metrics to produce ready-to-go spreadsheets and plots.

• jrs, the Job-Running System. This is a very lightweight batch-job system for compute clusters. It fills the same niche as Condor or PBS, but is much, much simpler. It takes a Condor-like file format as a job description, has a lightweight metadata server to split the cluster's cores evenly among users, and has a client which connects directly to compute nodes to spawn and manage jobs. It has almost no features and thus has relatively few ways to break.

• digilight, a microcontroller-based low voltage halogen lighting system controlled via DMX, a standard lighting-control protocol.

• nixie, a hardware design and microcontroller firmware for a Nixie tube-based digital clock. This is a work-in-progress.

• pong (tarball), an implementation of the classic game of Pong in hardware for a Digilent FPGA board with a Xilinx Spartan3E FPGA. It displays to a VGA monitor and takes input from a PS/2 keyboard.

• sudoku solver (and tutorial-style writeup), circa junior year of high school (2005), rewritten in JavaScript in 2016 to remove need for server-side CGI. The algorithm performs a backtracking-based brute-force exploration of the solution space, which is very fast in practice for most puzzles.

• A Rust (v0.5) implementation of the Sudoku solver. Works in Rust as it existed circa January 2013, but no longer compiles due to significant changes to the language. This was a project to learn the language and was quite fun.

• A Haskell implementation of the Sudoku solver. There's probably a way to do it much more cleanly by taking deeper advantage of lazy evaluation to do the "bound" part of branch-and-bound. Or maybe wrap the board updates more cleanly as a Monad. I haven't really refined this too much.