Computer Languages最新文献

Fail-safety is a system attribute which ensures that a program either completes its execution satisfying its post-conditions in the normal manner or signals its failure to do so to its operating environment. Such an attribute is desirable of any system as it ensures the correctness of results which are produced. A very few modern sequential programming languages offer program fail-safety through the judicious use of a well designed exception handling mechanism. In this paper the exception handling techniques used in those sequential systems are developed to provide the guidelines for fail-safe concurrent system design.

Inter-process communication is achieved in many concurrent programming languages through message entries. Many of these languages contain inter-entry selection constructs allowing a process to selectively choose one of a group of message entries to service. Generally, this selection process is handled non-deterministically. To enable a degree of control over this selection, limited inter-entry selection control mechanisms are available in several of these languages. This paper reviews the need for more expressive inter-entry selection control mechanisms and details the design and implementation of two such control mechanisms—static and dynamic preferences. These implementations of static and dynamic preferences, SRps and SRpd respectively, are extensions of the SR concurrent programming language. In both implementations, the use of preferences is optional, and thus, the overhead associated with their use is incurred only when their use is necessary. Finally, this paper describes the performance of these implementations on several classical synchronization problems. For tests run in a shared memory environment the results show that there is substantial cost associated with the preference implementations. However, the results of the distributed environment tests illustrate that the incremental cost of adding preferences is small and often not discernable when the overhead costs associated with communications across a network are considered.

Incremental parsing is widely used in language-based editors and incremental compiling and interpreting environments. Re-parsing of modified input strings is the most frequently performed operation in these environments. Its efficiency can greatly affect the success of these environments. This paper describes the introduction of a threaded link in parse trees and an additional distance entry in LL parse tables to support minimal LL(1) re-parsing. These enhancements are then used to produce an efficient incremental LL parser.

An effective resolution multiprocessor can be built from distributed processing, logic programming, and interface elements. Widely used, portable, components can be modularly composed into a portable parallel system that displays good resistance to premature obsolescence by software evolution. A virtual multiprocessor offering common message passing and configuration services integrates a distributed mesh of sequential resolution engines. Users configure and control the resolution engines and virtual multiprocessor through a GUI using an embedded command language to drive its facilities. Prolog programs either explicitly control parallel execution through message passing or would have to rely on program transformation techniques to extract parallelism implicitly.

The PPL framework is proposed as a simple extension to logic programming aiming at handling resources. It is argued that the separation between logical treatments and resource handling is desirable and, to that end, resources are proposed to be manipulated by means of pre- and post-conditions associated with usual Horn clauses. The expressiveness of the resulting framework is evidenced through the coding of several applications. Operational and declarative semantics are also presented as extensions of the classical ones accounting for the evaluation of pre- and post-conditions, in particular the non-monotonic behavior of the world of resources they induce in general.

We present the design and implementation of the and-parallel component of ACE. ACE is a computational model for the full Prolog language that simultaneously exploits both or-parallelism and independent and-parallelism. A high-performance implementation of the ACE model has been realized and its performance reported in this paper. We discuss how some of the standard problems which appear when implementing and-parallel systems are solved in ACE. We then propose a number of optimizations aimed at reducing the overheads and the increased memory consumption which occur in such systems when using previously proposed solutions. Finally, we present results from an implementation of ACE which includes the optimizations proposed. The results show that ACE exploits and-parallelism with high efficiency and high speedups. Furthermore, they also show that the proposed optimizations, which are applicable to many other and-parallel systems, significantly decrease memory consumption and increase speedups and absolute performance both in forward execution and during backtracking.

We define a new language that naturally satisfies the requirements of concurrency support, modularity, and declarativity. Although some classes of existing languages already cover a subset of these requirements, there is no example of a programming language entirely fulfilling them. We propose to merge three programming paradigms, Multiple Tuple Spaces, Object Orientation, and Logic Programming, as a solution to our requirement list. Each paradigm is well characterized and satisfies one of the given requirements. Moreover, we claim that the merging will reveal new directions in the inception and development of future programming languages.

Shared Prolog (SP) is a parallel symbolic language in which coordination issues are clearly separated from computation issues. SP combines concurrency and communication based on a shared dataspace coordination model with sequential symbolic computation based on logic programming. We demonstrate how a rule-based coordination language can be used for expressing a number of different parallel computing schemata, reusing and reorganizing existing sequential programs.

In this article we advocate a declarative approach to data-parallelism to provide both parallelism expressiveness and efficient execution of data intensive applications. 8_{$\text{1}\text{2}$}, an experimental language combining features of collection and stream oriented languages in a declarative framework, is presented. A new structure, the web, allows the programmer to write programmes as mathematical expressions and to implicitly express data and control parallelism. The first part of this paper proposes a classification of the various expressions of parallelism in programming languages. We show that hybrid execution models combining both data and control parallelism are possible and necessary to get an effective speedup. We sketch the advantage of the declarative style with respect to parallelism expression (application side) and exploitation (compiler side). In the second part we describe the 8_{$\text{1}\text{2}$} language and the concepts of collection, stream and web. A web is a multi-dimensional object that represents the successive values of a structured set of variables. Some 8_{$\text{1}\text{2}$} programmes are given to show the relevance of the web data structure for simulation applications (a resolution of O.D.P.E. and a simulation in artificial life). Examples of 8_{$\text{1}\text{2}$} programmes, involving the dynamic creation and destruction of webs, are also given. Such programmes are necessary for simulations of growing systems. In the third part, the implementation of a compiler restricted to the static part of the language is described. We focus on the process of web equations compilation towards a virtual SIMD machine. We also present the clock calculus, the scheduling inference and the distribution of the computations among the processing elements of a parallel computer.

Much work has been done in the areas of and-parallelism and data-parallelism in Logic Programs. Such work has proceeded to a certain extent in an independent fashion. Both types of parallelism offer advantages and disadvantages. Traditional (and-) parallel models offer generality, being able to exploit parallelism in a large class of programs (including that exploited by data-parallelism techniques). Data-parallelism techniques on the other hand offer increased performance for a restricted class of programs. The thesis of this paper is that these two forms of parallelism are not fundamentally different and that relating them opens the possibility of obtaining the advantages of both within the same system. Some relevant issues are discussed and solutions proposed. The discussion is illustrated through visualizations of actual parallel executions implementing the ideas proposed.