一个基于Ada的面向对象建模语言

给出了一个基于Ada的建模语言AML.AML以Ada95为基础,吸取了Ada95的基本原理和思想,利用支持建模的设施对其进行扩充,以便适用于软件建模的各个阶段.AML沿用了Ada95中的程序包概念,并将程序包作为它的核心成份,同时,沿用了Ada95的任务单元和保护单元等设施,以精确描述了软件系统中主动控制成份和资源保护成份的各种特性;AML吸取了图形化面向对象建模语言与建模方法所采用的多视点模型思想,将实体不同侧面的特征分开描述;AML利用一种新的并发模型和限制设施,有效地解决了系统的并发特性和不确定性等非功能特性的描述问题;AML有较强的可扩充性,能应用于各种应用领域.总之,AML是一个既面向用户,面向开发者,又面向系统的通用建模语言,有效地克服了现有一些建模语言在表达能力和应用范围等方面存在的诸多不足.     

VAX／VMS Ada编译程序的结构与功能

《Ada编译程序系统剖析》是我国七·五期间军用计算机研制计划中的主要课题之一。其目标是以VAX/VMS Ada编译程序系统的目标码为对象,搞清该系统的结构、功能、方法和接口技术。从Ada编译及其环境各方面介绍了Ada编译系统的结构、所采用的编译方法、各遍扫描的任务和相互接口、中间语言的形式、Ada任务与异常的实现以及与操作系统VMS的接口等技术。     

分布式Ada语言系统的实现

基于Ada 95参考手册附录E“分布式系统”中的思想,提出了实现分布式Ada语言系统的一些概念和设计思想,并给出了实现分区通信子系统的具体方案.在此基础上,通过一些前置处理,并利用已实现的分区通信子系统的接口,实现了分布式Ada语言系统.最后通过一个实例,具体介绍了分布式Ada语言系统的程序设计方法.     

在共享存贮器的多处理机系统中Ada任务的同步

Ada语言通过设定任务为一个程序中并行的过程提供了一种工具。几个异步执行的任务可以连续地写在一个Ada语言程序中。任务内部的通讯和同步是通过会合原理来保证的。本文论述的是多处理机系统中Ada任务的一种实现方法。文中用Intel80286处理机作为这种系统的例子,并例举了实现约定任务间的通讯与同步所需要的代码,这些任务可能是在不同的处理机上执行。任务内的信息传送是Ada应用程序的一个重要方面。本文中有效地址信息可在整个共享的内存中传送。     

P—Ada：一个基于工作站机群的Ada95编译系统

Ada95语言是一种功能十分强大的高级程序设计语言,其诸多特征,例如强类型检查,数据抽象以及面向对象等,反映了现代软件工程的要求,便于程序员开发高可靠性、高可移植性的大规模实时软件系统。在并行处理方面,Ada95语言提供了任务描述机制用以支持并发程序设计。在现有的Ada95编译器中,任务机制一般都是在单机上或共享内存的多机系统上利用多线程实现的,因而在不存在共享内存的松散耦合的系统中无法使用。     

Ada语言族

本文提出由Ada全集和各种子集构成Ada语言族的概念。根据应用的对象和特点,定义了Ada语言族中四个子集,即基本顺序子集、系统程序设计子集。科学计算子集和实时控制子集。     

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

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

Ada与图形核心系统

图形核心系统(GKS)是一种通用的、独立于设备的二维图形系统。由国际标准化组织(ISO)[ISO 1982]和美国标准化协会(ANSI)主持的该系统的标准化工作,现在已进入了最后阶段。每一项GKS标准化工作都与程序设计语言的联编(binding)有关。它为GKS的实现提供了特定语言的标准化接口。当前在该项标准化工作的建议草案中,把Ada语言联编到ANSI GKS[ANSI 1985]。本文介绍产生联编到ANSI GKS的Ada语言和用Ada实现GKS(GKS/Ada)的研究工作。这与建议的Ada语言联编的草案要求相一致。这将是第一个展示标准化的Ada图形能力的系统。     

Ada编译中若干问题

Ada是由Jean D.Ichbiah等人代表美国国防部设计的一个新的系统程序设计语言,我们提出了Ada编译程序的一种结构,它分为(不依赖于机器的)前端部分与依赖于机器的后端部分。文章讨论了解决前端设计某些问题的若干方法。最后简要地介绍了中间语言DIANA,它是专门为表示Ada程序的中间形式而设计的。     

Ada会合嵌套关系与会合嵌套复杂性度量——Ada会合关系并发复杂性质量研究之三

影响并发程序复杂性的最重要因素是任务之间的通讯和同步行为。我们认为这些行为表现为Ada程序中的会合和会合之间的关系。在这项系列研究里,我们要考察Ada程序中的会合、会合之间的关系和关系的分类,深入研究会合接续和嵌套关系,为接续关系引入接续图,为嵌套关系引入嵌套树,并给出构造这些图和树的方法和它们的一些性质。最后,我们建议Ada程序P的并发复杂性CC(P)是接续复杂性SC(P)和嵌套复杂性NC(P)的加权和;SC(P)是可从Ada程序正文静态识别的会合关系构成的诸会合接续图的边数之和,NC(P)是诸嵌套树的加权节点数之和。文中还给出若干可静态断言程序死锁的充分条件。本文第三部分讨论Ada会合的嵌套关系和程序的会合嵌套复杂性度量,并将综合这几部分研究,提出Ada程序并发复杂性度量的综合指标。     

Implementing atomic actions in Ada 95

Atomic actions are an important dynamic structuring technique that aid the construction of fault-tolerant concurrent systems. Although they were developed some years ago, none of the well-known commercially-available programming languages directly support their use. This paper summarizes software fault tolerance techniques for concurrent systems, evaluates the Ada 95 programming language from the perspective of its support for software fault tolerance, and shows how Ada 95 can be used to implement software fault tolerance techniques. In particular, it shows how packages, protected objects, requeue, exceptions, asynchronous transfer of control, tagged types, and controlled types can be used as building blocks from which to construct atomic actions with forward and backward error recovery, which are resilient to deserter tasks and task abortion     

Real-time interrupt handling in Ada

The Ada? programming language defines the semantics of interrupt handling as part of the tasking mechanism, making it possible to construct implementation-independent interrupt handlers. However, for the Ada mechanism to be effective, an implementation must provide support not specified by the Ada standard, such as for initializing hardware interrupting devices, handling unexpected interrupts and optimizing for real-time performance constraints. This paper analyses some of the constraints that efficient interrupt support places on an implementation. It develops a model for the interaction between interrupt hardware and Ada tasks and describes optimizations for Ada interrupt handlers. Implementation issues, including task priorities and task termination for interrupt handlers, are discussed in detail.     

Monitoring for Deadlock and Blocking in Ada Tasking

We present a deadlock monitoring algodrithm for Ada tasking programs which is based on transforming the source program. The transformations introduce a new task called the monitor, which receives information from all other tasks about their tasking activities. The monitor detects deadlocks consisting of circular entry calls as well as some noncircular blocking situations. The correctness of the program transformations is formulated and proved using an operational state graph model of tasking. The main issue in the correctness proof is to show that the deadlock monitor algorithm works correctly without having simultaneous information about the state of the program. In the course of this work, we have developed some useful techniques for programming tasking applications, such as a method for uniformly introducing task identifiers. We argue that the ease of finding and justifying program transformations is a good test of the generality and uniformity of a programming language. The complexity of the full Ada language makes it difficult to safely apply transformational methods to arbitrary programs. We discuss several problems with the current semantics of Ada's tasks.     

Ada-I:支持保护对象继承的Ada95扩充语言

面向对象并发程序设计语言能够帮助程序员利用面向对象技术编写并发程序,从而获得面向对象技术给软件开发带来的种种好处.然而,由于继承异常现象的存在,影响了并发程序设计语言引入继承特性.Ada95语言是支持并发程序设计的面向对象语言之一,但并不支持保护对象的继承.Ada-I语言在Ada95语言的基础上进行扩充,从而支持保护对象的继承,并且避免了继承异常现象的出现.     

Ada95保护对象与面向数据的同步

本文详细讨论了Ａｄａ保护对象机制，分析其应用并将之与其它有关设施进行了分析与比较。     

Temporal logic-based deadlock analysis for Ada

A temporal logic-based specification language and deadlock analyzer for Ada is described. The deadlock analyzer is intended for use within Timebench, a concurrent system-design environment with support for Ada. The specification language, COL, uses linear-time temporal logic to provide a formal basis for axiomatic reasoning. The deadlock analysis tool uses the reasoning power of COL to demonstrate that Ada designs specified in COL are systemwide deadlock-free: in essence, it uses a specialized theorem prover to deduce the absence of deadlock. The deadlock algorithm is shown to be decidable for finite systems and acceptable otherwise. It is also shown to have a worst-case computational complexity that is exponential with the number of tasks. The analyzer has been implemented in Prolog. Numerous examples are evaluated using the analyzer, including readers and writers, gas station, five dining philosophers, and a layered communications system. The results indicate that analysis time is reasonable for moderate designs in spite of the worst-case complexity of the algorithm     

On the Implementation and Use of Ada on Fault-Tolerant Distributed Systems

In this paper, we discuss the use of Ada® on distributed systems in which failure of processors has to be tolerated. We assume that tasks are the primary object of distribution, and that communication between tasks on separate processors will take place using the facilities of the Ada language. It would be possible to build a separate set of facilities for communication between processors, and to treat the software on each machine as a separate program. This is unnecessary and undesirable. In addition, the Ada language Reference Manual states specifically that a system consisting of communicating processors with private memories is suitable for executing an Ada program.     

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     

Issues in Ada compiler technology

The key technical issues involved in producing high-quality Ada compilers and related support tools are discussed. These include real-time issues, programming tools and environments, and code optimization. Also addressed are some important problems that compiler designers face, for example, determining which deficiencies of existing Ada systems can be attributed to the language and which are simply hard-to-implement features or unresolved issued in Ada compiler technology     

Distributing concurrent Ada programs by source translation

This paper tackles the practical aspects of obtaining a distributed version of an Ada program. It proposes the use of an adapter, which can be a methodology or an automatic translator. The adapter accepts source of a concurrent Ada program, adds communication and control tasks, and produces source for a single distributed Ada program, which can then be compiled and run on a multi-processor computer. The original program can consist of packages and tasks, and both of these can be classed as virtual nodes. The process of adaption does not alter the contents of any package in the original program, so that the method is directly applicable to systems that make use of library and generic packages. The communication between virtual nodes, which would normally reside as one per processor, is via messages on a ring, but the protocols are kept as simple as possible, and the messages are fully checked Ada types, rather than byte strings. The method has been applied to programs of the client-server model, and could be adapted for other rendezvous-based languages such as occam.