Vernon Rego

Ariadne : Architecture of a portable threads system supporting thread migration

Threads exhibit a simply expressed and powerful form of concurrency, easily exploitable in applications that run on both uni‐ and multi‐processors, shared‐ and distributed‐memory systems. This paper presents the design and implementation of Ariadne: a layered, C‐based software architecture for multi‐threaded distributed computing on a variety of platforms. Ariadne is a portable user‐space threads system that runs on shared‐ and distributed‐memory multiprocessors. Thread‐migration is supported at the application level in homogeneous environments (e.g., networks of SPARCs and Sequent Symmetrys, Intel hypercubes). Threads may migrate between processes to access remote data, preserving locality of reference for computations with a dynamic data space. Ariadne can be tuned to specific applications through a customization layer. Support is provided for scheduling via a built‐in or application‐specific scheduler, and interfacing with any communications library. Ariadne currently runs on the SPARC (SunOS 4.x and SunOS 5.x), Sequent Symmetry, Intel i860, Silicon Graphics workstation (IRIX), and IBM RS/6000 environments. We present simple performance benchmarks comparing Ariadne to threads libraries in the SunOS 4.x and SunOS 5.x systems.

High performance software testing on SIMD machines

A method for high-performance, software testing, called mutant unification, is described. The method is designed to support program mutation on parallel machines based on the single instruction multiple data stream (SIMD) paradigm. Several parameters that affect the performance of unification have been identified and their effect on the time to completion of a mutation test cycle and speedup has been studied. Program mutation analysis provides an effective means for determining the reliability of large software systems and a systematic method for measuring the adequacy of test data. However, it is likely that testing large software systems using mutation is computation bound and prohibitive on traditional sequential machines. Current, implementations of mutation tools are unacceptably slow and are only suitable for testing relatively small programs. The proposed unification method provides a practical alternative to the current approaches. The method also opens up a new application domain for SIMD machines. >

Efficient Multithreaded User-Space Transport for Network Computing

We present a novel user-space and transaction-oriented protocol for use in high-performance distributed computing applications. The TRAP protocol is designed to support low-latency communication in multithreaded message-passing libraries. To demonstrate the viability of TRAP, we implemented and tested the fully operational protocol and conducted several experiments comparing its runtime performance with that of popular communication libraries. For fairness, the experiments did not exploit the TRAP protocols multithreading capability at the application level. The results show that a TRAP-based communication library can, in various scenarios, outperform extant libraries based on in-kernel or user-level protocols. The results of these experiments also show that the TRAP protocol exhibits scalability characteristics, with respect to number of computing and communicating nodes, that is superior to regular in-kernel TCP/IP and other user-space protocol implementations.

Yet another application of a binomial recurrence. Order statistics

We investigate the moments of the maximum of a set of i.i.d geometric random variables. Computationally, the exact formula for the moments (which does not seem to be available in the literature) is inhibited by the presence of an alternating sum. A recursive expression for the moments is shown to be superior. However, the recursion can be both computationally intensive as well as subject to large round-off error when the set of random variables is large, due to the presence of factorial terms. To get around this difficulty we develop accurate asymptotic expressions for the moments and verify our results numerically.ZusammenfassungWir untersuchen die Momente des Maximums einer Menge von unabhängig identisch verteilten geometrischen Zufallsvariablen. Numerisch ist die Verwendung der exakten Formel für die Momente (die überdies in der Literatur nicht erscheint) wegen des Vorhandenseins einer alternierenden Summe nicht ratsam. Ein rekursiver Ausdruck für die Momente ist besser geeignet. Jedoch kann die Rekursion wegen des Auftretens von faktoriellen Ausdrücken sowohl viel Rechenaufwand erfordern als auch große Rundungsfehler verursachen, wenn die Menge der Zufallsvariablen groß ist. Zur Überwindung dieser Schwierigkeiten entwickeln wir genaue asymptotische Formeln für die Momente und verifizieren unsere Ergebnisse numerisch.

Arachne: a portable threads system supporting migrant threads on heterogeneous network farms

We present the design and implementation of Arachne, a threads system that can be interfaced with a communications library for multithreaded distributed computations. In particular, Arachne supports thread migration between heterogeneous platforms, dynamic stack size management, and recursive thread functions. Arachne is efficient, flexible, and portable-it is based entirely on C and C++. To facilitate heterogeneous thread operations, we have added three keywords to the C++ language. The Arachne preprocessor takes as input code written in that language and outputs C++ code suitable for compilation with a conventional C++ compiler. The Arachne runtime system manages all threads during program execution. We present some performance measurements on the costs of basic thread operations and thread migration in Arachne and compare these to costs in other threads systems.

Effect of testing techniques on software reliability estimates obtained using a time-domain model

Since the early 1970s, researchers have proposed several models to estimate software-reliability as testing progresses. Among these, the time-domain models are the most common. We present empirical evidence to show that the testing method does affect the reliability estimates using one of these models, viz, the Musa basic execution-time model. The evidence suggests that: (1) reliability models need to consider additional data, generated during testing, such as some form of code coverage, to obtain accurate reliability estimates; and (2) further research is necessary to determine which testing method, or combination thereof, leads to higher reliability. >

Experiments in concurrent stochastic simulation: the EcliPSe paradigm

Abstract This paper presents results on the performance of a novel and flexible concurrent simulation environment known as EcliPSe . The paradigm we advocate is based on the premise that replication based simulations, either nondistributed or minimally distributed, yield excellent speedups. The approach used makes concurrent simulation easily accessible to researchers because its use does not require knowledge of parallel programming. The experiments we report include Monte Carlo type simulations (e.g., estimating integrals, order-statistics), Markov-chain simulations (hitting-times, distributed algorithms), and discrete-event simulation (e.g., tail probabilities in queues, FDDI token ring performance, and simulations of high performance software testing techniques on SIMD machines).

EcliPSe: a system for high performance concurrent simulation

A description of a system which provides for the concurrent execution of stochastic simulation applications is presented. The EcliPSe system provides high‐level simulation primitives that enable common sawlation tasks. An application programmer describes the simulation process in terms of these primitives using a sequential computation model. The system transparently replicates appropriate sections of the simulation when the program is executed on a concurrent system. By binding to machine‐dependent versions of the EcliPSe library, the simulation program can execute without modification on a variety of architectures including uniprocessors, hypercubes, shared‐memory machines and loosely coupled networks. In those experiments conducted, near‐linear speed‐ups were obtained. The main design aspects of the system, salient implementation features and performance figures for some simulation applications are presented. The usefulness of the system for more general applications is also discussed.

A case study to investigate sensitivity of reliability estimates to errors in operational profile

We report a case study to investigate the effect of errors in an operational profile on reliability estimates. A previously reported tool named TERSE was used in this study to generate random flow graphs representing programs, model errors in operational profile, and compute reliability estimates. Four models for reliability estimation were considered: the Musa-Okumoto model, the Goel-Okumoto model, coverage enhanced Musa-Okumoto model, and coverage enhanced Goel-Okumoto model. It was found that the error in reliability estimates from these models grows nonlinearly with errors in operational profile. Results from this case study lend credit to the argument that further research is necessary in development of more robust models for reliability estimation.<<ETX>>

High performance testing on SIMD machines

The authors describe how software testing using mutation analysis can be performed efficiently on an SIMD machine. They develop a technique that permits unified scheduling of multiple mutant programs on a very large SIMD machine. They believe that supercomputers with novel architectures can be used to enhance software productivity by using techniques like the one proposed.<<ETX>>