Javier Miranda

A quick distributed consensus protocol

Abstract A number of current distributed applications require the use of consensus protocols. Two well known examples are fault-tolerant applications built with process replicas in need to agree on their external behavior, and systems of replicated data where consistency has to be maintained. In this paper we first present an already known consensus protocol which has a cost of O( n 2 ) in the number of exchanged messages, and O( n ) in terms of time needed to arrive at an agreement. We then present several refinements to this protocol which make it linear-in the absence of failures-both in terms of exchanged messages and in time spent, and conclude with some remarks on current and future work.

Remote management of distributed application

Distributed computing has been applied to a variety of computational problems. Several software systems have been developed that make distributed applications available to an application programmer. Although these systems provide functionality for the design, execution, monitoring and control of distributed applications, they are not Web-based. The increasing use of Web technology for Internet and Intranet applications is making the Web an attractive framework for solving distributed applications, in particular, because the interface can be made platform independent. We present a Web-based environment which provide remote management of distributed applications. The environment allows the user to configure, execute, monitor and dynamically reconfigure distributed components. In addition the tool tolerates node failures to ensure service availability, and can be tailored to different distributed application platforms. The proposed tool is developed without changing the front-end Web server and does not require manual software installation on the client side as long as a client Web browser is available.

Implementing an Application-Defined Scheduling Framework for Ada Tasking

A framework for application-defined scheduling and its correspond-ing application program interface (API) were defined during the last Interna-tional Real-Time Ada Workshop, and are being proposed for standardization in the future revision of the Ada language. The framework allows applications to install one or more task schedulers capable of implementing a large variety of scheduling algorithms. This paper describes the implementation of this frame-work, both at the compiler and the run-time system levels. The objective of this work is to serve as a reference implementation in which the API can be evalu-ated and tested, and its performance can be assessed. We show that the amount of changes to the compiler is relatively small, and that the application scheduling capability can be supported with a small level of complexity.

The implementation of ada 2005 interface types in the GNAT compiler

One of the most important object-oriented features of the new revision of the Ada Programming Language is the introduction of Abstract Interfaces to provide a form of multiple inheritance. Ada 2005 Abstract Interface Types are based on Java interfaces, and as such support inheritance of operation specifications, rather than the general complexity of inheritance of implementations as in full multiple inheritance. Real-time uses of Ada demand efficient and bounded worst-case execution time for interface calls. In addition, modern systems require mixed-language programming. This paper summarizes part of the work done by the GNAT Development Team to provide an efficient implementation of this language feature and simplifies interfacing with C++.

Integrating application-defined scheduling with the new dispatching policies for ada tasks

In previous papers we had presented an application program interface (API) that enabled applications to use application-defined scheduling algorithms for Ada tasks in a way compatible with the scheduling model defined in the real-Time Annex of the language. Each application scheduler was implemented with a special task. This paper presents a new implementation in which the application scheduler actions are executed as part of the kernel on which the run-time system is based, thus increasing the efficiency. This paper also presents modifications to the proposed API that align it with the evolution of the Ada Issues being considered in the Ada 200Y standardization. First, we use the new concept of deadline as an abstract notion of urgency, to order the tasks in the scheduling queue of the underlying kernel, freeing the application scheduler of the responsibility of keeping the desired ordering of tasks, and thus simplifying it and reducing its overhead. In second place, we also consider task synchronization through protected objects using the new Stack Resource Policy proposed for the EDF task dispatching policy in Ada 200Y, which can be used in a large variety of fixed and dynamic priority scheduling policies without explicit intervention of the application scheduler.

GNAT: on the road to Ada 2005

The GNAT Development Team is directly involved with the Ada 2005 effort, both participating in the Ada Rapporteur Group (ARG), and implementing and testing the new features proposed for the language revision. In this paper we summarize the Ada 2005 issues already implemented in the development version of GNAT, and give a brief overview of the implementation of the more complex ones. We find that the proposed language enhancements fit well into the existing compiler structure, and present no major implementation hurdles.

Programming distributed systems with Group_IO

This paper describes Group_IO, a software library written in Ada which facilitates the construction of distributed applications by means of the group paradigm, an abstraction which considers a set of processes as an individual entity. Group_IO provides support for replicated as well as cooperative groups. Group_IO offers a straightforward interface to reliable, atomic, causal, and uniform multicast services, and it allows client-server interactions where the client may be a process group. It relies on an own consensus protocol to implement the uniform broadcast protocols. Group_IO provides support for the client/server group (1-to-M) communication, client group/server (N-to-1) and client group/group server (N-to-M) communication. Group_IO is the basis on which the programming language Drago has been implemented.

The implementation of ada 2005 synchronized interfaces in the GNAT compiler

One of the most important object-oriented features of the new revision of the Ada Programming Language is the introduction of Abstract Interfaces to provide a form of multiple inheritance. Ada 2005 Abstract Interface Types are akin to Java interfaces, and as such support inheritance of specification rather than inheritance of implementation. Ada 2005 interfaces apply as well to tasks and protected types, and provide a classification mechanism for concurrent programming that goes considerably beyond the capabilities of Java.This paper summarizes the implementation in the GNAT compiler of the various kinds of interfaces that relate to concurrent programming in Ada 2005 [1]. The implementation is efficient, and involves mostly modifications to the compiler front-end, with virtually minimal impact on run-time structures, beyond those that are in place to support regular interfaces. However, the implementation of interface operations as triggers in selective waits and asynchronous transfers of control proved to be surprisingly delicate and requires additional predefined primitive operations.

A proposal to integrate the POSIX execution-time clocks into Ada 95

In this paper we present a proposal to integrate the POSIX.1 execution-time clocks and execution-time timers into the Ada 95 language. This proposal defines a new package named Ada. CPU_Time and describes the modifications done to the GNAT front-end and run-time to support it. Additionally this proposal discusses some usage schemes of this new interface.

Abstract interface types in GNAT: conversions, discriminants, and C++

Ada 2005 Abstract Interface Types provide a limited and practical form of multiple inheritance of specifications. In this paper we cover the following aspects of their implementation in the GNAT compiler: interface type conversions, the layout of variable sized tagged objects with interface progenitors, and the use of the GNAT compiler for interfacing with C++ classes with compatible inheritance trees.