提高Ada并发效率的一种途径

Ada的会合机制使我们能在高级语言一级上描述系统的并发活动,从而避免了在使用低级通信原语时所不可避免的问题。但由于会合机制是一种完全同步的实现机制,因此其并发效率较低。为此,本文提出：采用基于Ada保护对象的（异步）信箱机制实现Ada会合的服务模型,使之既具有会合机制的高可靠性,又能提高系统的并发度和实现效率。     

Ada程序的会合次序图

针对Ａｄａ程序提出了一种会合次序图，用以表达程序中的会合次序和任务的流程。同已有的其他多任务描述工具相比，更容易理解，可以用做并发程序的设计描述手段和程序理解工具。它也适用于其他具有舍并并发机构的语言。     

SSAC,一个基于软件科学法的Ada程序复杂性度量工具

ＳＳＡＣ是一个基于软件科学法的Ａｄａ程序复杂性度量工具，其主要特征是能同时分别度量程序的顺序复杂性和并发复杂性。文中描述了Ａｄａ程序中并发操作符和并发操作元的定义和识别。同时提出在Ａｄａ程序复杂性综合度量中，并发复杂性的加权思想。     

关于Ada并发可重用软件包的设计

文中首先分析了一般Ａｄａ顺序可重用软件包在用于开发Ａｄａ并发软件时所存在的问题，然后给出了几种可以支持并发软件开发的Ａｄａ可重用软件包的实现方案，并同时指出了各种方案的不足及可取之处。     

实现Ada 9X保护对象和控制异步转移

为了更好支持实时系统中使用并行机制，Ａｄａ程序设计语言的修订标准－Ａｄａ９Ｘ扩充了Ａｄａ的任务机制模型，这些扩充需要新的实现方法，该文讨论了有关技术问题，并且概述了实现方案－ＧＮｕＡｄａ运行库，详细地讨论了两个特点：保护对象和控制异步转换，保护对象是一种数据对象，对于多任务并发存取是安全的，控制异步转换允许一个任务去响应中止当前计算的异步事件，并把控制转移到该任务中的一个恢复点。     

基于群机系统的Ada编译程序

为了使Ａｄａ程序运行在松散耦合分布式系统并且降低程度员开发分布Ａｄａ的程序的工,设计并实现了基于该环境下的Ａｄａ编译程序。     

PSS／Ada程序切片系统的设计与实现

ＰＳＳ／Ａｄａ是一个Ａｄａ程序静态切片生成系统，可广泛应用于Ａｄａ程序的测试、排错、理解、维护以及Ａｄａ软件的波动性分析、并行性检测和复杂性度量等诸方面，本文介绍ＰＳＳ／Ａｄａ系统的设计思想、系统的结构、工作原理以及系统实现的重要技术细节。     

Ada软件开发系统SUNADADS—2的设计与实现

本文阐述了Ａｄａ软件开发系统ＳＵＮＡＤＡＤＳ－２系统功能的设计与实现。     

BISE Ada8086／8096交叉转换系统的设计与实现

本文给出了基于机器代码程序交叉转换的Ａｄａ交叉转换系统的设计方法和实现细节，简述了系统的基本构成和工作过程，指出了掌握代码交叉转换技术的重要意义。该系统的成功实现，为用Ａｄａ开发单片机应用软件提供了强有力的工具。     

并行算法在系统仿真中的应用

利用Ａｄａ语言单ＣＰＵ多任务并行算法的特点,我们用单ＣＰＵ上多任务并发运行的方法来仿真多机并行处理的模型,实现单机交替并发的并行仿真运算,对单ＣＰＵ多任务并行运算进行了探讨。     

Administrators and multiprocessor rendezvous mechanisms

This paper discusses rendezvous on multiprocessors. Three different approaches are compared, represented by three specific systems: Ada, Harmony and BNR Pascal. All three permit tasks to run on multiple processors and use blocking communications primitives, but there are significant differences. For example, control over replying to messages out of sequence and over the allocation of tasks to processors is omitted in Ada, but is available in Harmony. The approach represented by BNR Pascal follows a middle road between Harmony and Ada: a low level protocol, invisible to the programmer, is used to ensure communications reliability, but the programmer is aware of when a rendezvous is remote. If performance considerations and verbosity and robustness are ignored, all three approaches are equivalent. To illustrate this equivalence, and to demonstrate clearly the complexity of the Ada rendezvous, an Ada rendezvous administrator written using Harmony is described. A second method of adapting Harmony to Ada is also presented, in which the Harmony primitives are modified to be closer to Ada. In practice, using Harmony primitives directly will usually result in better programs. It is argued that something very much like the rendezvous adminstrator is needed for any actual implementation of the Ada rendezvous.     

Concurrent programming in the Ada® language: The polling bias

The rendezvous is an important concept in concurrent programming—two processes need to synchronize, i.e. rendezvous, to exchange information. The Ada programming language is the first programming language to use the rendezvous as the basis of its concurrent programming facilities. Our experience with rendezvous facilities in the Ada language shows that these facilities lead to and encourage the design of programs that poll. Polling is generally, but not always, undesirable because it is wasteful of system resources. We illustrate and examine the reasons for polling bias in the Ada language. We give suggestions on how to avoid polling programs, and suggest changes to the rendezvous facilities to eliminate the polling bias. The ramifications of these changes to the implementation of the Ada language are also discussed. Although we have focused on the rendezvous facilities in the Ada language our analysis is also applicable to other languages. A polling bias can occur in any concurrent programming language based on the rendezvous mechanism if it does not provide appropriate facilities.     

Towards complexity metrics for Ada tasking

Using Ada as a representative distributed programming language, the author discusses some ideas on complexity metrics that focus on Ada tasking and rendezvous. Concurrently active rendezvous are claimed to be an important aspect of communication complexity. A Petri net graph model of Ada rendezvous is used to introduce a rendezvous graph, an abstraction that can be useful in viewing and computing effective communication complexity     

ARTK-M2: A kernel for Ada tasking requirements: An implementation and an automatic generator

A run-time kernel, ARTK-M2, supporting Ada tasking semantics is discussed; full support for task creation, synchronization, communication, scheduling, and termination is provided, together with all options of the Ada rendezvous. An implementation in Modula-2 is presented and a method for automatically translating Ada programs into semantically equivalent Modula-2 programs with corresponding kernel calls is introduced. A parser generator and an attribute grammar were used for the automatic translation. A subset of the Ada Compiler Validation Capability was processed to test the implementation and to illustrate the translation mechanism. The kernel is applicable to the study of real-time control systems; it can also serve as a baseline for studying implementation alternatives of Ada concepts, such as new scheduling algorithms, and for analysing new language constructs. Work is under way to implement some of the changes to the Ada tasking model being proposed as a result of the language revision (Ada9X). Finally, through proper extensions, ARTK-M2 can form an integral part of programming tools such as an Ada compilation system and a distributed kernel for multi-processing environments.     

Rendezvous facilities: Concurrent C and the Ada language

The concurrent programming facilities in both Concurrent C and the Ada language are based on the rendezvous concept. Although these facilities are similar, there are substantial differences. Facilities in Concurrent C were designed keeping in perspective the concurrent programming facilities in the Ada language and their limitations. Concurrent C facilities have also been modified as a result of experience with its initial implementations. The authors compare the concurrent programming facilities in Concurrent C and Ada and show that it is easier to write a variety of concurrent programs in Concurrent C than in Ada     

Measurements of Ada overhead in OSI-style communications systems

A discussion is given on whether the Ada model of concurrency is suitable for implementing the seven-layer OSI reference model. Using the communications model introduced by R.J.A. Buhr (1984), they determine the overhead introduced by Ada when the model is implemented on two single-processor machines, a VAX 11/785 and a Rational 1000. The authors then calculate a lower bound on expected message delay. A novel model using server tasks is proposed and shown to have better performance. The authors investigate performance on an eight-processor Sequent Model 821 and a 14-processor Encore Multimax 320 by implementing the Buhr model, the server task model and a third model which abandons the Ada rendezvous in favor of procedure calls. They determine the Ada overhead per message as a function of the number of processors and calculate lower bounds on expected message delay attributable to Ada overhead for all three communications models     

Adam: An Ada-based language for multiprocessing

Adam is a high-level language for parallel processing. It is intended for programming resource scheduling applications, in particular supervisory packages for run-time scheduling of multiprocessing systems. An important design goal was to provide support for implementation of Ada and its run-time environment. Adam has been used to implement Ada task supervision and also as a high-level target language for compilation of Ada tasking. Adam provides facilities corresponding to the Ada sequential constructs (including subprograms, packages, exceptions, generics). In addition, it provides specialized module constructs for implementation of packages that may be shared between parallel processes, and new predefined types for scheduling. The parallel processing constructs of Adam are more primitive than Ada tasking. Strong restrictions are enforced on the ways in which parallel processes can interact. A compiler for Adam has been implemented in MacLisp on DEC PDP-10 computers. Runtime support packages in Adam for scheduling (on a single CPU) and I/O are also provided. The compiler contains a library manipulation facility for separate compilation. The Adam compiler has been used to build an Ada compiler for most of the July 1980 Ada, including task types and rendezvous constructs. This was achieved by implementing the translation of Ada tasking into Adam parallel processing as a preprocessor to the Adam compiler. This present Ada compiler, which has been operational since December 1980, uses a procedure call implementation of tasking. It can be easily modified to other implementations. Compilation of Ada tasking into a high-level target language such as Adam facilitates studying questions of correctness and efficiency of various compilation algorithms, and code optimizations specific to tasking, e.g. elimination of unnecessary threads of control. This paper gives an overview of Adam and examples of its use. Emphasis is placed on the differences from Ada. Experience using Adam to build the experimental Ada system is evaluated. Design of a run-time supervisor in Adam is discussed in detail.     

Specifying Ada server tasks with executable formal grammars

The author shows how a class of concurrent programming problems can be specified with formal grammars. These grammars, more powerful than path expressions, translate readily into Ada server tasks using the rendezvous and select-statement, though they may also be applied to other synchronization constructs. The grammars may be used to clarify informal specifications, to compare different specifications, and to analyze the behavior of implementations of such specifications. They may also be easily converted into Prolog programs that can be executed to generate the strings of events accepted by a grammar or by the Ada task being modeled. The automated translation from Ada to such grammars, and from grammatical specifications to Ada is discussed. The former facilitates the analysis of Ada programs; the latter yields Ada code of high quality