The Polylith Software Bus

We describe a system called POLYLITH that helps programmers prepare and interconnect mixedlanguage software components for execution in heterogeneous environments. POLYLITH'S principal benefit is that programmers are free to implement functional requirements separately from their treatment of interfacing requirements; this means that once an application has been developed for use in one execution environment (such as a distributed network) it can be adapted for reuse in other environments (such as a share d-memory multiprocessor) by automatic techniques. This flexibility is provided without loss of performance. We accomplish this by creating a new run-time organization for software. An abstract decoupling agent, called the software toolbus, is introduced between the system components. Heterogeneity in language and architecture is accommodated since program units are prepared to interface directly to the toolbus, not to other program units. Programmers specify application structure in terms of a module interconnection language (MIL); POLYLITH uses this specification to guide packaging (static interfacing acti vities such as stub generation, source program adaptation, compilation and linking). At run time, an implementation of the toolbus abstraction may assist in message delivery, name service or system reconfiguration. (Also cross-referenced as UMIACS-TR-90-65

Parallel I/O Using a Distributed Disk Cluster: An Exercise in Tailored Prototyping

Tailored prototyping refers to an emerging process for prototyping software applications, emphasizing a disciplined experimental approach in order for developers to obtain an understanding of system characteristics before committing to costly design decisions. In our approach, the design of software constituting prototype apparatus is driven by experimental hypotheses concerning risk, rather than an application's functional requirements. This paper describes the principles behind tailored prototyping, then illustrates them in concrete terms by describing their application in a pilot project. The pilot used in our illustration is a parallel I/O service --- a mechanism designed to deliver pages, in parallel, from a cluster of distributed disks. The performance results show that this parallel I/O system can, in certain circumstances, deliver higher page throughput from multiple remote disks, than with a single local disk. The pilot project exemplifies our prototyping method which is applicable to a wide variety software prototyping activities. (Also cross-referenced as UMIACS-TR-95-18

Reconfiguration of Hierarchical Tuple-Spaces: Experiments with Linda-Polylith

A hierarchical tuple-space model is proposed for dealing with issues of complexity faced by programmers who build and manage programs in distributed networks. We present our research on a Linda-style approach to both configuration and reconfiguration. After presenting the model used in our work, we describe an experimental implementation of a programming system based upon the model. (Also cross-referenced as UMIACS-TR-93-100

Load Balancing for Parallel Loops in Workstation Clusters

Load imbalance is a serious impediment to achieving good performance in parallel processing. Global load balancing schemes are not adequately manage to balance parallel tasks generated from a single application. Dynamic loop scheduling methods are known to be useful in balancing parallel loops on shared-memory multiprocessor machines. However, their centralized nature causes a bottleneck for the relatively small number of processors in workstation clusters because of order-of-magnitude differences in communications overheads. Moreover, improvements of basic loop scheduling methods have not dealt effectively with irregularly distributed workloads in parallel loops, which commonly occur in applications for workstation clusters. In this paper, we present a new decentralized balancing method for parallel loops on workstation clusters. (Also cross-referenced as UMIACS-TR-96-6

A Framework for Dynamic Reconfiguration of Distributed Programs

Current techniques for a software engineer to change a computer program are limited to static activities once the application begins executing, there are few reliable ways to reconfigure it. We have developed a general framework for reconfigurating application software dynamically. A sound method for managing changes in a running program allows developers to perform maintenance activities without loss of the overall system's service. The same methods also support some forms of load balancing in a distributed system, and research in software fault tolerance. Our goal has been to create an environment for organizing and effecting software reconfiguration activities dynamically. First we present the overall framework within which reconfiguration is possible, then we describe our formal approach for programmers to capture the state of a process abstractly. Next, we describe our implementation of this method within an environment for experimenting with program reconfiguration. We conclude with a summary of the key research problems that we are continuing to pursue in this area. (Also cross-referenced as UMIACS-TR-93-78

Software Engineering of Virtual Environments: Integration and Interconnection

Virtual Environments(VEs) are proving to be valuable resources in many fields, and they are even more useful when they involve multiple users in distributed environments. Many useful VEs were designed to be stand-alone applications, without consideration for integrating them into a distributed VE. Our approach to connecting VEs is to define an abstract model for the interconnection, use integration tools to do as much of the work automatically as possible, and use a run-time environment to support the interconnection. With our experiences to date, we are learning that certain classes of techniques are common to all solutions using this approach. We have summarized these in a set of requirements and are building a system that features these techniques as first class objects. In the future you will be able to solve these interconnection problems cheaply, plus engineers of future VEs will have some guidance on how they should organize their implementations so that interconnection with other VEs will be easier. In this paper we coin the phrase "software engineering of virtual environments" (SEVE) to describe the above activities. (Also cross-referenced as UMIACS-TR-96-89

Interconnecting Distributed Legacy Systems: Virtual Environment Domain Example

As the power and utility of virtual reality environments increases, so do the potential benefits found from combinding several such environments. But doing so presents the developer with a host of difficult distributed systems issues. This paper explores what some of these issues are within the VE domain, relates our successes to date in overcoming these problems by means of various automated tools, and suggests ways to apply our results other target domains. (Also cross-referenced as UMIACS-TR-96-88

Tool Support for Collaborative Software Prototyping

Prototyping is a means by which requirements for software projects can be defined and refined before they are committed to firm specifications for the finished software product. By this process, costly and time-consuming errors in specification can be avoided or minimized. Reconfiguration is the concept of altering the program code, bindings between program modules, or logical or physical distribution of software components while allowing the continuing execution of the software being changed. Combining these two notions suggests the potential for a development environment where requirements can be quickly and dynamically evolved. This paper discusses reconfiguration-based prototyping (RBP), that is, the simultaneous consideration of requirements, software behavior and user feedback within a running system in order to derive a clear specification of an intended product. Tools enabling RBP can coordinate the efforts of developers, users and subject matter specialists alike as they work towards consensus on an application's specification by means of a prototype. The authors describe the scope of the modifications that can be effected by an integration of prototyping and reconfiguration protocols, and they then demonstrate that the technology exists to create such an environment. They conclude by describing a software development environment based on RBP. (Also cross-referenced as UMIACS-TR-95-5

Software Engineering of Distributed Simulation Environments

With the increasing popularity of simulation and virtual environment software, it is necessary to provide software engineering techniques to simulation program designers. In this paper we lay out the requirements that any such techniques will have to meet, then suggest a formalism and an interconnection tool that will allow the interconnection of re-usable simulator components to build distributed simulation software. (Also cross-referenced as UMIACS-TR-95-100