Stephen E Verderame

About

Hi, I’m Stephen. I’m mainly interested in programming languages (PL) and compilers, but I’m also fond of computer architecture, and graphics. Right now, I’m particularly interested in compiler technologies and languages for heterogeneous, parallel, or high-performance computing. However, I like a broad range of PL-related things.

At Cornell, I was a part of the Capra research group where I created a frontend for Caiman, a research IR and compiler for heterogeneous programming that allows independent specification of device communication, allocations, and values computed to ease design space exploration and optimization.

I also compete in XC mountain bike races (with the occasional road race) and enjoy cooking. I like to think of myself as a mildly competitive amateur XC racer.


Latest Posts

Jun 3, 2024

Chordal Graph Register Allocation

Register allocation is commonly framed as a vertex coloring problem on an interference graph, where vertices represent virtual registers and edges connect two virtual registers that interfere (belong to the same live-out set of a program point). A classic method, due to Chaitin1, is to do register allocation via graph coloring with a set of heuristics to make the problem more easily computable, as vertex coloring is an NP-Hard problem. Read more


May 31, 2024

A Year in Caiman

Caiman is a language designed for heterogeneous programming that formalizes the communication between devices, allocations, and computations performed. This post details the current state of the Caiman Frontend and includes a brief overview of the implementation of some features such as lowering to continuation passing style and the e-graph-based type inference. Background In heterogeneous programming, communication and synchronization between devices is extremely important for performance, but it’s not at all obvious what the optimal communication strategy should be. Read more


Jan 12, 2024

Z3-Powered Constraint Solving for Static Analysis

In a previous post, we discussed implementing an analysis to detect potential uses of null pointers. The workhorse of this analysis was an interval analysis that could (conservatively) determine all possible values an integer could take on. We used this information to prove whether or not an array access could be determined to always be in-bounds. This worked, but it could not handle cases such as a dynamically sized buffer. Suppose we know that a buffer has $a$ elements. Read more


All Posts

Projects