[Show abstract][Hide abstract] ABSTRACT: We present Adaptive Multi-Policy disk caching (AMP), which uses multiple caching policies within one application, and adapts both which policies to use and their relative fraction of the cache, based on program-context specific information. AMP differentiate disk requests based on the program contexts, or code locations, that issue them. Compared to recent work, AMP is unique in that it employs a new robust scheme for detecting looping patterns in access streams, as well as a low-overhead randomized way of managing many cache partitions. We show that AMP outperforms non-detection-based caching algorithms on a variety of workloads by up to 50% in miss rate reduction. Compared to other detection- based schemes, we show that AMP detects access patterns more accurately for a series of synthesized workloads, and incurs up to 15% fewer misses for one application trace. 1 Detection (classiÞcation) Based Caching
[Show abstract][Hide abstract] ABSTRACT: This paper presents Capriccio, a scalable thread package for use with high-concurrency servers. While recent work has advocated event-based systems, we believe that thread-based systems can provide a simpler programming model that achieves equivalent or superior performance.By implementing Capriccio as a user-level thread package, we have decoupled the thread package implementation from the underlying operating system. As a result, we can take advantage of cooperative threading, new asynchronous I/O mechanisms, and compiler support. Using this approach, we are able to provide three key features: (1) scalability to 100,000 threads, (2) efficient stack management, and (3) resource-aware scheduling.We introduce linked stack management, which minimizes the amount of wasted stack space by providing safe, small, and non-contiguous stacks that can grow or shrink at run time. A compiler analysis makes our stack implementation efficient and sound. We also present resource-aware scheduling, which allows thread scheduling and admission control to adapt to the system's current resource usage. This technique uses a blocking graph that is automatically derived from the application to describe the flow of control between blocking points in a cooperative thread package. We have applied our techniques to the Apache 2.0.44 web server, demonstrating that we can achieve high performance and scalability despite using a simple threaded programming model.
[Show abstract][Hide abstract] ABSTRACT: Event-based programming has been highly touted in recent years as the best way to write highly concurrent applications. Having worked on several of these systems, we now believe this approach to be a mistake. Specifically, we believe that threads can achieve all of the strengths of events, including support for high concurrency, low overhead, and a simple concurrency model. Moreover, we argue that threads allow a simpler and more natural programming style. We examine the claimed strengths of events over threads and show that the weaknesses of threads are artifacts of specific threading implementations and not inherent to the threading paradigm. As evidence, we present a user-level thread package that scales to 100,000 threads and achieves excellent performance in a web server. We also refine the duality argument of Lauer and Needham, which implies that good implementations of thread systems and event systems will have similar performance. Finally, we argue that compiler support for thread systems is a fruitful area for future research. It is a mistake to attempt high concurrency without help from the compiler, and we discuss several enhancements that are enabled by relatively simple compiler changes.
[Show abstract][Hide abstract] ABSTRACT: Ninja is a new framework that makes it easy to cre-ate robust scalable Internet services. We introduce a new programming model based on the natural parallel-ism of large-scale services, and show how to implement the model. The first key aspect of the model is intelligent connection management, which enables high availabil-ity, load balancing, graceful degradation and online evolution. The second key aspect is support for shared persistent state that is automatically partitioned for scalability and replicated for fault tolerance. We discuss two versions of shared state, a cluster-based hash table with transparent replication and novel features that reduce lock contention, and a cluster-based file system that provides local transactions and cluster-wide namespaces and replication. Using several applications we show that the framework enables the creation of scalable, highly available services with persistent data, with very little application code, as little as one-tenth the code size of comparable stand-alone applications.
[Show abstract][Hide abstract] ABSTRACT: The Ninja project seeks to enable the broad innovation of robust, scalable, distributed Internet services, and to permit the emerging class of extremely heterogeneous devices to seamlessly access these services. Our architecture consists of four basic elements: bases, which are powerful workstation cluster environments with a software platform that simplifies scalable service construction; units, which are the devices by which users access the services; active proxies, which are transformational elements that are used for unit- or service-specific adaptation; and paths, which are an abstraction through which units, services, and active proxies are composed.
Full-text · Article · Mar 2001 · Computer Networks
[Show abstract][Hide abstract] ABSTRACT: In today's Internet era, electronic mail is replacing telephony
and postal mail as the primary means of communication for hundreds of
millions of individuals. Free e-mail services, such as Microsoft's
Hotmail and Yahoo's Yahoo Mail, each have tens of millions of
subscribers. However, these and other current e-mail systems
unfortunately are nor capable of handling the scale of Internet e-mail
use, while still providing reliable, high performance and feature-rich
services to users. This limitation is the result both of suboptimal use
of cluster computing resources, and of highly variable performance of
wide-area connections over the Internet. This paper presents NinjaMail,
a novel geographically distributed, cluster-based e-mail system built on
top of UC Berkeley's Ninja cluster architecture and OceanStore wide-area
data storage architecture. NinjaMail is unique in that it uses a
collection of clusters distributed through the wide-area to provide
users with highly available, scalable and feature-rich services via a
wide variety of access methods
[Show abstract][Hide abstract] ABSTRACT: Security in email systems involves computationally expensive public key cryptography operations. This makes it difficult to deploy secure email systems for computationally weak environments, such as personal digital assistants. To solve this problem, we have developed a secure framework in which computationally weak clients can use a trusted server to perform difficult cryptographic operations on their behalf. As an added benefit, slight modifications to our scheme make it simple to add email security on top of older systems that do not support security.