Our group works on research covering a number of areas in operating systems, distributed systems, computer architecture and security.
This project explores the co-design of distributed systems with their network layer, with a focus on providing high-performance replication and coordination protocols. Using techniques like software-defined networking to build new network primitives, we enable new designs for distributed protocols. These include Speculative Paxos and Network-Ordered Paxos, replication protocols that use the network to order requests and nearly eliminate performance overhead. Eris, a new transaction processing system, avoids both transaction and replication coordination overhead entirely, providing an order-of-magnitude speedup.
Modern datacenter applications struggle with the need to access thousands of servers while still providing a fast response time to the user. In these situations, the user’s overall request is not complete until the slowest of the subrequests has completed, making it important to design network services that offer not just low latency but predictable latency. We are developing techniques for building systems that offer predictable response time.
Emerging non-volatile memory technologies such as phase-change memory, spin-torque memory, and flash-backed DRAM blur the line between volatile memory and persistent storage, challenging a distinction that has existed since the earliest days of operating systems. Our group is rethinking fundamental operating system abstractions for this new environment.
Our current work is exploring process models for this environment, where the state of a running process and an executable on disk do not need to differ. We are organizing applications around a persistent process container abstraction that encapsulates all application state. Process containers are persistent, surviving OS and hardware crashes, and can be rolled back to earlier states.
Transactional Application Protocol for Inconsistent Replication, or TAPIR, is a new protocol for linearizable distributed transaction built using replication with no consistency guarantees. By eliminating consistency, and thus coordination, from the replication layer, TAPIR provides the same transaction model and consistency guarantees as existing systems like Spanner with better latency and throughput.
Transactional storage systems are popular due to their simplicity, performance, and scalability. Such systems are gradually evolving and some recent ones now support transactions, which are a convenient means to coordinate access to data shared among many clients. Examples of such systems include Hyperdex Warp, CockroachDB, Walter, and TAPIR. Because these systems are so new, there are not many ways to assess how well they implement transactions. To address this shortcoming, we propose Transtorm, a benchmark suite for such transactional key-value storage systems (TKVS).
Arrakis is a new operating system that is designed around recent application and hardware trends: Applications are becoming so complex that they are miniature operating systems in their own right and are hampered by the existing OS protection model. On the hardware side, virtualization technologies and I/O devices have become increasingly sophisticated and take on more and more functions traditionally carried out by the operating system.
In Arrakis, we ask the question whether we can remove the OS entirely from normal application execution. The OS only sets up the execution environment and interacts with an application in rare cases where resources need to be reallocated or name conflicts need to be resolved. The application gets the full power of the unmediated hardware, through an application-specific library linked into the application address space.
Agate is a new trusted distributed runtime system that gives users control over how mobile/cloud applications share sensitive user data collected on mobile devices (e.g., photos, GPS location). Agate combines aspects of access control and information flow control to allow applications to share user data in application-specific ways, while enforcing user policies without trusting the application or the application programmer.
Sapphire is a new distributed programming platform that provides customizable and extensible deployment of mobile/cloud applications. Sapphire’s key design feature is its distributed runtime system, which supports a flexible and extensible deployment layer for solving complex distributed systems tasks, such as fault-tolerance, code-offloading, and caching. Rather than writing distributed systems code, programmers choose deployment managers that extend Sapphire’s kernel to meet their applications’ deployment requirements. In this way, each application runs on an underlying platform that is customized for its own distribution needs.