Grzegorz Czajkowski

JRes: a resource accounting interface for Java

With the spread of the Internet the computing model on server systems is undergoing several important changes. Recent research ideas concerning dynamic operating system extensibility are finding their way into the commercial domain, resulting in designs of extensible databases and Web servers. In addition, both ordinary users and service providers must deal with untrusted downloadable executable code of unknown origin and intentions.Across the board, Java has emerged as the language of choice for Internet-oriented software. We argue that, in order to realize its full potential in applications dealing with untrusted code, Java needs a flexible resource accounting interface. The design and prototype implementation of such an interface --- JRes --- is presented in this paper. The interface allows to account for heap memory, CPU time, and network resources consumed by individual threads or groups of threads. JRes allows limits to be set on resources available to threads and it can invoke callbacks when these limits are exceeded. The JRes prototype described in this paper is implemented on top of standard Java virtual machines and requires only a small amount of native code.

Low-Latency Communication on the IBM RISC System/6000 SP

The IBM SP is one of the most powerful commercial MPPs, yet, in spite of its fast processors and high network bandwidth, the SPs communication latency is inferior to older machines such as the TMC CM-5 or Meiko CS-2. This paper investigates the use of Active Messages (AM) communication primitives as an alternative to the standard message passing in order to reduce communication overheads and to offer a good building block for higher layers of software. The first part of this paper describes an implementation of Active Messages (SP AM) which is layered directly on top of the SPs network adapter (TB2). With comparable bandwidth, SP AMs low overhead yields a round-trip latency that is 40% lower than IBM MPLs. The second part of the paper demonstrates the power of AM as a communication substrate by layering Split-C as well as MPI over it. Split-C benchmarks are used to compare the SP to other MPPs and show that low message overhead and high throughput compensate for SPs high network latency. The MPI implementation is based on the freely available MPICH version and achieves performance equivalent to IBMs MPI-F on the NAS benchmarks.

J-Kernel: a capability-based operating system for Java

Safe language technology can be used for protection within a single address space. This protection is enforced by the languages type system, which ensures that references to objects cannot be forged. A safe language alone, however, lacks many features taken for granted in more traditional operating systems, such as rights revocation, thread protection, resource management, and support for domain termination. This paper describes the J-Kernel, a portable Java-based protection system that addresses these issues. J-Kernel protection domains can communicate through revocable capabilities, but are prevented from directly sharing unrevocable object references. A number of micro-benchmaxks characterize the costs of language-based protection, and an extensible web and telephony server based on the J-Kernel demonstrates the use of language-based protection in a large application.

Resource management for extensible Internet servers

With the continued spread of the Internet the typical computing model for servers is undergoing a drastic change. In the past, server systems have moved from providing interactive time-sharing service to providing fileserver and now more general back-office (mail, database, web, etc.) services. While the characteristics of the new Internet server systems are not yet clear, we expect that Internet servers will have at least three characteristics that distinguish them drastically from today’s servers: (i) high code mobility, (ii) large numbers of anonymous users, and (iii) significant concern for the efficient use of resources.

MRPC: a high performance RPC system for MPMD parallel computing

MRPC is an RPC system that is designed and optimized for MPMD parallel computing. Existing systems based on standard RPC incur an unnecessarily high cost when used on high‐performance multi‐computers, limiting the appeal of RPC‐based languages in the parallel computing community. MRPC combines the efficient control and data transfer provided by Active Messages (AM) with a minimal multithreaded runtime system that extends AM with the features required to support MPMD. This approach introduces only the necessary RPC overheads for an MPMD environment. MRPC has been integrated into Compositional C++ (CC++), a parallel extension of C++ that offers an MPMD programming model. Basic performance in MRPC is within a factor of two from those of Split‐C, a highly tuned SPMD language, and other messaging layers. CC++ applications perform within a factor of two to six from comparable Split‐C versions, which represent an order of magnitude improvement over previous CC++ implementations. Copyright

Internet servers, safe-language extensions, and structured resource control

The growing role of server systems, especially in the context of the World Wide Web, requires providing flexible and inexpensive mechanisms for accounting for and controlling of resources consumed by individual requests. To a large extent, the Internet server models currently deployed fail in this respect. The focus of this work is to alleviate some problems related to resource management in server environments. In particular, we propose a structured approach to binding threads (execution entities) to resource accounts (abstractions encapsulating rights to using particular amounts of particular resources). The approach advocates separation between protection domains (processes) and resource management; we argue that this is more appropriate for server systems than traditional approaches. Resource accounts address some issues related to trust and to dividing complex requests into separate sub-requests.

Performance implications of communication mechanisms in all-software global address space systems

Global addressing of shared data simplifies parallel programming and complements message passing models commonly found in distributed memory machines. A number of programming systems have been designed that synthesize global addressing purely in software on such machines. These systems provide a number of communication mechanisms to mitigate the effect of high communication latencies and overheads. This study compares the mechanisms in two representative all-software systems: CRL and Split-C. CRL uses region-based caching while Split-C uses split-phase and push-based data transfers for optimizing communication performance. Both systems take advantage of bulk data transfers.By implementing a set of parallel applications in both CRL and Split-C, and running them on the IBM SP2, Meiko CS-2 and two simulated architectures, we find that split-phase and push-based bulk data transfers are essential for good performance. Region-based caching benefits applications with irregular structure and with sufficient temporal locality, especially under high communication latencies. However, caching also hurts performance when there is insufficient data reuse or when the size of caching granularity is mismatched with the communication granularity. We find the programming complexity of the communication mechanisms in both languages to be comparable. Based on our results, we recommend that an ideal system intended to support diverse applications on parallel platforms should incorporate the communication mechanisms in CRL and Split-C.

Security versus performance tradeoffs in RPC implementations for safe language systems

In current distributed systems, the performance of remote procedure calls (RPCs) is determined primarily by the performance of the underlying network transport. While the overheads of the RPC system itself are secondary, two ongoing developments are likely to change this and will cause the current RPC systems to become the bottleneck in communication: user-level network interfaces and safe languages. User-level network interfaces such as VIA [2], U-Net [10], Fast Messages [8], NoW Active Messages [1], or Shrimp VMMC [3] are removing the operating system from the critical communication path by allowing applications to access the network interface directly. As a result, the overhead of the network transport underlying RPC decreases by almost an order of magnitude. At the same time, the increasing adoption of Java as the “internet programming language” places a heavier burden on the RPC system because communication among Java programs must satisfy the type safety properties assumed by the language run-time (this is a general issue with safe languages). Typically enforcing this type safety requires additional operations (e.g. checks) in the critical RPC path.

Building Parallel Runtime Systems with Active Messages

Past research in communication infrastructure for parallel computing has shown that Active Messages is an attractive communication model that allows efficient implementations on a variety of architectures. This has been demonstrated through microbenchmarks, by including Active Messages in a runtime system for SplitC – a parallel SPMD extension of C, and by analyzing performance of a set of Split-C benchmarks. The goal of this work is to demonstrate that Active Messages are applicable for building a range of parallel runtime systems. Design and implementation issues are discussed in context of three programming languages: Split-C, CC++ and CRL, representing the three prominent parallel computing models: SPMD, MPMD and DSM, respectively.