The distributed programming language SR—Mechanisms,design and implementation

SR is a new language for programming software containing many processes that execute in parallel. The language allows an entire software system that controls a potentially large collection of processors to be programmed as an integrated set of software modules. The key language mechanisms are resources, operations and input statements. The language supports separate compilation, type abstraction, and dynamic communication links; it also contains novel treatments of arrays and procedures. This paper gives an overview of the language mechanisms, discusses some of the major design decisions and describes one implementation.     

A joyce implementation

Joyce is a programming language for distributed systems based on CSP and Pascal. A Joyce program defines concurrent agents which communicate through unbuffered channels. This paper describes a surprisingly simple single-processor implementation of Joyce which runs on an IBM-PC.     

DTL: A language for the design and implementation of concurrent programs as structured networks

DTL is an experimental programming language which has developed from an investigation of data structured design methods and data driven programming techniques. A DTL program is derived from a specification of the structure of its valid input and output languages. The program function is defined as a translation between these languages. A complex translation can be hierarchically structured into a network of simpler translations by stepwise refinement.     

A multiprocessor implementation of joyce

Joyce is a programming language for parallel computers based on CSP and Pascal. A Joyce program defines concurrent agents which communicate through unbuffered channels. This paper describes a multiprocessor implementation of Joyce.     

A new implementation technique for applicative languages

It is shown how by using results from combinatory logic an applicative language, such as LISP, can be translated into a form from which all bound variables have been removed. A machine is described which can efficiently execute the resulting code. This implementation is compared with a conventional interpreter and found to have a number of advantages. Of these the most important is that programs which exploit higher order functions to achieve great compactness of expression are executed much more efficiently.     

The development of the HiPE system: design and experience report

The concurrent functional programming language Erlang has been designed to ease the development of large-scale distributed soft real-time control applications. So far, it has been used quite successfully in industry, both within Ericsson Telecom, where it was designed and developed, and by other companies. This declarative language success-story has taken place despite the fact that Erlang implementations are slow compared with implementations of other functional languages. Wanting to improve the performance aspects of publicly available Erlang implementations, which are based on emulators, we embarked on a project called HiPE (High-Performance Erlang) whose aim has been to develop an efficient just-in-time native code compiler for Erlang (called the HiPE system). Since its start in 1996, the system has gone through various (re-)design phases, partly due to implementation choices that did not turn out to be as promising as they appeared on paper, but mainly due to changes in Ericssons Erlang system upon which the HiPE system is built. In this article, we describe how the HiPE system was developed, what it currently looks like, and its current performance. We critically examine design decisions that we took, and the main lessons learnt from implementing them. Finally, we also report on our experiences from trying to keep up with the concurrent development of Ericssons base Erlang system. As such, this article both documents the HiPE system and can serve as possible guidance to anyone wishing to attempt a similar feat.     

Another approach to the implementation of synchronization primitives

A new method for the implementation of synchronization primitives is described. The method combines the flexibility of user defined primitives with the possibility of compiler checks. The method allows the tailoring of the size and of the performance of the synchronization primitives to the needs of the user.     

切削过程的虚拟现实系统

介绍虚拟现实的基本特性和系统构成,利用WTK、VC＋＋、OpenGL等软件设计了切削过程的虚拟现实系统,实现了车床的虚拟加工过程的仿真。     

基于虚拟样机的复杂产品协同设计与仿真关键技术研究*

主要研究并行工程环境下复杂产品虚拟样机协同设计与仿真的体系结构及其关键技术。提出虚拟样机协同设计与仿真系统的体系结构与整体解决方案,研究面向虚拟样机的数字化多领域集成建模理论与方法,建立面向虚拟样机开发全生命周期的集成过程管理与冲突协调模型,提出面向复杂产品虚拟样机开发的多学科协同设计、协同仿真和智能决策支持的理论与方法,建立复杂产品虚拟样机协同支持环境,有效提高企业创新能力和核心竞争力。     

The semantics of the combination of atomized statements and parallel choice

In this paper we define a uniform language that is an extension of the language underlying the process algebraPA. One of the main extensions of this language overPA is given by so-called atomizing brackets. If we place these brackets around a statement then we treat this statement as an atomic action. Put differently, these brackets remove all interleaving points. We present a transition system for the language and derive its operational semantics. We show that there are several options for defining a transition system such that the resulting operational semantics is a conservative extension of the semantics forPA. We define a semantic domain and a denotational model for the language. Next we define a closure operator on the semantic domain and show how to use this closure operator to derive a fully abstract denotational semantics. Then the algebraic theory of the language is considered. We define a collection of axioms and a term rewrite system based on these axioms. Using this term rewrite system we are able to identify normal forms for the language. It is shown that these axioms capture the denotational equality. It follows that if two terms are provably equal then they have the same operational semantics. Finally, we show how to extend the axiomatization in order to axiomatize its operational equivalence.     

Concurrent C++: Concurrent programming with class(es)

C++ and Concurrent C are both upward-compatible supersets of C that provide data abstraction and parallel programming facilities, respectively. Although data abstraction facilities are important for writing concurrent programs, we did not provide data abstraction facilities in Concurrent C because we did not want to duplicate the C++ research effort. Instead, we decided that we would eventually integrate C++ and Concurrent C facilities to produce a language with both data abstraction and parallel programming facilities, namely, Concurrent C++. Data abstraction and parallel programming facilities are orthogonal. Despite this, the merger of Concurrent C and C++ raised several integration issues. In this paper, we will give introductions to C++ and Concurrent C, give two examples illustrating the advantages of using data abstraction facilities in concurrent programs, and discuss issues in integrating C++ and Concurrent C to produce Concurrent C++.     

The design and implementation of Object Grammars

An Object Grammar is a variation on traditional BNF grammars, where the notation is extended to support declarative bidirectional mappings between text and object graphs. The two directions for interpreting Object Grammars are parsing and formatting. Parsing transforms text into an object graph by recognizing syntactic features and creating the corresponding object structure. In the reverse direction, formatting recognizes object graph features and generates an appropriate textual presentation. The key to Object Grammars is the expressive power of the mapping, which decouples the syntactic structure from the graph structure. To handle graphs, Object Grammars support declarative annotations for resolving textual names that refer to arbitrary objects in the graph structure. Predicates on the semantic structure provide additional control over the mapping. Furthermore, Object Grammars are compositional so that languages may be defined in a modular fashion. We have implemented our approach to Object Grammars as one of the foundations of the Ensō system and illustrate the utility of our approach by showing how it enables definition and composition of domain-specific languages (DSLs).     

An SR approach to multiway rendezvous

This paper presents a new approach to programming multiway rendezvous problems in the SR language. The approach uses SR's concurrent invocation statement and rendezvous mechanism to coordinate the interacting processes. This approach is compared with one that suggested an extension to SR's rendezvous mechanism. The two approaches result in differing program structure. The new approach is shown to lead to simpler and cleaner interfaces between the main process and the worker processes, and uses only existing language mechanisms. The results are of importance to both programmers and designers of concurrent program languages.     

基于虚拟样机的复杂产品协同设计与仿真关键技术研究

主要研究并行工程环境下复杂产品虚拟样机协同设计与仿真的体系结构及其关键技术。提出虚拟样机协同设计与仿真系统的体系结构与整体解决方案,研究面向虚拟样机的数字化多领域集成建模理论与方法,建立面向虚拟样机开发全生命周期的集成过程管理与冲突协调模型,提出面向复杂产品虚拟样机开发的多学科协同设计、协同仿真和智能决策支持的理论与方法,建立复杂产品虚拟样机协同支持环境,有效提高企业创新能力和核心竞争力。     

The implementation of generators and goal-directed evaluation in icon

Two features of the Icon programming language strongly influence its implementation: generators and goal-directed evaluation. A generator is an expression that is capable of producing a sequence of results. In goal-directed evaluation, the results of generators are produced automatically in an attempt to complete computations successfully. This paper describes the generated code and run-time support for generators, goal-directed evaluation, and related control structures.     

Meta-interpreters and partial evaluation in Parlog

Since logic programs are executable specifications, the main concern of logic programming, producing efficient programs, is tangential to the mainstream of formal methods. A fashionable automatic transformation technique for producing efficient programs, partial evaluation, applied to the concurrent logic programming language Parlog is discussed.     

An implementation of syntax directed functional programming on nested-stack machines

This paper contributes to the field of functional programming languages. We investigate the call-by-name and call-by-need implementation of a restricted type of functional programming, calledsyntax directed functional programming; the target of this implementation is an abstract machine that is based on nested stacks. In fact, the technical kernel of this paper is a refinement of an automata theoretical result that, roughly speaking, investigates the well-known relationship recursion = iteration + stack in the framework of tree transducers. More precisely, in the underlying result the class of functions computed by total deterministic macro tree-to-string transducers with the call-by-name computation strategy is characterized by total deterministic checking-tree nested-stack transducers. Note that total deterministic macro tree-to-string transducers are term rewriting systems by means of which the reduction semantics of syntax directed functional programming languages can be described.The work of this author has been supported by the Deutsche Forschungsgemeinschaft (DFG).     

The design and implementation of dynamic hashing for sets and tables in icon

Two key features in the Icon programming language are tables and sets. An Icon program may use one large set or table, or thousands of small ones. To improve space and time performance for these diverse uses, their hashed data structures were reimplemented to dynamically resize during execution, reducing the minimum space requirement and achieving constant-time access to any element for virtually any size set or table. The implementation is adapted from Per-Åke Larson's dynamic hashing technique by using well-known base-2 arithmetic techniques to decrease the space required for small tables without degrading the performance of large tables. Also presented are techniques to prevent dynamic hashing from interfering with other Icon language features. Performance measurements are included to support the results.