Gregory D. Benson

A Comparison of MPICH Allgather Algorithms on Switched Networks

This study evaluates the performance of MPI_Allgather() in MPICH 1.2.5 on a Linux cluster. This implementation of MPICH improves on the performance of allgather compared to previous versions by using a recursive doubling algorithm. We have developed a dissemination allgather based on the dissemination barrier algorithm. This algorithm takes log2 p stages for any values of p. We experimentally evaluate MPICH allgather and our implementations on a Linux cluster of dual-processor nodes using both TCP over FastEthernet and GM over Myrinet. We show that on Myrinet, variations of the dissemination algorithm perform best for both large and small messages. However, when using TCP, the dissemination allgather algorithm performs poorly because data is not exchanged in a pair-wise fashion. Therefore, we recommend the dissemination allgather for low-latency switched networks.

Fairness in shared invocation servicing

Invocation servicing is an important aspect of many concurrent programming languages. Some invocation handling mechanisms allow for multiway servicing by multiple processes. This paper addresses fairness with respect to choosing which invocation to service and fairness with respect to choosing which process to perform the servicing. It examines how these fairness issues have been resolved in the SR concurrent programming language. This paper presents a new approach that eliminates several key restrictions. The new approach has been implemented in JR, an extended Java that includes SR-like synchronization mechanisms. This paper discusses design and implementation issues and tradeoffs.

Mechanizing a Programming Logic for the Concurrent Programming Language microSR in HOL

This paper presents our current effort to formally derive, using HOL, a sound Hoare logic for the concurrent programming language microSR, a derivative of SR. Our methodology is built on Gordons work on mechanizing programming logics for a small sequential programming language. The constructs of microSR include those basic to common sequential programming languages, in addition to an asynchronous send statement, a synchronous receive statement, a guarded communication input statement, and a co statement for specifying concurrent execution. This language has the appearance of a high-level system programming language that supports distributed applications. The Hoare logic for microSR with concurrency features presented in this paper has been formally proven to be sound within HOL. The logic we derived allows one to reason and state formal assertions about concurrently executing processes that do not share any data objects, but communicate through shared channels.

The Design of Microkernel Support for the Sr Concurrent Programming Language

In general, networked and distributed operating systems are still programmed using a sequential language like C, even though the underlying programming model is that of multithreaded programs that communicate using some form of message passing. In a distributed environment it is more natural to program using a distributed programming language. In addition, distributed languages do not map well to traditional operating systems. The new, minimal kernel, or micro-kernel, operating systems provide an opportunity to efficiently support distributed languages. This paper explores different ways to provide support for the SR concurrent programming language on the Mach microkemel.

State management for distributed Python applications

We present a novel state management mechanism that can be used to capture the complete execution state of distributed Python applications. This mechanism can serve as the foundation for a variety of dependability strategies including checkpointing, replication, and migration. Python is increasingly used for rapid prototyping parallel pro grams and, in some cases, used for high-performance application development using libraries such as NumPy. Building on Stackless Python and the River parallel and distributed programming environment, we have developed mechanisms for state capture at the language level. Our approach allows for migration and checkpointing of applications in heterogeneous environments. In addition, we allow for preemptive state capture so that programmers need not introduce explicit snapshot requests. Our mechanism can be extended to support application or domain-specific state capture. To our knowledge, this is the first general checkpointing scheme for Python. We describe our system, the implementation, and give some initial performance figures.

A Framework for Specializing Threads in Concurrent Run-Time Systems

Many thread packages support only a limited number target configurations and are generally inflexible with respect to scheduling. Even configurable thread packages distance core thread operations and thread state from client code. In addition, most thread implementations duplicate some of the functionality found in concurrent language run-time systems. To address these limitations, we have developed the Mezcla thread framework. Unlike conventional thread packages, Mezcla enables a language implementor to generate specialized, light-weight thread systems based on the requirements of the run-time system and the functionality of the target platform. This paper presents several current techniques for implementing threads in concurrent run-time systems and evaluates their effectiveness. We then describe our experience with threads in the SR concurrent programming language. Finally, we present the design and implementation of the Mezcla thread framework with some preliminary performance results.

The Performance of Parallel Disk Write Methods for Linux Multiprocessor Nodes

We experimentally evaluate several methods for implementing parallel computations that interleave a significant number of contiguous or strided writes to a local disk on Linux-based multiprocessor nodes. Using synthetic benchmark programs written with MPI and Pthreads, we have acquired detailed performance data for different application characteristics of programs running on dual processor nodes. In general, our results show that programs that perform a significant amount of I/O relative to pure computation benefit greatly from the use of threads, while programs that perform relatively little I/O obtain excellent results using only MPI. For a pure MPI approach, we have found that it is usually best to use two writing processes with mmap(). For Pthreads it is usually best to use two writing processes, write() for contiguous data, and writev() for strided data. Codes that use mmap() tend to benefit from periodic syncs of the data of the data to the disk, while codes that use write() or writev() tend to have better performance with few syncs. A straightforward use of ROMIO usually does not perform as well as these direct approaches for writing to the local disk.