Samuel H. Russ

The Hector distributed run-time environment

Harnessing the computational capabilities of a network of workstations promises to off-load work from overloaded supercomputers onto largely idle resources overnight. Several capabilities are needed to do this, including support for an architecture-independent parallel programming environment, task migration, automatic resource allocation, and fault tolerance. The Hector distributed run-time environment is designed to present these capabilities transparently to programmers. MPI programs can be run under this environment on homogeneous clusters with no modifications to their source code needed. The design of Hector, its internal structure, and several benchmarks and tests are presented.

An artificial immune system model for intelligent agents

Abstract This paper describes the human immune system and its functionalities from a computational viewpoint. The objective of this paper is to provide the biological basis for an artificial immune system. This paper will also serve to illustrate how a biological system can be studied and how inferences can be drawn from its operation that can be exploited in intelligent agents. Functionalities of the biological immune system (e.g., content addressable memory, adaptation, etc.) are identified for use in intelligent agents. Specifically, in this paper, an intelligent agent will be described for task allocation in a heterogeneous computing environment. Initial implementation of the agents will be described along with preliminary results. This research is not intended to develop an explicit model of the human immune system, but to exploit some of its functionalities in designing agent-based parallel and distributed control systems.

The Biological Basis of the Immune System as a Model for Intelligent Agents

This paper describes the human immune system and its functionalities from a computational viewpoint. The objective of this paper is to provide the biological basis for an artificial immune system. This paper will also serve to illustrate how a biological system can be studied and how inferences can be drawn from its operation that can be exploited in intelligent agents. Functionalities of the biological immune system (e.g., content addressable memory, adaptation, etc.) are identified for use in intelligent agents. Specifically, in this paper, an intelligent agent will be described for task allocation in a heterogeneous computing environment. This research is not intended to develop an explicit model of the human immune system, but to exploit some of its functionalities in designing agent-based parallel and distributed control systems.

Hectiling: an integration of fine and coarse-grained load-balancing strategies

General-purpose programmers have come to expect a high degree of portability among widely varying architectures. Advances in run-time systems for parallel programs have been proposed in order to harness available resources as efficiently as possible. Simultaneously, advances in algorithmic methods of dynamically balancing computational load have been proposed in order to respond to variations in actual performance and therefore in run-time. The primary mechanism for harnessing idle resources effectively, task migration, can be used alongside the primary mechanism for dynamic load balancing, data redistribution. Besides the fact that the two methods can be used simultaneously to spur further increases in performance, the run-time information-gathering infrastructure necessary to detect and use idle resources can also benefit dynamically load-balanced applications. This paper describes an architecture for and preliminary implementation of a system that combines data-parallel load balancing with task-parallel load balancing. Performance test results are included as well.

Transparent Real-Time Monitoring in MPI

MPI has emerged as a popular way to write architecture-independent parallel programs. By modifying an MPI library and associated MPI run-time environment, transparent extraction of timestamped information is possible. The wall-clock time at which specific MPI communication events begin and end can be recorded, collected, and provided to a central scheduler. The infrastructure to create and collect these events has been implemented and tested, and a future architecture that can use this information is described.

An architecture for rapid distributed fault tolerance

Embedded high performance computing is being called upon to provide critical computing resources with increasing frequency. The ability to tolerate faults during operation, both maintaining operational capability and ensuring that correct results continue to be produced, is an important ingredient in mission-critical systems. An architecture for such a system is proposed, providing the ability to withstand faults with graceful degradation in performance and complete transparency to the applications programmer. The final system will be able to offer fault-tolerant computing transparently to MPI applications and draws heavily on existing, demonstrated successes.

Experiences from integrating algorithmic and systemic load balancing strategies

Load balancing increases the efficient use of existing resources for parallel and distributed applications. At a coarse level of granularity, advances in runtime systems for parallel programs have been proposed in order to control available resources as efficiently as possible by utilizing idle resources and using task migration. Simultaneously, at a finer granularity level, advances in algorithmic strategies for dynamically balancing computational loads by data redistribution have been proposed in order to respond to variations in processor performance during the execution of a given parallel application. Combining strategies from each level of granularity can result in a system which delivers advantages of both. The resulting integration is systemic in nature and transfers the responsibility of efficient resource utilization from the application programmer to the runtime system. This paper presents the design and implementation of a system that combines an algorithmic fine‐grained data parallel load balancing strategy with a systemic coarse‐grained task‐parallel load balancing strategy, and reports on recent experimental results of running a computationally intensive scientific application under this integrated system. The experimental results indicate that a distributed runtime environment which combines both task and data migration can provide performance advantages with little overhead. It also presents proposals for performance enhancements of the implementation, as well as future explorations for effective resource management. Copyright