Experience acquiring and retargeting a portable Ada compiler

A technique for implementing Ada with reasonable effort on a piece of non-standard hardware is described. The target machine is a single processing element in an experimental multiprocessor based on NS32000. A portable Ada front-end compiler was used for retargeting, and the process of acquiring and evaluating the front end is described. Based on this experience, comments on the validation, quality and efficiency of Ada compilers are given, along with a detailed overview of the resultant system. The Ada system was built from scratch on the bare hardware. It has three main components: a code generator, a run-time system and an Ada kernel. The code generator is table driven and generates symbolic NS32000 assembler. This code is then assembled and linked by commercially available components. The run-time system and the kernel are implemented in assembly language and Concurrent Euclid and handle tasking, exceptions and scheduling. The result is a complete Ada implementation.     

一种基于PGRM结构的负载分布策略

本文首先介绍一种基于并行图重写模型的并行图重写机ＰＧＲＭ。在此基础上提出一种新的任务分布策略。目标是以基于多线程的负载分布策略，减少系统的通讯开销，缩短响应时间并且使派生的任务有合理的计算粒度。本文提出的策略是一种融合分布式与集中式两种控制机制的一种混合策略。实验测试结果表明这种分布策略在多ＴＲＡＮＳＰＵＴＥＲ构成的分布存储多机系统上具有高效性和实用性。     

Performance prediction and evaluation of parallel processing on aNUMA multiprocessor

The efficiency of the basic operations of a NUMA (nonuniform memory access) multiprocessor determines the parallel processing performance on a NUMA multiprocessor. The authors present several analytical models for predicting and evaluating the overhead of interprocessor communication, process scheduling, process synchronization, and remote memory access, where network contention and memory contention are considered. Performance measurements to support the models and analyses through several numerical examples have been done on the BBN GP1000, a NUMA shared-memory multiprocessor. Analytical and experimental results give a comprehensive understanding of the various effects, which are important for the effective use of NUMA shared-memory multiprocessor. The results presented can be used to determine optimal strategies in developing an efficient programming environment for a NUMA system     

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.     

BJ—01并行计算机的系统软件

本文介绍了ＢＪ－０１并行计算机操作系统ＭＯＳ，并行Ｃ语言ＰＣＬ以及接口软件的设计和实现技术。此外还讨论了ＢＪ－０１并行机的并行执行环境和并行程序调试工具。     

Simulation of hierarchical multiprocessor database systems

The paper is dedicated to issues concerning simulation and analysis of hierarchical multiprocessor systems oriented to database applications. Requirements for a parallel database system model are given. A survey and comparative analysis of known parallel database system models are presented. A new multiprocessor database system model is introduced. This model allows us to simulate and evaluate arbitrary hierarchical multiprocessor configurations in the context of the OLTP class database applications. Examples of using the database multiprocessor model for simulation study of multiprocessor database systems are presented.     

多处理机并行处理模拟器的设计与实现

“多处理机并行处理模拟器”是旨在帮助使用者巩固和加深对典型的并行计算机系统－－ＭＩＭＤ多处理机系统－－进行并行处理基本工作过程的理解，通过实际编写并行应用程序并对其模拟执行的过程进而引导其进行更为深入研究与开发的计算机辅助教学系统。通过对ＭＩＭＤ多处理机系统体系结构、编译器和操作系统基本牲的模拟，实现了对作业／作业步和ＤＯ循环级并行性的显式及隐式开发，依据“单独并行段”和“主动抽取”策略可对并行代     

The processor working set and its use in scheduling multiprocessorsystems

The concept of a processor working set (PWS) as a single value parameter for characterizing the parallel program behavior is introduced. Through detailed experimental studies of different algorithms on a transputer-based multiprocessor machine, it is shown that the PWS is a robust measure for characterizing the workload of a multiprocessor system. It is shown that processor allocation strategies based on the PWS provide significantly better throughput-delay characteristics. The robustness of PWS is further demonstrated by showing that allocation policies that allocate processors more than the PWS are inferior in performance to those that never allocate more than the PWS-even at a moderately low load. Based on the results, a simple static allocation policy that allocates the PWS at low load and adaptively fragments at high load to one processor per job is proposed     

Simulation study of multitasking in distributed server systems with variable workload

The multitasking performance of a distributed server system is considered where the workload is variable. Time varying distributions are proposed for job arrival, job parallelism, and task service demand. A simulation model is used to address performance issues associated with task scheduling. The objective is to identify conditions that produce good overall system performance, while maintaining fairness of individual job execution times. Simulated results show that all task scheduling methods have merit. In all cases, the best policy depends on performance goals. Furthermore, although the paper studies distributed multiprocessor system performance, it also addresses the performance issues of other systems where multitasking and scheduling is used, since no restrictions are imposed on the server/job/task characteristics.     

A parallel-programming process model

A process model is presented for constructing and executing parallel programs on a shared-memory multiprocessor running under Unix. The model involves some simple extensions to the standard Unix process model, a set of language extensions, runtime library support, and additional operating-system support. The model is easy to use, and it supports several higher-level parallel programming constructs in several languages, including microtasking in C and Fortran and multitasking in Ada and C++. It frees programmers to concentrate on parallel algorithms instead of low-level implementation details, and it yields good performance     

计算机仿真中并行处理技术的研究

用多机系统进行并行仿真是解决大规模连续系统实时仿真问题的有效途径。多机并行仿真中关键要解决的问题，是如何有效地将一个仿真任务分配到多机系统上并发执行，并获得高的加速比。本文介绍了作者自行研制的并行仿真软件支撑环境ＰＡＲＳＩＭ，它可将一个传统单机上串行执行的仿真程序自动转换成在同构型多机系统上高效并发执行的并行仿真程序，并就并行性识别，多任务自动划分等问题展开了讨论，给出了相应的算法和应用实例。     

多处理机环境下UNIX文件系统的设计和实现

本文论述了在多处理机环境下UNIX 文件系统的设计和实现,以保证文件系统运行的正确性和极大限度地开发信息处理的并发性。文中提出多处理机UNIX 文件系统的模型、结构及特点。着重论述多处理机UNIX 文件系统主要数据结构低层缓冲区和内部其他数据结构的组织和管理。最后论述了多处理机环境中出现的数据一致性问题。     

Software CAD: a revolutionary approach

A research project is described in which an experimental software CAD environment called the Carleton embedded system design environment (CAEDE), oriented toward embedded systems and Ada, was developed to provide a demonstration of the concept and to serve as a research testbed. The major contribution of CAEDE is a demonstration of a visual paradigm which combines semantic depth and syntactic shallowness, relative to Ada, in a manner that makes it possible for the embedded-system designer to work in terms of abstract machines while still thinking Ada. A secondary contribution is the identification of Prolog as a promising approach for supporting tool development in an environment which supports the visual paradigm. Also described are experimental tools for temporal analysis, performance analysis, and the generation of skeleton Ada code     

A Distributed Real-Time Operating System

A distributed real-time operating system, Fados, has been developed for an embedded multiprocessor system. The operating system is based on a host-target approach and provides for communication between arbitrary processes on host and target machines. The facilities offered are, apart from process communication, access to the file system on the host by programs on the target machine and monitoring and debugging of programs on the target machine from the host. The process communication has been designed in such a way that the possibilities are the same as those offered by the Ada programming language. The operating system is implemented on an MC 68000 based multiprocessor system in combination with a Unix

1 Unix is a trademark of A. T. & T. Bell laboratories.

host.     

Task management in Ada—A critical evaluation for real-time multiprocessors

As the cost of processor hardware declines multiprocessor architectures become increasingly cost-effective and represent an important area for future research. In order to exploit the full potential of multiprocessors, however, it is necessary to understand how to design software which can make effective use of the available parallelism. This paper considers the impact of multiprocessor architecture on the design of high-level programming languages and, in particular, evaluates the language Ada in the light of the special requirements of realtime multiprocessor systems. We conclude that Ada does not, as currently designed, meet the needs for real-time embedded systems.     

Ada program partitioning language: a notion for distributing Adaprograms

Ada Program Partitioning Language (APPL) has been designed as part of Honeywell's Distributed Ada project. The goal of the project is to develop an approach for reducing the complexity of building distributed applications in Ada. In the proposed approach, an application is written as a single Ada program using the full capabilities of the Ada language. It is not necessary to factor the underlying hardware configuration into the program design. Once the program has been completed and tested in the host development environment, it is partitioned into fragments and mapped onto the distributed hardware. The partitioning and mapping are expressed in APPL and do not require changes to the Ada source. The main thrusts of the project include the design of APPL and the development of language translation tools and the run-time system to support Ada and APPL for a distributed target. The authors present an overview of APPL, the goals considered in the design, and issues that impact its implementation     

The distributed ada run-time system darts

A distributed Ada run-time system, DARTS, is presented. DARTS is used with a source code transformation method for pre-partitioning, and it also allows a late configuration. A single program can be partitioned to run on a loosely coupled multiprocessor system. The distributed units are tasks, task objects, packages, variables, procedures and functions. Task objects can by dynamically distributed. High fault tolerance is assured by unit redistribution. Design decisions, implementation details and ideas are presented.     

PRESTO: A system for object-oriented parallel programming

PRESTO is a programming system for writing object-oriented parallel programs in a multiprocessor environment. PRESTO provides the programmer with a set of pre-defined object types that simplify the construction of parallel programs. Examples of PRESTO objects are threads, which provide fine-grained control over a program's execution, and synchronization objects, which allow simultaneously executing threads to co-ordinate their activities. The goals of PRESTO are to provide a programming environment that makes it easy to express concurrent algorithms, to do so efficiently, and to do so in a manner that invites extensions and modifications. The first two goals, which are the focus of this paper, allow a programmer to use parallelism in a way that is naturally suited to the problem at hand, rather than being constrained by the limitations of a particular underlying kernel or hardware architecture. The third goal is touched upon but not emphasized in this paper. PRESTO is written in C++; it currently runs on the Sequent shared-memory multiprocessor on top of the Dynix operating system. In this paper we describe the system model, its applicability to parallel programming, experiences with the initial implementation, and some early performance measurements.