Applications which communicate extensively over a network can be highly sensitive to network performance. This is especially true in a wireless network, where mobile hosts must cope with large variations in available bandwidth. While extensive research has been done on adapting applications to work well in low-bandwidth environments, an application that expects its network operations to complete relatively quickly can be adversely affected even if it only receives half its expected bandwidth.
The Modeless Adaptation project focuses on how applications that perform RPC-like communication with a remote server can be structured in order to perform automatic adaptation to variations in bandwidth. Some examples of this type of application are web browsers, distributed file system clients and mail client programs. Client-server applications are of particular interest because they frequently exhibit bursty behaviour or perform multiple simultaneous interactions with a server, for which traditional stream-oriented adaptation techniques can be ineffective.
Adaptation without modes
Previous work in bandwidth-oriented adaptation for mobile clients is typified by "modal" schemes for adaptation, under which an application has a number of modes for communication, corresponding to different ranges of available bandwidth. If available bandwidth decreases, the application restructures its communication by switching into a mode that requires less bandwidth, which results in a decrease in data quality or other semantic changes such as reduced cache consistency. Examples of such an approach are the Coda file system, the Rover toolkit, the Odyssey system, quality levels in video streaming, and transcoding schemes for web browsers. Modal adaptation has two key disadvantages: first, devising a suitable set of modes may be difficult or impractical for RPC-style applications; second, a modal scheme may necessarily under-utilise available bandwidth. Enforcing modes requires setting bandwidth thresholds to control mode switching, and thresholds may over-constrain the application's use of bandwidth. As an example, a two-mode application may find itself with almost enough bandwidth to operate in the high-bandwidth mode, but since it is below the threshold between modes, it must behave as though it has the expected amount for the low-bandwidth mode.
Our work is concerned with supporting an alternative style of adaptation that is more tailored to RPC-style applications, which we have termed "modeless adaptation". The key insight behind this technique is that client-server applications often conduct concurrent interactions with a server, and not all of the client-server interactions are necessarily of the same degree of importance. For instance, some may be vital for the client to operate correctly, such as downloading a web page, and some may improve the "user experience" or improve performance, such as downloading images or prefetching data before it is actually required. Given such an application, it is possible to adapt to bandwidth reductions by controlling the order in which RPCs are issued, without recourse to modes. The application is then able to gracefully adjust to bandwidth decreases and efficiently utilise all the available bandwidth, since it adapts at a fine-grained, per-RPC level.
The initial stage of the project has investigated how modeless adaptation is best supported within a network protocol. The interfaces to commonly-used network protocols such as TCP present insufficient information and control over data transmission for them to support modeless adaptation directly. Consequently we designed and implemented ATP, an adaptive transport protocol that supports adaptation through the use of message priorities. Using ATP, RPCs which are necessary for application correctness are initiated at a high priority, RPCs which improve performance but may be delayed are at low priority, and intermediate priority levels are available for implementing particular application semantics. Experiments have demonstrated that simple applications using ATP for modeless adaptation are able to outperform modal alternatives.
Modeless application design
A shortcoming of investigating modeless adaptation at the level of a network protocol is that it oversimplifies application semantics. The real difficulty in designing an application to use modeless adaptation lies in determining which RPCs are vital, and which can be delayed, and assigning priorities to them appropriately. In fact, consecutive RPCs issued by an application may well incorporate dependencies, in which case it is necessary to ensure that the essential dependencies are retained.
The principal application we have worked on is a cache manager for MFS, a distributed file system tailored towards mobile clients. Since a file system cache manager operates on behalf of multiple processes, and file systems have sophisticated semantics, MFS has proved to be an interesting example of an adaptive application. The basic design of MFS is similar to the Andrew File System and Coda, and ATP is used to add priorities to RPCs so that blocking operations such as fetching files are made at high priority, various categories of updates to files are made at lower priorities, and prefetching files is at the lowest priority. By controlling the way in which different types of RPCs interact, MFS is able to achieve performance improvements over more conventional designs at a wide variety of bandwidth levels.
The design of MFS has also revealed more about the feasibility of modeless adaptation: for instance, a considerable performance improvement can be made by transmitting writes to files over the network asynchronously, but this sacrifices strong consistency. MFS incorporates a cache consistency algorithm to provide a high degree of consistency for accesses to heavily-shared files without penalising bandwidth-constrained writers.
Publications
Talks