Application specific conversation schemes for ADA programs

doi:10.1016/0165-6074(95)00014-3

Microprocessing and Microprogramming

Volume 41, Issue 10, June 1996, Pages 703-713

Microprocessing and ...

https://doi.org/10.1016/0165-6074(95)00014-3 Get rights and content

Abstract

The paper considers a development of the conversation scheme version proposed by A. Clematis and V. Gianuzzi in Microprocessing and Microprogramming (Vol. 32, No. 1–5, 1991) [5] and Computer Languages (Vol. 18, No. 3, 1993) [6]. The authors discussed the methodology of using conversations within a conventional concurrent language (Ada), which makes the conversation scheme practical. In our paper we concentrate on the improvements for their scheme. We believe that it is important for the programmer to have more choice, and propose what could be called a library of schemes from which the appropriate scheme could be chosen depending on the application. We discuss ways of setting dynamically the number of processes participating in a conversation; of having different sets of servers involved in different alternates of the same conversation; of introducing a global acceptance test which would be more sophisticated; of increasing robustness of the conversation. All of these proposals are meant to be used within a conventional language.

References (13)

A. Clematis et al.
Software fault tolerance in concurrent Ada programs
Microprocessing and Microprogramming
(1991)
A. Clematis et al.
Structuring conversation in operation/procedure oriented programming languages
Comput. Lang.
(1993)
Ada programming language, Language and standard libraries, Draft
ANSI/ISO/IEC, IR-MA-1363-3
(1993)
T. Anderson et al.
A framework for software fault-tolerance in real-time systems
IEEE Trans. Software Eng.
(1983)
G.R. Andrews et al.
Concepts and notations for concurrent programming
ACM Comput. Surveys
(1983)
A. Best et al.
A formal model of atomicity in asynchronous systems
Acta Inform.
(1981)

There are more references available in the full text version of this article.

Cited by (3)

A study of atomic action schemes intended for standard Ada
1998, Journal of Systems and Software
Although the number of proposals discussing various atomic action schemes is increasing, these schemes are very rarely used in designing practical applications. To a large extent, this is accounted for by the gap existing between the languages used in research and the standard or widely spread languages (e.g. C, C++, Ada 83, Ada 95, Java) employed by practitioners. Moreover, very often researchers extend languages with new features or invent new languages to express their ideas better. Even though these approaches seem to be quite natural, they widen the gap between practice and research. To bridge this gap, we should consider fault tolerance schemes in terms of a standard language, taking the language itself for granted. The question which we believe should be addressed is how to use/implement a particular scheme in these languages rather than how to modify the language. Only in this way the schemes could be used directly and the application domains of atomic action schemes extended. The main intention of this paper is to summarise research that has been done in the last years in designing various atomic action and conversation schemes in Ada 83 and Ada 95. This should give a fuller picture of the existing schemes for researchers and help practitioners to choose the appropriate schemes. We would also like to raise and discuss some questions concerned with moving fault tolerance schemes into standard languages and environments. Finally, we intend to discuss the likely directions of future research in this area.
Practical exception handling and resolution in concurrent programs
1997, Computer Languages
The paper discusses how atomic actions based on forward error recovery in the form of concurrent exception handling and resolution can be programmed within standard conventional languages (Ada and Ada 95). We express the main characteristics of the general atomic action scheme in terms of these languages and discuss a set of templates and programmers' conventions which would allow the programming of atomic actions within Ada and Ada 95. We offer an approach to implementing a resolution procedure (function) and outline other approaches. The scheme is very flexible in that it gives an opportunity for programmers to use any sort of the resolution procedure. We introduce a general concept of self-checking programming, which allows the kind of failure assumption necessary for simplifying the atomic action support, and discuss how it can be applied (to Ada, in particular). It is shown how this approach helps to solve the deserter process problem. We outline the main improvements which can be made in the scheme when Ada 95 is used. We believe that this paper discusses important practical questions because it seems unlikely that an existing practical language will have concurrent exception handling of the level sufficient for supporting atomic actions based on forward error recovery.
Programming replicated systems in Drago
2000, Computer Systems Science and Engineering

^∗: Present address: Computing Department, University of Newcastle upon Tyne, Newcastle upon Tyne, NE1 7RU, UK.

View full text

PaperApplication specific conversation schemes for ADA programs

Abstract

Microprocessing and Microprogramming

Comput. Lang.

Ada programming language, Language and standard libraries, Draft

ANSI/ISO/IEC, IR-MA-1363-3

A framework for software fault-tolerance in real-time systems

IEEE Trans. Software Eng.

Concepts and notations for concurrent programming

ACM Comput. Surveys

A formal model of atomicity in asynchronous systems

Acta Inform.

Paper
Application specific conversation schemes for ADA programs