• Flexible and Efficient Sharing of Protected Abstractions (1998)
• Vassal: Loadable Scheduler Support for Multi-Policy Scheduling (1997)
• RFS: A Mobile-Transparent File System for the Rover Toolkit (1997)

• An Infrastructure for Loadable Scheduling Policies
• RFS (Rover File System)
• VNP (Virtual Network Protocol)

Last summer I was an intern in the Operating Systems group at Microsoft Research and worked with Mike Jones. The main motivation behind this work was my belief that operating systems should be different from what they are today. An OS should take from applications a set of requirements and then try to satisfy them, as opposed to forcing applications to conform to a set of fixed policies. An example would be process/thread scheduling.

General purpose computer systems need to execute a group of increasingly diverse jobs, so they end up with a single scheduling algorithm that represents a compromise. Such a compromise that is quite common today are priority-based schedulers. However, it is extremely hard to properly map requirements such as predictability, throughput, fairness, turnaround time, waiting time, or response time onto a fixed set of priorities. In addition, applications do not have access to global information when choosing priorities, which can lead to chaos in the system. Priorities are a rather primitive way of describing the relative performance requirements of processes.

In order to provide optimal scheduling performance, the operating system would need the ability to predict the future. However strange this may seem, it is not all that hard to do when semantic information exists regarding an application's intentions. Therefore, we need a system in which applications have the ability to express their requirements and then the operating systems can cater to them.

I am currently writing a paper with Mike in which we present a system that separates policy (scheduler) from mechanism (dispatcher) and externalizes the policy component. Scheduling policies can be dynamically loaded and unloaded at run-time and they are concurrently used by the kernel's dispatcher. The characteristics of a certain scheduling class need only be known to the particular policy component for that class and to the process that declares itself as belonging to the class. We describe a "proof-of-concept" real-time scheduler that can coexist with the native scheduler. Our results are encouraging: while most applications run unaware of the multiple scheduling policy, real-time applications get predictable scheduling to within a few microseconds.

Such flexibility not only enhances applications' performance (such as multimedia using the real-time scheduler), but it also changes the programming paradigm. It becomes much easier for programmers to write applications because the OS does not have to be tricked into doing what app writers want it to do: the applications states explicitly its requirements and the OS either guarantees that it will satisfy them or it informs the application that this might not be possible. We show that an operating system with multiple scheduling policies can offer applications much greater flexibility than traditional operating systems.

I used to work together with Anthony Joseph, Josh Tauber, and Frans Kaashoek on a toolkit for mobile information access, called Rover. Most of my work is described in RFS: A Mobile-Transparent File System for the Rover Toolkit, which we presented as a Works-In-Progress poster at the 16th ACM Symposium on Operating Systems Principles (SOSP).

Rover addresses the challenges of mobile environments, such as intermittent connectivity, limited bandwidth, and channel-use optimization. The toolkit combines two new ideas to solve these issues for ``roving'' mobile applications: Relocatable Dynamic Objects (objects with a well-defined interface that can be dynamically loaded into a client computer from a server, or vice versa, to reduce client - server communication requirements) and Queued Remote Procedure Calls (a communication system that permits applications to make non-blocking RPC requests even when a host is disconnected, with requests and responses being exchanged upon network reconnection).

I wrote the Rover File System, that enables applications to run without any modification on Rover clients. The goal was to provide the last component of a complete development environment for mobile applications. Appication designers now have a simple choice: those portions of an application's state that are difficult to port, that change infrequently, or exhibit update conflicts that are easy to detect and resolve can rely on RFS for storage. On the other hand, application state that is sensitive to bandwidth and latency, or where conflicts may be complicated to detect or handle, can use the full functionality of Rover's object management support as well as conflict resolution and detection. We expect this to significantly ease the process of adding mobile-awareness to applications.

While an intern at IBM Research (T.J. Watson Center) I wrote the Virtual Network Protocol (VNP), which enables mobile computers to interconnect via Personal Messaging Units (PMU), such as pagers.

The motivation behind this research was the fact that the recent PMU's had advanced to the point where using them as network interfaces for the paging network was feasible. Skytel had released their 2-way pagers, which, unlike traditional pagers, allow the units to initiate pages (messages), not only receive them. These pagers can also be connected via a serial cable to the COM port of a PC or laptop, thus allowing the pager to be programmed. Even though the purpose of the new devices was to send alphanumeric pages, any type of data could be sent, with appropriate encoding, over the paging network. What made this solution to mobile network communication very attractive was that it could be done without having to purchase any hardware in addition to the 2-way pager that most users would be wearing anyway as part of their job duties.

VNP provides most of the services that a TCP/IP stack provides, in a manner absolutely transparent to the mobile application. It tailors the packets according to the specifics of short messaging networks. VNP performs packet retransmission and reordering to provide reliable stream communication and provides an interface for easy plug-in of encryption, compression, and encoding modules. The latter two are crucial because the networks with which VNP works have small maximum packet sizes and they don't always support the entire range of byte values (some even restrict the data to being purely alphanumeric).