Projects - search

Recent experiments have revealed surprisingly large performance variation across repeated executions of some applications, even after taking standard benchmarking precautions. One possible explanation is that ASLR produces memory layouts with significantly different performance characteristics. If so, an important challenge is determining how these layouts differ and identifying the memory-layout properties responsible for the observed performance changes.

A possible research direction is to develop techniques and tools for detecting ASLR-induced performance variation, comparing memory layouts across executions, and identifying the characteristics that distinguish faster and slower runs. Such a tool could potentially build upon HeapLENS and leverage AI-assisted analysis to help explain observed performance differences.

Tags: C/C++, Data Structures, Multithreading, Memory Management, Operating Systems, Systems, 2nd Year +

Professor T. Brown recently developed a system called HeapLENS to help researchers automatically examine the memory layout of multithreaded applications. HeapLENS is specifically designed to produce compact, high-quality, curated output suitable for AI-driven analysis. While HeapLENS output can already enable AI agents to improve application memory layouts by a significant margin, the current workflow invokes HeapLENS only once and uses its output only once. A natural research direction is therefore to adapt HeapLENS to support repeated interaction with an AI agent, enabling an iterative optimization cycle in which incremental changes can be proposed, evaluated, and refined.

Tags: C/C++, Data Structures, Multithreading, Memory Management, Operating Systems, Systems, Artificial Intelligence, 2nd Year +

Professor T. Brown and collaborators recently designed a concurrent version of the van Emde Boas tree that incorporates a number of novel space optimizations and can outperform other state-of-the-art concurrent ordered sets by a large margin. However, this data structure relies on hardware transactional memory (HTM) for synchronization. The goal of this project is to extend this work to universally available synchronization mechanisms for systems without HTM support, with optimistic concurrency control (OCC) being one natural direction.

Tags: C/C++, Data Structures, Multithreading, Systems, 2nd Year +

For secure multiparty computation (MPC), our goal is for parties 1 to n to securely compute f(x1, …, xn) where xi is the private input of party i. Our security condition is for the messages each party sends and receives during the computation of f to reveal no more information than its input and output.  This allows the parties to collaboratively compute a function over their private inputs while maintaining privacy.

One primitive used to implement MPC algorithms is function secret sharing, which is a way to split a function f among multiple parties such that each party can evaluate f on a common input x and obtain shares of the output f(x). We investigate the use of function secret sharing to implement sorting algorithms in MPC since sorting is a common subroutine in many algorithms. We then benchmark these implementations against state-of-the-art private sorting algorithms.

Tags:  Algorithms, Cryptography, C/C++, Security, All Years

In this project, students will evaluate a recently proposed CDC algorithm and compare it against state-of-the-art techniques. Working in teams, students will use open-source implementations and real-world datasets to conduct benchmarking experiments and measure metrics such as chunking throughput, chunk-size distributions, and deduplication efficiency. Team members will focus on complementary tasks, including experiment design, dataset preparation, benchmarking, data analysis, and visualization. The primary goal during the program is to evaluate the algorithm and understand its strengths and limitations. Students who continue beyond the program may also explore integrating the algorithm into an open-source benchmarking framework and investigating further improvements to chunking techniques.

Tags: Systems, Algorithms, C/C++, Go, Python, All Years

AI coding agents can attempt real compiler work, but they stumble on implementing optimizations: asked to add a rewrite rule to LLVM's InstCombine pass, they often produce patches that miscompile programs, break tests, or land in the wrong place, and our benchmarking shows agents fail many such tasks. The open question is what feedback closes the gap: when the agent is handed a correctness counterexample, a profitability estimate, or a regression result, does its success rate improve, and which helps most? This project answers that on a fixed open model in a fully observable loop.

Tags: Compilers, Artificial Intelligence, Python, Command Line, C/C++, 2nd Year +, Experienced 1st Years

Every time you compile a C or C++ program, the compiler quietly rewrites your code thousands of times to make it faster, e.g. "x + 0 -> x". In LLVM (behind Clang, Swift, and Rust), one pass called InstCombine performs an enormous share of these rewrites. We have built an open-source tool, instcombine-debugger, that patches LLVM to record every transformation InstCombine performs. This project extends that tool to capture richer traces, turning an opaque, heavily-used optimizer into something we can observe and understand.

Tags: Compilers, Python, Command Line, C/C++, 2nd Year +, Experienced 1st Years