Chi-Chao Chang

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.

Interfacing Java to the virtual interface architecture

User-level network interfaces (UNIs) have reduced the overheads of communication by exposing the buffers used by the network interface DMA engine to the applications. This removes the kernel from the critical path of message transmission and reception, and it reduces the number of data copies performed on that path. Unfortunately, the fact that UNIs require the application to manage buffers explicitly makes it difficult to provide direct access to a UNI from Java, as the language explicitly prevents programs from controlling the location or layout of objects. This paper describes Javia, a Java interface to the Virtual Interface Architecture (VIA), an emerging UNI standard in the industry. Javia implements a special buffer abstraction that allows Java programs to allocate arrays in pinned memory and use them as communication buffers without copy. The location and lifetime of these arrays are controlled through small modifications to the garbage collector. Simple experiments show that Java programs can achieve round-trip times of 21us for small messages and bandwidths of 95Mbytes/sec for 4Kbyte messages.

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

Javia: A Java interface to the virtual interface architecture

The Virtual Interface (VI) architecture has become the industry standard for user-level network interfaces. This paper presents the implementation and evaluation of Javia, a Java interface to the VI architecture. Javia explores two points in the design space. The first approach manages buffers in C and requires data copies between the Java heap and native buffers. The second approach relies on a Java-level buffer abstraction that eliminates the copies in the first approach. Javia achieves an effective bandwidth of 80 Mbytes s−1 for 8 kbyte messages, which is within 1% of those achieved by C programs. Performance evaluations of parallel matrix multiplication and of the active messages communication protocol show that Javia can serve as an efficient building block for Java cluster applications. Copyright

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.