Distributed Systems Annex Research Articles

Ada and many-core platforms

The new many-core platforms make it difficult for the programmer to provide efficient mapping of Ada programs onto the underlying non-uniform hardware. This paper discusses how existing Ada concepts such as Dispatching Domains and the Distributed Systems Annex can be extended or changed to better support the hierarchical and heterogeneous nature of these platforms.

Adapting the end-to-end flow model for distributed Ada to the ravenscar profile

This paper presents a proposal to develop High-integrity Distributed Real-Time (HDRT) systems by integrating the real-time end-to-end flow model with the Ravenscar profile. Although this profile is being widely used in the development of single-processor critical hard real-time systems, further research is required to apply this profile in a distributed environment. This work is built upon the endpoints pattern, a technique that we have used to integrate the end-to-end flow model into Ada's Distributed Systems Annex (DSA). We adapt our previous work to the requirements of the Ravenscar profile. Therefore, this paper gives a step forward and discusses the modifications needed to make a specific instance of the endpoints pattern compatible with Ravenscar.

Gem #84

Ada Gem #84 --- This is the first in a series of Gems introducing the facilities defined by the optional annex for distributed systems (Annex E) in the Ada Reference Manual. In this introduction, we show how a simple client/server architecture can be implemented easily with the Distributed Systems Annex (DSA).

Gem #85

Ada Gem #85 --- This is the second in a series of Gems introducing the facilities defined by the optional annex for Distributed Systems (Annex E) of the Ada Reference Manual. In the first installment, we showed how a simple client/server architecture can be implemented easily with the Distributed Systems Annex (DSA). We now introduce distributed objects, which allow dynamic relationships between components of a distributed application.

Gem #87

Ada Gem #87 --- This is the third in a series of gems introducing the facilities defined by the optional annex for Distributed systems (Annex E) of the Ada Reference Manual. In the previous two installments, we introduced the Distributed Systems Annex (DSA). We showed how a client/server architecture can be implemented, and we introduced distributed objects. The present gem shows how asynchronous message passing can be implemented on top of these facilities.

Support for a real-time transactional model in distributed Ada

This paper presents a proposal to integrate a generic technique to express complex scheduling and timing parameters of distributed transactions as a part of the Distributed Systems Annex of Ada (DSA). The technique allows real-time middleware implementations to change their scheduling policies for both the processing nodes and the networks with a minimal interference in the application code. The proposed mechanisms are managed by the middleware in a transparent way. The only requirement is an initial configuration operation, which can be generated automatically, and a single operation call to set an event identifier in each of the tasks that initiates a distributed transaction. The automatic process used to obtain the initial configuration of the distributed application, based on a real-time model, is also proposed. The implementation of this proposal is currently being developed.

Distributed status monitoring and controlusing remote buffers and Ada 2005

The ability to monitor status and control equipment distributed over a network is a common network management need. This paper describes a relatively simple approach to designing a prototype dynamic network where the assets of all vehicles on the network can be monitored and controlled at multiple remote stations. In particular, Ada 2005 features are explored in conjunction with Ada's Distributed Systems Annex (DSA) features to utilize a suite of remote buffer classes that implement an interface providing a mechanism for sharing a distributed dataset. In addition, the paper demonstrates an approach for distributed interoperability between Ada and C++ by using the DSA to distribute a C++ class hierarchy of objects that can be accessed by application code written in both languages. Finally, the paper exposes a need and describes a possible solution for enhancing existing DSA implementations in order to provide better support for multicast networking solutions.

A comparison of CORBA and ada's distributed systems annex

With the recent advent of affordable computers, and the increased computing needs in numerous different fields, distributed computing has become quite popular. Along with this popularity has come several different approaches for creating distributed systems. Ada is fortunate to have multiple approaches available, each distinctively different from each other. One approach is to use a separate middle layer to allow different parts of the Ada distributed program to communicate. The Common Object Request Broker Architecture, or CORBA, uses this approach. Another approach is to use an extension of the language made for the creation of distributed systems, meaning no extra layers need to be added. This language extension approach is used by Ada's Distributed Systems Annex. While both approaches have their merits, CORBA has received much more attention than Ada's Distributed Systems Annex. This paper is the result of an undergraduate research project to examine how easy each approach was, and to see if the extra attention given to CORBA is deserved.

Using Linux and Ada in the Development of Distributed Computer Control Systems

Many dist-ibuted computer control systems are non-critical in the sense that they have only soft time constraints and no stringent safety requirements. This is the case with certain teleoperated robot control systems, which can be effectively built on top of general purpose hardware and software execution platforms, instead of having to use costly and difficult-to-program real-time computers and operating systems. An approach for developing such kind of applications, based on the use ofLinux and Ada on PC architectures, is presented in this paper. Distribution is based on the Distributed System Annex of Ada on top of a TCP/lP LAN. A number of guidelines on how to use them in a proper way are described with reference to an example teleoperation architecture.

DROOPI

This paper presents our work to bridge the Ada 95 Distributed Systems Annex (DSA) and CORBA to take advantages of both environments facilities. Our project consists in two successive steps. The first one is CIAO, a DSA to CORBA translator. The second one aims at the definition of a generic middleware to be customized to DSA and CORBA. We propose a definition and an architecture of services for a generic middleware, D ROOPI , and explain how it can be customized according various criteria. This generic middleware takes advantage of the lessons learned in the design and the development of several projects: GLADE [24], AdaBroker [1], and CIAO [25]. Therefore, in its motivation and its targetting, we believe D ROOPI is an original project.

Issues with using Ravenscar and the Ada distributed systems annex for high-integrity systems

The Distributed Systems Annex (DSA) was designed for general-purpose distributed systems programming. This paper explores the practical use of the DSA in terms of high-integrity real-time distributed systems. In particular, it defines a high-integrity subset of the DSA and considers how such a subset can be implemented using SPARK and Ravenscar.

Towards a real-time distributed systems annex in Ada

In this paper we address the problem of combining two issues that are standardized separately in two Ada 95 annexes: Real-Time Systems (Annex D) and Distributed Systems (Annex E). With these annexes it is possible to build applications with real-time requirements, or alternatively distributed applications; but real-time distributed applications are not directly supported. In this paper we propose extensions to the Distributed Systems Annex that would provide support for developing distributed real-time applications in Ada. The paper proposes an interface for assigning priorities to the messages in the interconnection networks, and also to the tasks executing remote operations, in a way that avoids priority inversions. It also addresses the issues of configuration of the RPC handler tasks and non blocking asynchronous remote procedure calls.

What future for the distributed systems annex?

In this paper, we report our experience as implementors and users of the Ada 95 Distributed Systems Annex (annex E of the Ada reference manual). We identify the principal strengths and weaknesses of the annex, and make some proposals to improve it either immediately or for the next revision of the language (Ada0X). Our goal is to get an annex that is more open and compatible with other distributed systems such as CORBA, without loosing the capability of developing pure Ada rock solid distributed systems.We assume that the reader is familiar with Ada. Knowledge of the Distributed Systems Annex is useful but not required to understand the main ideas exposed in this article.

CORBA and CORBA services for DSA

Comparing CORBA and the Ada 95 Distributed Systems Annex shows that an advantage of CORBA is its Common Object Services, providing standard, frequently-used components for distributed application development. This paper presents our implementation of similar services for the DSA. We also introduce new developments of our team that aim at providing close interaction between CORBA and Ada applications. Part of the work presented here was accomplished by the AdaBroker team: Fabien Azavant, Emmanuel Chavane, Jean-Marie Cottin, Tristan Gingold, Laurent Kübler, Vincent Niebel, and Sébastien Ponce.

Prioritizing remote procedure calls in Ada distributed systems

In this paper we discuss the assignment of priorities to the execution of remote procedure calls in distributed real-time systems that are programmed using the Distributed Systems Annex (DSA) of Ada 95. We first discuss the current priority model used in the Glade implementation of the DSA. We then present some theoretical results that show that a more flexible priority assignment methodology can provide much better schedulable utilization levels. Based upon these results we propose an implementation that would allow using this priority assignment methodology in Glade. Finally, we propose new features for a future DSA that would allow prioritizing remote procedure calls in a flexible manner.

A portable implementation of the distributed systems annex in Java

article Free Access Share on A portable implementation of the distributed systems annex in Java Authors: Yoav Tzruya Department of Computer Science, Tel-Aviv University, Ramat-Aviv 69978 Israel Department of Computer Science, Tel-Aviv University, Ramat-Aviv 69978 IsraelView Profile , Mordechai Ben-Ari Department of Science Teaching, Weizmann Institute of Science, Rehovot 76100 Israel Department of Science Teaching, Weizmann Institute of Science, Rehovot 76100 IsraelView Profile Authors Info & Claims ACM SIGAda Ada LettersVolume XVIIIIssue 6Nov./Dec. 1998 pp 204–211https://doi.org/10.1145/301687.289620Published:01 November 1998Publication History 0citation241DownloadsMetricsTotal Citations0Total Downloads241Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Distributed Atomic Actions in Ada 95

This paper discusses the development of a distributed asynchronous atomic action scheme for Ada 95. The scheme makes use of many unique Ada 95 features including protected objects, asynchronous transfer of control and the distributed systems annex. We present the packages which implement the local and global action support and illustrate their use in a (partial) implementation of the FZI production cell problem. We also discuss a number of variations of the model and how these might be included. Finally, we discuss how the distribution model used in Ada 95 has influenced our design.

Programming Replicated Systems in Ada 95

This paper considers the programming of passive (cold and warm standbys) and active replicated systems in Ada 95. We show that it is relatively easy to develop systems which act as standbys using the facilities provided by the language and the Distributed Systems Annex. Arguably, active replication in Ada 95 can be supported in a manner which is transparent to the application. However, this is implementation-dependent, requires a complex distributed consensus algorithm (or a carefully chosen subset of the language to be used) and has little flexibility. We therefore consider two extensions to the Distributed Systems Annex to help give the application programmer more control. The first is a via a new categorization pragma which specifies that a RCI package can be replicated in more than one partition. The second is through the introduction of a coordinated type which has a single primitive operation. Objects which are created from extensions to coordinated types can be freely replicated across the distributed system. When the primitive operation is called, the call is posted to all sites where a replica resides, effectively providing a broadcast (multicast) facility. We also consider extensions to the partition communication subsystem which implement these new features.