Kees Verstoep

Fast Measurement of LogP Parameters for Message Passing Platforms

Performance modeling is important for implementing efficient parallel applications and runtime systems. The LogP model captures the relevant aspects of message passing in distributed-memory architectures. In this paper we describe an efficient method that measures LogP parameters for a given message passing platform. Measurements are performed for messages of different sizes, as covered by the parameterized LogP model, a slight extension of LogP and LogGP. To minimize both intrusiveness and completion time of the measurement, we propose a procedure that sends as few messages as possible. An implementation of this procedure, called the MPI LogP benchmark, is available from our WWW site.

The distributed ASCI Supercomputer project

The Distributed ASCI Supercomputer (DAS) is a homogeneous wide-area distributed system consisting of four cluster computers at different locations. DAS has been used for research on communication software, parallel languages and programming systems, schedulers, parallel applications, and distributed applications. The paper gives a preview of the most interesting research results obtained so far in the DAS project.

Efficient reliable multicast on Myrinet

The paper describes a reliable multicast algorithm on top of reliable point-to-point communication. The algorithm uses a flow control method based on a credit scheme to prevent message loss caused by overflow of software buffers. The multicast algorithm has been implemented by extending the Illinois Fast Messages software for Myrinet, which supports reliable point-to-point communication but no multicast. To obtain low latency and high throughput, forwarding of messages is handled entirely by the network adapter boards without involving the hosts. Measurements on an 8-node Myrinet system show that the implementation achieves high performance.

Wide-area communication for grids: an integrated solution to connectivity, performance and security problems

Grid computing applications are challenged by current wide-area networks: firewalls, private IP addresses and network address translation (MAT) hamper connectivity, the TCP protocol can hardly exploit the available bandwidth, and security features like authentication and encryption are usually difficult to integrate. Existing systems (like GridFTP, JXTA, SOCKS) each address only one of these issues. However, applications need to cope with all of them, at the same time. Unfortunately, existing solutions are often not easy to combine, and a particular solution for one subproblem may reduce the applicability or performance of another. We identify the building blocks that are needed for connection establishment and efficient link utilization. We present an integrated solution, implemented within the Java-based Ibis runtime system. OurNetlbis implementation lets applications span multiple sites of a grid, and copes with firewalls, local IP addresses, secure communication, and TCP bandwidth problems.

Efficient large-scale model checking

Model checking is a popular technique to systematically and automatically verify system properties. Unfortunately, the well-known state explosion problem often limits the extent to which it can be applied to realistic specifications, due to the huge resulting memory requirements. Distributed-memory model checkers exist, but have thus far only been evaluated on small-scale clusters, with mixed results. We examine one well-known distributed model checker, DiVinE, in detail, and show how a number of additional optimizations in its runtime system enable it to efficiently check very demanding problem instances on a large-scale, multi-core compute cluster. We analyze the impact of the distributed algorithms employed, the problem instance characteristics and network overhead. Finally, we show that the model checker can even obtain good performance in a high-bandwidth computational grid environment.

Real-World Distributed Computer with Ibis

The use of parallel and distributed computing systems is essential to meet the ever-increasing computational demands of many scientific and industrial applications. Ibis allows easy programming and deployment of compute-intensive distributed applications, even for dynamic, faulty, and heterogeneous environments.

Group communication in Amoeba and its applications

Unlike many other operating systems, Amoeba is a distributed operating system that provides group communication (i.e. one-to-many communication). The authors discuss design issues for group communication, Amoebas group system calls, and the protocols to implement group communication. To demonstrate that group communication is a useful abstraction, they describe a design and implementation of a fault-tolerant directory service. They discuss two versions of the directory service: one with non-volatile RAM (NVRAM) and one without NVRAM. They give performance figures for both implementations.

Programming environments for high-performance grid computing: the Albatross project

The aim of the Albatross project is to study applications and programming environments for computational Grids. We focus on high-performance applications, running in parallel on multiple clusters or MPPs that are connected by wide-area networks (WANs). We briefly present three Grid programming environments developed in the context of the Albatross project: the MagPIe library for collective communication with MPI, the replicated method invocation (RepMI) mechanism for Java, and the Java-based Satin system for running divide-and-conquer programs on Grid platforms.A major challenge in investigating the performance of such applications is the actual WAN behavior. Typical wide-area links are just part of the Internet and thus shared among many applications, making runtime measurements irreproducible and thus scientifically hardly valuable. To overcome this problem, we developed a WAN emulator as part of Panda, our general-purpose communication substrate. The WAN emulator allows us to run parallel applications on a single (large) parallel machine with only the wide-area links being emulated. The Panda emulator is highly accurate and configurable at runtime. We present a case study in which Satin runs across various emulated WAN scenarios.

Performance of a High-Level Parallel Language on a High-Speed Network

Clusters of workstations are often claimed to be a good platform for parallel processing, especially if a fast network is used to interconnect the workstations. Indeed, high performance can be obtained for low-level message passing primitives on modern networks like ATM and Myrinet. Most application programmers, however, want to use higher level communication primitives. Unfortunately, implementing such primitives efficiently on a modern network is a difficult task, because their software overhead is relatively much higher than on a traditional, slow network (such as Ethernet). In this paper we investigate the issues involved in implementing a high-level programming environment on a fast network. We have implemented a portable runtime system for an object-based language (Orca) on a collection of processors connected by a Myrinet network. Many performance optimizations were required in order to let application programmers benefit sufficiently from the faster network. In particular, we have optimized message handling, multicasting, buffer management, fragmentation, marshalling, and various other issues. The paper analyzes the impact of these optimizations on the performance of the basic language primitives as well as parallel applications.

Using group communication to implement a fault-tolerant directory service

Group communication is an important paradigm for building distributed applications. The authors discuss a fault-tolerant distributed directory service based on group communication, and compare it with the previous design and implementation based on remote procedure call (RPC). The group directory service uses an active replication scheme and, when triplicated, can handle 627 lookup operations per second and 88 update operations per second (using nonvolatile RAM). This performance is better than the performance for the RPC implementation and it is even better than the performance for directory operations under SunOS, which does not provide any fault tolerance at all. The conclusion is that the implementation using group communication is simpler and has better performance than the one based on remote procedure call, supporting the claim that a distributed operating system should provide both remote procedure call and group communication.<<ETX>>