Concurrent Logic Programming Languages Research Articles

A Semantics for Concurrent Logic Programming Languages Based on Multiple-Valued Logic

In order to obtain an understanding of parallel logic thought it is necessary to establish a fully abstract model of the denotational semantics of logic programming languages. In this paper, a fixed point semantics for the committed choice, non-deterministic family of parallel programming languages, i.e. the concurrent logic programming languages is developed. The approach is from an order theoretic viewpoint. We rigorously define a semantics for a Guarded Horn Clauses-type of language because of the minimal restrictions of the language. The extension to other concurrent logic programming languages would be direct and analogous, based on their specific rules of suspension. Today’s world is replete with multitasking and parallelism in general. The content of this paper reflects a paradigm of an application of multi-valued logic which is reflective of this.

CONCURRENT ABDUCTIVE LOGIC PROGRAMMING IN PANDORA

The extension of logic programming with abduction (ALP) allows a form of hypothetical reasoning. The advantages of abduction lie in the ability to reason with incomplete information and the enhancement of the declarative representation of problems. On the other hand, concurrent logic programming is a framework which explores AND-parallelism and/or OR-parallelism in logic programs in order to efficiently execute them on multi-processor / distributed machines. The aim of our work is to study a way to model abduction within the framework of concurrent logic programming, thus taking advantage of the latter's potential for parallel and/or distributed execution. In particular, we describe Abductive Pandora, a syntactic sugar on top of the concurrent logic programming language Pandora, which provides the user with an abductive behavior for a concurrent logic program. Abductive Pandora programs are then transformed into Pandora programs which support the concurrent abductive behavior through a simple programming technique while at the same time taking advantage of the underlying Pandora machine infrastructure.

ロボット間協調を容易に実現する並列論理型プログラミング言語の設計

ロボット間協調を容易に実現する並列論理型プログラミング言語の設計

Preface: Volume 16, Issue 1

AbstractCOTIC 98 was the second workshop organized in the context of the ESPRIT Working Group COTIC. The previous one, COTIC 97, was held at RISC in October 1997. These workshops aim at stimulating research on timed extensions of (concurrent) constraint programming and more generally timed declarative languages. Additionally, they seek to investigate possible uses of concurrent logic and constraint programming languages in representing the reasoning and communication capabilities of intelligent agents.The programme of COTIC 98 included eight presentations selected by a programme committee consisting of: F. S. de Boer (co-chair, Univ. Utrecht), P. Bonatti (Univ. Torino), M. Gabbrielli (co-chair, Univ. Pisa), A. Maggiolo-Schettini (Univ. Pisa), J. Maluszynski (Univ. Linkoeping), J.-J. Meyer (Univ. Utrecht), L. Monteiro (Univ. Lisboa) and V.S. Subrahmanian (Univ. Maryland). Out of the eight presented papers four were selected for inclusion in this volume. Further information on the workshop can be found at the COTIC 98 web page.We would like to thank the authors of the submitted papers and the members of the program committee for their contribution to the meeting. We also would like to thank Michael Mislove for his help with the editing of the proceedings.November 1998, F.S. de Boer and M. Gabbrielli

Experience with the Super Monaco optimizing compiler

“Super Monaco” is a shared-memory multiprocessor implementation of a flat concurrent logic programming language. The system evolved from the earlier Monaco project, and retains, by and large, the Monaco intermediate abstract machine. Over the past two years, the compiler and runtime system were modified, incorporating a number of new features improving robustness, flexibility, maintainability, and performance. The optimizing compiler, written in KL1, takes high-level programs and produces intermediate code for the Monaco abstract machine. An “assembler-assembler” converts a host machine description into a KL1 program which translates Monaco intermediate code into target assembly code. There are currently two intermediate code translators: one for SGI MIPS-based hosts, and another for Sequent 80386-based multiprocessors. This paper discusses the compiler design and our experience building it. A cost/benefit analysis of the compiler optimizations is given, with a comparison to similar systems.

Distributed memory implementation of KLIC

This paper describes external reference management and distributed unification in a distributed implementation of a concurrent logic programming language KL1. This implementation is based on the KLIC system. KLIC has a feature calledgeneric objects that enable easy modification and extension of the system without changes in the core implementation. This distributed implementation is built upon the same core and external references are represented using generic objects. Unification operations are defined as methods of generic objects. Since creation of interprocessor reference loops cannot be avoided, we studied a new unification scheme that can cope with interprocessor reference loops. We built several experimental distributed systems that all demonstrate reasonable efficiency.

Instant replay debugging of concurrent logic programs

One problem with debugging (committed choice) concurrent logic programs is that their behaviour may be non-deterministic, in that successive executions of the same program may produce different results. We describe a scheme, based on the ‘Instant Replay’ scheme developed for more conventional parallel languages, that allows us to reproduce the execution behaviour of a concurrent logic program on subsequent executions, so that the execution may be examined for debugging purposes. The properties of concurrent logic programming languages allow us to simplify our scheme greatly. We have demonstrated our scheme with KLIC, and KL1 on the PIM multiprocessors, but it can also be applied to other committed choice concurrent logic programming languages.

The deevolution of concurrent logic programming languages

This article surveys the field of implementation of concurrent logic programming languages. I briefly review language semantics and programming paradigms, before summarizing the results of the past decade in compiler and runtime system implementation. A theme throughout the research presented is the deevolution of concurrent logic programming languages due to the limitations of what systems designers and compiler writers can efficiently implement, as well as the growing perception among programmers that reduced expressivity is sufficient.

Determinacy testing for nondeterminate logic programming languages

This paper describes an algorithm for the code generation of determinacy testing for nondeterminate flat concurrent logic programming languages. Languages such as Andorra and Pandora require that procedure invocations suspend if there is more than one candidate clause potentially satisfying the goal. The algorithm described has been developed specifically for a variant of flat Pandora based on FGHC, although the concepts are general. We have extended Kliger and Shapiro's decision-graph construction algorithm to compile “don't-know” procedures that must suspend for nondeterminate goal invocation. The determinacy test is compiled into a decision graph quite different from those of committed-choice procedures: They are more similar to decision trees optimized by code sharing. We present both empirical data of compilation results (code size and graph characteristics), and a correctness proof for our code-generation algorithm.

A compile-time granularity analysis algorithm and its performance evaluation

A major implementation problem with implicitly parallel languages, is that small grain size can lead to execution overheads and reduced performance. We present a new granularity-analysis scheme that produces estimators, at compile time, of the relative execution weight of each procedure invocation. These estimators can be cheaply evaluated at runtime to approximate the relative task granularities, enabling intelligent scheduling decisions. Our method seeks to balance tradeoffs between analysis complexity, estimator accuracy, and runtime overhead of evaluating the estimator. To this end, rather than analyze data size or dependencies, we introduceiteration parameters to handle recursive procedures. This simplification facilitates solving the recurrence equations that describe the granularity estimators, and reduces the runtime overhead of evaluating these estimators. The algorithm is described in the context of concurrent logic programming languages, although the concepts are applicable to functional languages in general. We show, for a benchmark suite, that the method accurately estimates cost. Multiprocessor simulation results quantify the advantage of dynamically scheduling tasks with the granularity information.

Concurrency and backtracking in Vienna Parallel Logic

Vienna Parallel Logic ( VP L) is a persistent language and programming system that supports the concurrent execution of communicating processes and the computation of several alternative solutions by means of programmed backtracking. It unifies the worlds of sequential logic programming languages (Prolog) and concurrent logic programming languages (i.e. Parlog). Aspects of both language classes can be combined to any desired degree within one computation. Such a language is well suited for multidatabase applications. Further characteristics include an advanced transaction model, the support of an architecture-neutral programming style, and the treatment of failing processes. We describe the language and briefly outline implementation issues of our prototype system.

A survey of PARLOG and Concurrent Prolog: The integration of logic and parallelism

A new class of programming languages is born from the integration of logic programming and concurrent programming: concurrent logic programming languages. The main goal of concurrent logic languages is the exploitation of parallelism which is inside logic programs. This paper surveys and compares the two most significant concurrent logic programming languages, PARLOG and Concurrent Prolog with respect to the original mechanisms defined in each one to embody parallelism in a logic programming framework. For both languages, some implementation techniques in parallel environments are discussed.

PRETS: A parallel reverse‐engineering toolset for FORTRAN

AbstractThe widespread acceptance of parallel and distributed processing will result in migration of millions of lines of sequential code to parallel environments over the next decade. Unlike movement across sequential environments, significant structure and code changes must be made in order to benefit from the increased processing power of parallel computing. Nowhere is this problem more obvious than in the scientific computing community. The sequential nature of FORTRAN has limited its ability to utilize the performance achievable from parallel and/or distributed systems.Strand, a concurrent logic programming language based on Edinburgh Prolog, is intended to exploit concurrency in both parallel and distributed environments, while offering portability across a variety of platforms and topologies. Strand minimizes reprogramming of existing software by providing a Foreign Language Interface (FLI) which allows inclusion of C and/or FORTRAN code in Strand programs. This paper describes a set of tools called the pRETS (parallel Reverse engineering ToolSet) which supports the semi‐automated conversion of FORTRAN programs into Strand Foreign Language Kernels.

Generalized algorithmic debugging and testing

This paper presents a method for semi-automatic bug localization, generalized algorithmic debugging, which has been integrated with the category partition method for functional testing. In this way the efficiency of the algorithmic debugging method for bug localization can be improved by using test specifications and test results. The long-range goal of this work is a semi-automatic debugging and testing system which can be used during large-scale program development of nontrivial programs. The method is generally applicable to procedural langua ges and is not dependent on any ad hoc assumptions regarding the subject program. The original form of algorithmic debugging, introduced by Shapiro, was however limited to small Prolog programs without side-effects, but has later been generalized to concurrent logic programming languages. Another drawback of the original method is the large number of interactions with the user during bug localization. To our knowledge, this is the first method which uses category partition testing to improve the bug localization properties of algorithmic debugging. The method can avoid irrelevant questions to the programmer by categorizing input parameters and then match these against test cases in the test database. Additionally, we use program slicing, a data flow analysis technique, to dynamically compute which parts of the program are relevant for the search, thus further improving bug localization. We believe that this is the first generalization of algorithmic debugging for programs with side-effects written in imperative languages such as Pascal. These improvements together makes it more feasible to debug larger programs. However, additional improvements are needed to make it handle pointer-related side-effects and concurrent Pascal programs. A prototype generalized algorithmic debugger for a Pascal subset without pointer side-effects and a test case generator for application programs in Pascal, C, dBase, and LOTUS have been implemented.

Structural operational semantics for AKL

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 first 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 infinite computations.

Debugging Tools for Concurrent Logic Programming

A problem which confronts the developers of concurrent logic programming (CLP) systems concerns the design of the programming environment, particularly the provision of debugging tools. Debugging tools are useful for many activities besides identifying bugs: they can help in program testing and demonstration, in software experiments, and in teaching the language semantics. For CLP languages the questions of what debugging tools should be provided, and of how they should be used, are still open. Although the languages are closely related to other logic programming and concurrent programming languages, they are sufficiently different that new debugging techniques are required. This paper describes a primarily channel-oriented debugging methodology and a set of debugging tools that we have developed in the light of our experience in using and teaching the CLP language Parlog. With these tools a programmer can test a program by observing communication on channels, opening up a process to examine the activity on internal channels and, if necessary, to check in detail the execution steps of a process. Almost all of the ideas, which are equally applicable to other CLP languages, have been implemented in two commercial Parlog systems. As well as fulfilling the needs of existing users of CLP languages, we believe that the tools emphasise the attractions of CLP as a concurrent programming paradigm, since they are made possible by the unique attributes of CLP. Concurrent programming and logic programming have both been the focus of considerable research during the past decade. The reasons are clear: concurrent programming is necessary to support a growing number of advanced applications and to exploit the emerging multiprocessor hardware architectures; logic programming attempts to root the activity of software development in formal logic, and hence to make software development more reliable, productive, and better matched to the increasing number of artificial intelligence-oriented projects. Particularly interesting and, we think, fruitful has been research into the intersection between these subjects. From this research has emerged a new family of languages: the concurrent logic programming (CLP) languages, exemplified by Parlog, Concurrent Prolog, GHC, and Strand. The CLP languages attempt to combine the benefits of both parent disciplines into a coherent whole. Some of them are now available commercially and it seems likely that they will become more widely used in the near future. One of the problems which confronts the developers of CLP systems concerns the design of the programming environment, including (the subject of this paper) the provision of debugging tools. Although debugging tools represent only a part of the programming environment, there are several reasons why they are of special interest: 1. Existing CLP systems have poor debugging tools. Yet experience of other programming systems suggests that programmers are more likely to be receptive to, and productive in, a new system if

A lingua franca for concurrent logic programming

Two of the more important concurrent logic programming languages with nonflat guards are GHC and Parlog. They balance the requirements of having clean semantics and providing good control facilities rather differently, and their respective merits are compared and contrasted. Since concurrent logic programming would benefit from both, but neither language is able to express all the programs expressible in the other language, a lingua franca of these languages is defined and justified. A method is given for translating GHC and Parlog to and from it. The method preserves the arities and execution conditions of each clause. It enables a lingua franca implementation to support both languages transparently, and to provide a simple concurrent logic programming language suitable for programming in its own right.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Heuristic search in PARLOG using replicated worker style parallelism

Most concurrent logic programming languages hide the distribution of processes among physical processors from the programmer. For parallel applications based on heuristic search, however, it is important for the programmer to accurately control this distribution. With such applications, an inferior distribution strategy easily leads to enormous search overheads, thus decreasing speedup on parallel hardware. To solve this problem, various language extensions for concurrent logic languages have been proposed, such as mapping notations and priorities. We present an alternative approach that does not require any new language features. Our solution is to use the replicated workers paradigm in a concurrent logic language (PARLOG). This paradigm has thus far mainly been used in parallel procedural languages, such as Linda and Orca. We show that it is just as useful for logic languages. We have implemented two parallel applications, the Traveling Salesman Problem and alpha-beta search, using this approach. Also, we have done some performance measurements of these programs on a multiprocessor. These experiments show that significant speedups can be obtained in this way.

Linear objects: Logical processes with built-in inheritance

We present a new framework for amalgamating two successful programming paradigms: logic programming and object-oriented programming. From the former, we keep the delarative reading of programs. From the latter, we select two crucial notions: (i) the ability for objects to dynamically change their internal state during the computation; (ii) the structured representation of knowledge, generally obtained via inheritance graphs among classes of objects. We start with the approach, introduced in concurrent logic programming languages, which identifies objects with proof processes and object states with arguments occurring in the goal of a given process. This provides a clean, side-effect free account of the dynamic behavior of objects in terms of the search tree—the only dynamic entity in logic programming languages. We integrate this view of objects with an extension of logic programming, which we call Linear Objects, based on the possibility of having multiple literals in the head of a program clause. This contains within itself the basis for a flexible form of inheritance, and maintains the constructive property of Prolog of returning definite answer substitutions as output of the proof of non-ground goals. The theoretical background for Linear Objects is Linear Logic, a logic recently introduced to provide a theoretical basis for the study of concurrency. We also show that Linear Objects can be considered as constructive restriction of full Classical Logic. We illustrate the expressive power of Linear Objects compared to Prolog by several examples from the object-oriented domain, but we also show that it can be used to provide elegant solutions for problems arising in the standard style of logic programming.

Coupling committed and trial binding resolution engines

Sequential and parallel Prolog's ability to implement don't know non-determinism in resolution efficiently makes them apt for supporting a knowledge base querying capability. On the other hand, their search based execution model their trial use of bindings makes them unsuitable for systems programming. Conversely, the use of concurrent logic programming or CLP languages of committed bindings, general and-parallelism, and synchronisation constraints enables them to support systems programming applications quite well. However, their use of committed choice resolution makes them unable to support a knowledge base querying capability. These limitations of the main logic programming schemes make it awkward to program concurrent knowledge based systems in logic. That would require the means for sustaining both knowledge base querying and systems management capabilities within a single logic programming scheme. However, the querying parts could be realised with trial binding computations on a multi-threaded Prolog engine and the systems programming parts with committed binding computations on a CLP engine by loosely coupling these engines together. This paper proposes suitable interfaces and methods for realising these forms of coupling. A multi-user Prolog system, a coupled meta-interpreter and multiple solutions predicates illustrate coupled resolution engine programming.