When at ETH, I was working on the Barrelfish multikernel operating system. In Barrelfish, we address scalability issues of traditional kernels on multicore machines. Instead of relying on cache-coherent shared memory to share operating system data between cores, we run an independent kernel on every core. These kernels do not share any state. All communication is explicitly done via message passing.

During my PhD, I was investigating deployment of applications on multicore machines in the context of Shoal. Applications work on replicated and partitioned state. Machine characteristics need to be considered for implementing efficient management of such state. These characteristics are often not known at time of development. Additionally, manually adding code to deal with the specifics of individual machines is tedious.

I propose a distribution layer, which abstracts the global state such that programmers use an interface to access state. This abstraction allows agile placement and management of global state and binding of algorithms to handle that state at runtime. This approach allows efficient access to global state without the programmer providing any machine specific code.

Earlier work I did in the context of Barrelfish was exploring message passing support in hardware using the Intel SCC research machine for prototyping. Instead of programming an FPGA or simulating a whole multicore machine, we dedicated every second core on the SCC to emulate our message passing hardware.