Traditional file system implementations do not allow applications to control file caching replacement decisions. We have implemented two-level replacement, a scheme that allows applications to control their own cache replacement, while letting the kernel control the allocation of cache space among processes. We designed an interface to let applications exert control on replacement via a set of directives to the kernel. This is effective and requires low overhead. We demonstrate that for applications that do not perform well under traditional caching policies, the combination of good application-chosen replacement strategies, and our kernel allocation policy LRU-SP, can reduce the number of block I/Os by up to 80%, and can reduce the elapsed time by up to 45%. We also show that LRU-SP is crucial to the performance improvement for multiple concurrent applications: LRUSP fairly distributes cache blocks and offers protection against foolish applications.

Operating system research has endeavored to develop micro-kernels that provide modularity, reliability and security improvements over conventional monolithic kernels. However, the resulting kernels have been slower, larger and more error-prone than desired. These efforts have also failed to provide sufficient application control of resource management required by sophisticated applications. This paper describes a caching model of operating system functionality as implemented in the Cache Kernel, the supervisor-mode component of the V++ operating system. The Cache Kernel caches operating system objects such as threads and address spaces just as conventional hardware caches memory data. User-mode application kernels handle the loading and writeback of these objects, implementing application-specific management policies and mechanisms. Experience with implementing the Cache Kernel and measurements of its performance on a multiprocessor suggest that the caching model can provide competitiv...

Message-based communication offers the potential benefits of providing stronger specification and cleaner separation between components. Compared with shared-memory interactions, message passing has the potential disadvantages of more expensive data exchange (no direct sharing) and more complicated programming. In this paper we report on the language, verification, and run-time system features that make messages practical as the sole means of communication between processes in the Singularity operating system. We show that using advanced programming language and verification techniques, it is possible to provide and enforce strong system-wide invariants that enable efficient communication and low-overhead software-based process isolation. Furthermore, specifications on communication channels help in detecting programmer mistakes early—namely at compile-time—thereby reducing the difficulty of the message-based programming model. The paper describes our communication invariants, the language and verification features that support them, as well as implementation details of the infrastructure. A number of benchmarks show the competitiveness of this approach.

Today’s high-end massively parallel processing (MPP) machines have thousands to tens of thousands of processors, with next-generation systems planned to have in excess of one hundred thousand processors. For systems of such scale, efficient I/O is a significant challenge that cannot be solved using traditional approaches. In particular, general purpose parallel file systems that limit applications to standard interfaces and access policies do not scale and will likely be a performance bottleneck for many scientific applications. In this paper, we investigate the use of a “lightweight” approach to I/O that requires the application or I/O-library developer to extend a core set of critical I/O functionality with the minimum set of features and services required by its target applications. We argue that this approach allows the development of I/O libraries that are both scalable and secure. We support our claims with preliminary results for a lightweight checkpoint operation on a development cluster at Sandia. 1

Dedicated operating systems for embedded systems are fast being phased out due to their use of manual optimization, which provides high performance and small footprint, but also requires high maintenance and portability costs every time hardware evolves.

Abstract not found

The Linux kernel stack has a fixed size. There is no mechanism to prevent the kernel from overflowing the stack. Hackers can exploit this bug to put unwanted information in the memory of the operating system and gain control over the system. In order to prevent this problem, we introduce a dynamically sized kernel stack that can be integrated into the standard Linux kernel. The well-known paging mechanism is reused with some changes, in order to enable the kernel stack to grow. 1.

This paper introduces the design philosophy and underlying principles of WYKIWYG, a language to implement high performance network services. A WYKIWYG compiler, unlike compilers for traditional languages, is empowered with the knowledge of underlying OS mechanisms such as task management, memory management, the device I/O interface etc. generates code which is specifically optimized for these mechanisms, and can even go as far as modifying or extending them in a controlled manner. Preliminary experiments with manually compiled code show that such code can improve the throughput of network services by up to an order of magnitude. 1

Sensor networking has emerged as a promising tool for monitoring and actuating the de-vices of the physical world, employing self-organizing networks of battery-powered wire-less sensors that can sense, process, and communicate. Such networks can be rapidly de-ployed at low cost, enabling large-scale, on-demand monitoring and tracking over a wide area. Energy is the most crucial and scarce resource for such networks. However, since sensor network applications generally exhibit specific limited behaviors, there is both a need and an opportunity for adapting the network architecture to match the application in order to optimize resource utilization. Many applications–such as large-scale collaborative sensing, distributed signal process-ing, and distributed data assimilation–require sensor data to be available at multiple reso-lutions, or allow fidelity to be traded-off for energy efficiency. In this thesis, I develop an adaptive cross-layered sensor network architecture that enables multi-scale collaboration and communication. Analyzing the unique characteristics of sensor networks, I identify cross-layering and adaptability to applications as the primary design principles needed to

Abstract not found