Anthony Gargaro

Transitioning a model-based software engineering architectural style to Ada 95

Abstract : This report describes the transition of an existing Model-Based Software Engineering architectural style to Ada 95. The report presents an overview of a software architecture for developing product families of domain specific applications comprising reusable components, explains recognized deficiencies in the existing Ada mapping to this software architecture, and proposes solutions for correcting these deficiencies using a mapping to Ada 95. The report concludes with observations gained during the transition exercise and recommendations for future activities aimed towards deploying and enhancing the proposed mapping.

Supporting distribution and dynamic reconfiguration in AdaPT

It is widely accepted that Ada83 provides inadequate support for the programming of distributed systems. Ada9X has introduced a unit of distribution called a partition. Partitions comprise aggregations of library units that collectively may execute in a distributed target execution environment. Each partition corresponds to a single execution site where all its library units occupy the same logical address space. The principal interface between partitions is one or more package specifications. Although Ada9X provides basic support for partitioning applications, it falls short of providing the full expressive power that would be expected of a language specially designed to support distributed systems. In particular, the unit of distribution is not a first class language object and methods for dynamic configuration are primarily left to the implementor. We briefly review the main requirements for programming distributed systems and illustrate where the current Ada9X proposals lack expressive power. We then introduce a new variant of Ada called AdaPT which has been designed to address explicitly partitioning and dynamic reconfiguration of distributed Ada programs. We illustrate how AdaPT programs can be written and detail their translation into Ada83 and Ada9X.

PARIS - Partitioned Ada for Remotely Invoked Services

This paper presents our experience implementing the Ada 95 Annex E to support distributed systems using the GNAT compiler[6]. The work has been performed by a multinational team from France and the USA. The paper describes the implementation of the Partition Communication System and the required support from the GNAT compiler. In addition, extensions beyond Annex E are described that facilitate programming the next generation of distributed applications in Ada 95.

Future directions in Ada—distributed execution and heterogeneous language interoperability toolsets

While the Ada community has seen and embraced the development of Ada 95 [1], with its enhanced object oriented features and various annexes, much of the rest of the commercial world continues to ignore Ada as a viable tool for software system building. Efforts have been ongoing for some time to provide rationale showing the superiority of Ada 95 over other choices such as C and C++, but with limited success in the commercial marketplace. In this paper, we put forward the idea that the Ada community should focus on: 1) interoperability with components built in other languages, and 2) convenient, easy to use toolsets for composing distributed systems from heterogeneous language components.

Towards distributed programming paradigms in Ada 9X

l’he Ada 9X Distributed Systems Anntw [1] supports a comprehensive range of distributed programming paradigms, ~is paper txplains the partition model for executing a distributed Ada program and presents a sampling of dtjlerent programming paradigms for interpartition communication using various forms of remote subprogram call. It concludes with a perspective on the contributions of Ada 9X to programming distributed systems. The term megaprogramrning has been coined to focus software engineering technology on scaling up current programming paradigms [2]. Megaprograms comprise megamodules where megamodules are large-granularity software components with internally consistent type systems. The Ada 9X requirements [3] coincided with the emergence of the megamodule concept [4]. Fortunately, many enhanced features of Ada 9X facilitate the disciplined development of megamodules through componentbased software engineering. These features include an extensible type hierarchy, child packages (to build component libraries), and partitioned programs [5]. Partitioning programs is an important contribution to the construction of a megamodule that executes as a distributed system. In essence, an Ada 9X partition becomes a module within the megamodule concept. A megamodule is developed as an executable partitioned A& program where inter-partition communication is accomplished using variations of the remote procedure call paradigm [6]. Cooperating partitions specify these variations through interface packages that are explicitly assigned to partitions subsequent to compilation. Through these interface packages the programming paradigms for distributed systems retain the same familiarity as for nondistributed systems, while offering opportunities to exploit the availability of increased parallelism and resiliency. This paper describes the model for partitioning an A& 9X program for distributed execution, an introduction to the fundamental approach for achieving remote procedure calls among partitions, and an explanation of the two forms of dynamically bound remote calls. Permission to copy without fee all w part of this material is granted provided that the copies are not made or distributed for direct commercial advarrtsge, the ACM copyright notice snd the title of the publication and its date appear, and notice is given that copying is by pmission of the Asmciation for Computing Machinery. To copy otherwise, or to republish, requires a fee arrd/or specific permission. (31993 ACM 0-89791-609-3/93/0006133

Adapting Ada distribution and fault tolerance

1.50 Three paradigms are used to illustrate that the abstractions for dynamically bound remote calls, when combined with other Ada 9X features, allow remote procedure calls ~ to be scaled up towards reliable distributed programming. In particular, a paradigm to access the operations of remote objects is presented as evidence that Ada 9X is a distributed programming language suitable for developing megamodule components. Model for Distributing an Ada 9X Svstem The A& 9X model for programming distributed systems specifies a partition as the unit of distribution. The model borrows from the virtual node concept [13] and earlier work that developed the concept into a library unit construct named a partition [14]. Partitions comprise aggregations of library units that may execute using a distributed target execution environment. Typically, each partition corresponds to a single execution site where all its library units occupy the same logical address space. The principal interface between partitions is one or more package specifications. The model specifies rules for partition composition, elaboration, execution, and interpartition communication. Support for configuring partitions to the target execution environment and its associated communication connectivity is not explicitly specified. The partition model (Figure 1Partition Model) allows a simple, consistent, and systematic approach towards composing distribut.~ systems based upon the partition concept. Partitions are specified subsequent to the compilation of their constituent library units. Programming cooperation among partitions is achieved by library level packages defied to allow access to data and subprograms in different partitions. These library (interface) packages are identified at compile-time by categorization pragmas and are explicitly @signed subsequently to partitions. In this way, strong typing and unit consistency are maintained across a distributed system, while the complexity of a distributed run-time system is avoided. 1993 Washington Ada Symposium 133 Partitions may be either active or passive. The librasy

Virtual nodes/distributed systems working group

During the Third International Real Time Ada Workshop held at Nemacolin Woodlands, Pennsylvania, in June 1989, the present authors formed a study group to review the changes in the Ada standard which would make the language more suitable for programming distributed systems. It was accepted that one of the important advantages of distributing embedded systems was the potential for recovery from partial failure of hardware, and that the techniques of programming recovery from such failure were not well supported by the current form of Ada. The working group made specific proposals, which have since been refined at a further meeting and discussions by electronic mail. The present paper reviews the causes of difficulty, and then outlines the new proposals, explaining their rationale in relation to the identified requirements.

Evaluating the performance efficiency of Ada compilers

The Virtual Node approach for partitioning a program for distributed execution received considerable attention at the last workshop. While the workshop failed to achieve consensus on virtual nodes, there was some sentiment that the approach could be quite useful while only requiring limited changes to the language. This working group addressed some of last year’s criticisms regarding partitioning restrictions and the support that would be required in the revised standard.

Towards distributed objects for real-time systems

The use of the Ada language [Ada83] to implement miss ion-cr i t ica l embedded computer applicat ion programs discloses the need for a methodology to evaluate the performance ef f ic iency of the object code that is generated by Ada compilers. The approach described in th is paper is a methodology that has been used to conduct a study of the ef f ic iency of the object code generated by an Ada compiler that w i l l be used in an advanced defense system. This system, current ly under development by the IBM Corporation, is expected to become one of the f i r s t large-scale miss ion-cr i t ica l applicat ions in which Ada is used extensively as an implementation language.

Ada-Java communication in ADEPT

This paper illustrates that several of the new features specified in the revised Ada standard facilitate programming real-time distributed/parallel applications. In particular, the Ada Distributed Systems Annex supports both statically bound and the more object-oriented dynamically bound remote procedure calls. These features are used to implement a paradigm for composing asynchronous remote procedure calls when both input and output parameters are required. The paradigm is based upon the notion of a distributed object through which the output parameters may be returned without blocking the execution of the caller. Such paradigms, when combined with the enhanced features for concurrency and data synchronization, suggest that Ada will contribute towards understanding some of the issues relevant to developing efficient implementations of distributed objects to support the next generation of real time systems.<<ETX>>