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

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

Ada并发软件的图形化设计方法研究

研究的目标：为Ada并发软件的设计提供一种图形化的方法和支撑工具，以便用图形表达并发软件的设计，并生成并发程序的框架（并发程序单元的划分和它们之间的通信）。这样做的好处在于提高软件的生产率，改善软件质量。在提出用于并发软件理解的会合次序图的基础上，给出了并发设计语言CONDL的语法、语义描述和图形化表示（泳道），并简单介绍了所研制的一个工具CONDLAS（生成Ada代码框架）。     

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

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

Ada会合关系及其分类：Ada会合关系并发复杂性度量研究之一

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

Ada语言并发机制的设计与实现

Ada语言并发机制是Ada语言区别于其他高级程序设计语言的主要特征之一。本文介绍了Ada语言并发机制的一种实现方法及其符合我们环境要求的实现策略;此外,还就如何编译含并发语句成份的Ada程序作了介绍。     

Ada会合接续关系及会合接续复杂性度量——Ada会合关系并发复杂性度量研究之二

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

一种Ada83服务性任务向Ada95保护对象变换的方法

任务是Ada语言支持并发程序设计的基础,它提供了一种进程同步和通信的良好机制.但也存在一类被动的、专为其他任务服务的服务性任务.服务性任务的存在增加了系统的负担,降低了系统的性能.如果能将服务性任务变换为保护对象,则可以明显地提高系统的性能,减少维护的费用.该文提出了一种在源程序级将Ada83服务性任务变换为Ada95保护对象的方法.先给出服务性任务应满足的条件、识别和表示服务性任务的方法,最后讨论此方法的可行性.与其他方法相比,此方法具有假设条件少、识别和变换效率高以及容易验证等特点.     

一种利用并发提高数据处理吞吐率的模型

针对分布式组网终端集中式数据采集与处理系统实时性高、数据吞吐量大、周期性强等特点,引入了一种利用并发机制的大吞吐量实时数据处理模型,在讨论模型基本结构和原理的基础上,深入研究了决定模型数据吞吐效率和时效性能的并发缓存机制和算法设计。利用该模型实现的数据采集处理系统在基于GPRS组网的1500个自动气象站数据采集与处理业务应用中,性能稳定可靠,能够满足对周期性大批量实时＂浪涌＂数据进行实时快速处理的要求,大大提高了数据处理的吞吐效率。     

分布式数据库并发控制方法研究

并发控制机制是数据库事务管理中重要的组成部分,是衡量一个数据库系统功能强弱和性能好坏的重要标志之一。分布式并发控制的目的是保证分布事务和分布式数据库的一致性,实现分布事务的可串行性,使事务具有良好的并发度以保证系统具有用户满意的效率。本文首先就分布式数据库并发事务的可串行化进行探讨并在此基础上提出分布式数据库并发控制的基本方法。     

协同虚拟环境中的并发控制机制

针对协同虚拟环境（CVE）并发控制在一致性、响应性和并发性之间存在的矛盾,提出一种基于客户端的并发控制机制。该机制通过在客户端保存共享物体的状态信息,使系统的一致性得到提高,利用基于对象属性的并发控制思想,提高系统的响应性。实验表明,该并发控制机制能使CVE系统在一致性、响应性和并发性等方面达到较好的平衡。     

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.     

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     

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.     

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     

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     

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     

Transformations for optimizing interprocess communication and synchronization mechanisms

This paper presents source-level transformations that improve the performance of programs using synchronous and asynchronous message passing primitives, including remote call to an active process (rendezvous). It also discusses the applicability of these transformations to shared memory and distributed environments. The transformations presented reduce the need for context switching, simplify the specific form of communication, and/or reduce the complexity of the given form of communication. One additional transformation actually increases the number of processes as well as the number of context switches to improve program performance. These transformations are shown to be generalizable. Results of hand-applying the transformations to SR programs indicate reductions in execution time exceeding 90% in many cases. The transformations also apply to many commonly occurring synchronization patterns and to other concurrent programming languages such as Ada and Concurrent C. The long term goal of this effort is to include such transformations as an otpimization step, performed automatically by a compiler.This work was supported by NSF under Grant Number CCR88-10617.