Software
The group's research ships as software: compilers, languages, and libraries. Together they form a connected line of work on making computation portable across data representations and machines.
Compilers and libraries that make tensor and array code portable across dense and sparse formats.
Sparse tensor & array compilation
A compiler for a sparse array language that supports shape operators — such as reshaping and concatenating sparse arrays — alongside compute operators, generating fused code over reshaped views.
Sparse tensor & array compilation
A compiler that generates fast kernels for tensor algebra expressions over dense and sparse tensors from a high-level index notation.
Sparse tensor & array compilation
A library that adds sparse tensors and JIT-compiled kernels to PyTorch with a compatible API, automating loop ordering, tiling, and format inference for sparse machine-learning workloads.
Sparse tensor & array compilation
A tensor algebra compiler, built on TACO, that binds parts of an expression to external hand-tuned functions from other libraries and generates the rest, searching for the best mapping.
Sparse tensor & array compilation
A compiler that lowers user-specified systems of recurrence equations, with data-structure and scheduling directives, into imperative C loops over dense and sparse arrays.
Compilers and runtimes that scale sparse and dense computation across machines.
Distributed sparse computation
A compiler for distributed dense tensor algebra that lets users specify how data is distributed and how computation is distributed independently, then compiles to a task-based runtime.
Distributed sparse computation
A distributed, accelerated drop-in replacement for the scipy.sparse library that runs unmodified sparse SciPy programs across clusters of CPUs and GPUs.
Intermediate representations and iteration abstractions that other compilers build on.
Compiler representations & iteration models
A Lean 4 compiler and formalization of indexed streams — an operational intermediate representation for the fused execution of contraction programs across sparse tensor and relational algebra.
Compiler representations & iteration models
A language for structured coiteration that breaks iteration over structured and sparse arrays into cases the compiler can specialize, implemented in the open-source Finch array compiler.
Languages that raise the level of abstraction for a specific domain.
Domain-specific languages
A programming language that lets a simulation be written simultaneously as a hypergraph of local update functions and as global vectors, matrices, and tensors.
Systems that generate compilers, interpreters, and fast baseline JITs.
Meta-compilers, JITs & virtual machines
A technique that generates machine code by copying pre-built binary stencils and patching in constants and addresses, producing baseline code far faster than a traditional compiler backend.
Meta-compilers, JITs & virtual machines
A meta-compiler that takes a dynamic language's bytecode semantics, written as C++ functions, and generates a high-performance interpreter and a Copy-and-Patch baseline JIT.
Compilers and simulators targeting reconfigurable and dataflow hardware.
Accelerator & dataflow compilation
A streaming-dataflow abstract machine and intermediate representation for compiling sparse tensor algebra to reconfigurable and fixed-function dataflow accelerators.
Accelerator & dataflow compilation
A Rust framework for building fast parallel simulators of dataflow systems, modeling computation as contexts that communicate over latency-bearing channels.