This paper presents a new and very rich class of (con-current) programming languages, based on the notion of comput.ing with parhal information, and the con-commitant notions of consistency and entailment. ’ In this framework, computation emerges from the inter-action of concurrently executing agents that communi-cate by placing, checking and instantiating constraints on shared variables. Such a view of computation is in-teresting in the context of programming languages be-cause of the ability to represent and manipulate partial information about the domain of discourse, in the con-text of concurrency because of the use of constraints for communication and control, and in the context of AI because of the availability of simple yet powerful mechanisms for controlling inference, and the promise that very rich representational/programming languages, sharing the same set of abstract properties, may be pos-sible. To reflect this view of computation, [Sar89] develops the cc family of languages. We present here one mem-ber of the family, CC(.L,+) (pronounced “cc with Ask and Choose”) which provides the basic operations of blocking Ask and atomic Tell and an algebra of be-haviors closed under prefixing, indeterministic choice, interleaving, and hiding, and provides a mutual recur-sion operator. cc(.L,-t) is (intentionally!) very similar to Milner’s CCS, but for the radically different under-lying concept of communication, which, in fact, pro-’ The class is founded on the notion of “constraint logic pro-gramming ” [JL87,Mah87], fundamentally generalizes concurrent logic programming, and is the subject of the first author’s disser-tation [Sar89], on which this paper is substantially based.

The logic programming language framework Kernel Andorra Prolog is defined by a formal computation model. In Kernel Andorra Prolog, general combinations of concurrent reactive languages and nondeterministic transformational languages may be specified. The framework is based on constraints. The languages Prolog, GHC, Parlog, and Atomic Herbrand, are all executable in the Kernel Andorra Prolog computation model. There are instances of the framework in which all of these languages are embeddable.

Concurrent constraint programming [Sar89,SR90,SRP91] is a simple and powerful model of computation based on the notions of store-as-constraint and process as information transducer. In this paper we describe a (domain-theoretic) semantic foundation for cc languages with ask, tell, parallel composition, hiding, recursion and angelic non-determinism ("parallel backtracking"). This class of languages includes the cc/Herbrand language [Sar89] and a simpler reworking [HS91] of CHIP. Generalizing previous work on determinate constraint programming [JPP89,SRP91], we describe the semantics for such a language based on modelling a process as a set of constraints, with parallel composition (conjunction) given by set intersection and or-parallel search (disjunction) given by set union. This is achieved by viewing processes as continuous linear closure operators on the Smyth powerdomain of the underlying constraint system. The model is shown to be fully abstract for the observation of finite appro...

Parallelizing logic programming has attracted much interest in the research community, because of the intrinsic OR- and AND-parallelisms of logic programs. One research stream aims at transparent exploitation of parallelism in existing logic programming languages such as Prolog, whale the family of concurrent logic languages develops language constructs allowing programmers to express the concurrency—that is, the communication and synchronization between parallel processes—within their algorithms. This article concentrates mainly on transparent exploitation of parallelism and surveys the most mature solutions to the problems to be solved in order to obtain efficient implementations. These solutions have been implemented, and the most efficient parallel logic programming systems reach effective speedups over state-of-the-art sequential Prolog implementations. The article also addresses current and prospective research issues in extending the applicability and the efficiency of existing systems, such as models merging the transparent parallehsm and the concurrent logic languages approaches, combination of constraint logic programming with parallelism, and use of highly parallel architectures.

The endeavor to extend logic programming to a language suitable for concurrent systems has stimulated in the last decade an intensive research, resulting in a large variety of proposals. A common feature of the various approaches is the attempt to define mechanisms for concurrency within the logical paradigm, the driving ideal being the balance between expressiveness and declarative reading. In this survey we present the motivations, the principal lines along which the field has developed, the various paradigms which have been proposed, and the main approaches to the semantic foundations. 1 Introduction Among the various reasons which have contributed to the popularity of logic programming, one is the opinion that it is an inherently parallel language, therefore suitable for parallel and distributed architectures. The pure language can already be regarded as a model for parallel computation: in the so-called process interpretation (van Emden and de Lucena 1982; Shapiro 1983), the goal...

This paper presents a technique to map automatically a complete digital signal processing (DSP) application onto a parallel machine with distributed memory. Unlike other applications where coarse or medium grain scheduling techniques can be used, DSP applications integrate several thousand of tasks and hence necessitate fine grain considerations. Moreover finding an effective mapping imperatively require to take into account both architectural resources constraints and real time constraints. The main contribution of this paper is to show how it is possible to handle and to solve data partitioning, and fine-grain scheduling under the above operational constraints using Concurrent Constraints Logic Programming languages (CCLP). Our concurrent resolution technique undertaking linear and non linear constraints takes advantage of the special features of signal processing applications and provides a solution equivalent to a manual solution for the representative Panoramic Analysis (PA) appli...

The Andorra Kernel Language #AKL# is a concurrent constraint programming language. It can be seen as a general combination of logic programming languages such as Prolog, GHC, and Parlog, the #rst of which provides don't know nondeterminism, and the last two of which are concurrent logic programming languages. The constraint system is an independent parameter of the language description. In this paper, we revisit the description of Janson and Haridi #10#, adding the formal machinery which is necessary in order to completely formalize the control of the computation model. To this we add a formal description of the transformational semantics of AKL. The semantics is a set of or-trees which also captures in#nite computations. 1

In this paper we propose a novel computational model for constraint logic programming (CLP) languages. The model provides an efficient mechanism for executing CLP programs by exploiting constraint satisfaction as a means for both solving constraints and controlling the whole computation. In the model, we separate constraint solving from the deduction procedure. Deductions over constraints are extracted from the source program and represented as a context-free grammar that encodes the way in which deduction will generate constraints to be solved. Therefore, deduction is performed abstractly at compile time. Executing the grammar generates all the constraints that need to be solved at run time. A very flexible control mechanism is therefore provided by the model in terms of the information fed back from the constraint solving procedure. It is shown that the model provides a general scheme for investigating an efficient computational model for implementing constraint logic programming sys...

The rate at which computers are becoming faster at sequential execution has dropped significantly. Instead parallel processing power is increasing, and multicore computers are becoming more common. Automatically parallelising programs is becoming much more desirable. Parallelising programs written in imperative programming languages is difficult and often leads to unreliable software. Parallelising programs in declarative languages is easy, to the extent that compilers are able to do this automatically. However this often leads to cases where the overheads of parallel execution outweigh the speedup that might have been available by parallelising the program. This thesis describes a new implicit parallelism implementation that calculates the speedup due to parallelism in dependent conjunctions for Mercury — a purely declarative logic programming language. This is done by analysing profiling data and a representation of the program in order