Full Prolog Research Articles

The BinProlog experience: Architecture and implementation choices for continuation passing Prolog and first-class logic engines

AbstractWe describe theBinPrologsystem's compilation technology, runtime system and its extensions supporting first-class Logic Engines while providing a short history of its development, details of some of its newer re-implementations as well as an overview of the most important architectural choices involved in their design. With focus on its differences with conventional Warren Abstract Machine (WAM) implementations, we explain key details ofBinProlog's compilation technique, which replaces the WAM with a simplifiedcontinuation passingruntime system (the “BinWAM”), based on a mapping of full Prolog tobinary logic programs. This is followed by a description of aterm compressiontechnique using a “tag-on-data” representation. Later derivatives, the Java-basedJinni Prologcompiler and the recently developedLean Prologsystem refine theBinPrologarchitecture withfirst-class Logic Engines, made generic through the use of anInteractorinterface. An overview of their applications with focus on the ability to express at source level a wide variety of Prolog built-ins and extensions covers these newer developments.

Justifying control for logic programs

A pure prolog program (with goal) consists of a definite clause part P and an expression G where P essentially assigns recursive definitions to predicate names and G is evaluated with respect to that assignment. This can be described using a term calculus for defining predicators p:πn and goal expressions g:o. Predicate names can be bound using recursion operators, and programs correspond to expressions without free predicate names. Evaluation of a goal expression g(ξ) with free program variables ξ enumerates a stream of answer substitutions {τ/ξ}.The denotational semantics of this language is employed to show limits of the expressiveness: While pure prolog is computationally complete in the sense that for every partial recursive function there is a closed predicator p so that [p](n,y) = [{f(n)/y}] (here n and f(n) stand for representations of numbers and [α] is a singleton stream), the set of definable functionals λP [[πn]. [t(p)]ϕ[p<-P] is extremely small. It is shown that even simple functionals as λP.λt.[P(t)(1)] (if defined otherwise ⊥), λP.λt.[P(t)(2)],… (i.e. ‘pick the first, second,… answer") are not definable. While ‘pick the first’ is usually obtained by adding the control construct once or cut or if-then-else to pure prolog, this does not in general account for ‘pick the n-th’.In full prolog, where imperative features are available, the situation changes. The classical prolog control, however, like cut etc. prove valuable as well as insufficient.

Multi-engine Horn Clause Prolog

We extend Horn Clause Prolog with two new primitives, new_engine (+Goal, +Answer, -Engine) and new_answer(+Engine, -Answer) for creating and exploring answer spaces of multiple interpreters (engines). We show that despite its ontological parsimony, the resulting language is comparable in practical expressiveness with conventional full Prolog, by allowing compact definitions for negation, if-then-else, all solution predicates, I/O and reflective meta-interpreters. While not really needed anymore as a workaround for the lack of expressiveness of pure Prolog, a form of dynamic database operations can be emulated as well, using the state of multiple engines. With multiple engines laying the foundation for multi-threaded execution models of logic programming languages, the surprising result that a minimal extension of Horn Clauses (with LD resolution) in fact bridges the gap to full Prolog, is significant as a basis for lightweight implementations of embedabble logic programming components. Our constructs have been used in the design of small footprint mobile code interpreters for a commercial multi-threaded agent programming language - Jinni - available from http://www.binnetcorp.com/Jinni”.

Overview of DASWAM: Exploitation of dependent and-parallelism

The Dynamic Dependent And-parallel Scheme (DDAS) is a parallel execution scheme for Prolog that is designed to exploit independent and dependent and-parallelism in full Prolog programs. In this paper, an overview of some techniques for implementing DDAS is presented. The main purpose of these techniques is to provide reasonably efficient methods for implementing the idea of the dependent status and the dynamic detection of the leftmost instance of a variable, along with the techniques needed for suspending and waking up of goals. DASWAM, an implementation of DDAS using the techniques presented in this paper, is based on modifying the Warren Abstract Machine (WAM) for parallel execution, and is designed to execute programs efficiently. A prototype DASWAM has been implemented, and results on running significant application programs presented in this paper suggest that it is possible to implement DASWAM efficiently, and that significant parallelism can be extracted.

Improving the efficiency of nondeterministic independent and-parallel systems

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.

A mathematical definition of full Prolog

The paper provides a mathematical yet simple model for the full programming language Prolog, as apparently intended by the ISO draft standard proposal. The model includes all control constructs, database operations, solution collecting predicates and error handling facilities, typically ignored by previous theoretical treatments of the language. We add to this the ubiquitous boxmodel debugger. The model directly reflects the basic intuitions underlying the language and can be used as a primary mathematical definition of Prolog. The core of the model has been applied for mathematical analysis of implementations, for clarification of disputable language features and for specifying extensions of the language in various directions. The model may provide guidance for extending the established theory of logic programming to the extralogical features of Prolog.

Optimal implementation of and-or parallel Prolog

Most models that have been proposed, or implemented, so far for exploiting both or-parallelism and independent and-parallelism have only considered pure logic programs (pure Prolog). We present an abstract model, called the Composition-Tree, for representing and-or parallelism in full Prolog. The Composition-Tree recomputes independent goals to ensure that Prolog semantics is preserved. We combine the idea of Composition-Tree with ideas developed earlier, to develop an abstract execution model that supports full Prolog semantics while at the same time avoiding redundant inferences when computing solutions to (purely) independent and-parallel goals. This is accomplished by sharing solutions of independent goals when they are pure (i.e. have no side-effects or cuts in them). The Binding Array scheme is extended for and-or parallel execution based on this abstract execution model. This extension enables the Binding Array scheme to support or-parallelism in the presence of independent and-parallelism, both when solutions to independent goals are recomputed as well as when they are shared. We show how extra-logical predicates, such as cuts and side-effects, are supported in this model.

Performance of Muse on switch-based multiprocessor machines

The Muse (multiple sequential Prolog engines) approach has been used to make a simple and efficient OR-parallel implementation of the full Prolog language. The performance results of the Muse system on bus-based multiprocessor machines have been presented in previous chapters, papers. This chapter paper discusses the implementation and performance results of the Muse system on switch-based multiprocessors (the BBN Butterfly GP1000 and TC2000). The results of Muse execution show that high real speedups can be achieved for Prolog programs that exhibit coarse-grained parallelism. The scheduling overhead is equivalent to around 8 -- 26 Prolog procedure calls per task on the TC2000. The chapter paper also compares the Muse results with corresponding results for the Aurora OR-parallel Prolog system. For a large set of benchmarks, the results are in favor of the Muse system.

Determinacy analysis for full Prolog

article Free Access Share on Determinacy analysis for full Prolog Author: Dan Sahlin SICS, Box 1263, S-164 28, Sweden SICS, Box 1263, S-164 28, SwedenView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 9Sept. 1991 pp 23–30https://doi.org/10.1145/115866.115869Published:01 May 1991Publication History 11citation208DownloadsMetricsTotal Citations11Total Downloads208Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Full prolog and scheduling or-parallelism in muse

Muse is a simple and efficient approach to Or-parallel implementation of the full Prolog language. It is based on havingmultiplesequential Prolog engines, each with its local address space, and some shared memory space. It is currently implemented on a number of bus-based and switch-based multiprocessors. The sequential SICStus Prolog system has been adapted to Or-parallel implementation with very low extra overhead in comparison with other approaches. The Muse performanhce results are very encouraging in absolute and relative terms.

The Aurora or-parallel Prolog system

Aurora is a prototype or-parallel implementation of the full Prolog language for shared-memory multiprocessors, developed as part of an informal research collaboration known as the “Gigalips Project”. It currently runs on Sequent and Encore machines. It has been constructed by adapting Sicstus Prolog, a fast, portable, sequential Prolog system. The techniques for constructing a portable multiprocessor version follow those pioneered in a predecessor system, ANL-WAM. The SRI model was adopted as the means to extend the Sicstus Prolog engine for or-parallel operation. We describe the design and main implementation features of the current Aurora system, and present some experimental results. For a range of benchmarks, Aurora on a 20-processor Sequent Symmetry is 4 to 7 times faster than Quintus Prolog on a Sun 3/75. Good performance is also reported on some large-scale Prolog applications.

Partial evaluation of metaprograms in a “multiple worlds” logic language

This paper describes a partial evaluation system specifically designed to be used as an automatic compilation tool for metaprograms in a KBMS (EPSILON) based on Prolog. EPSILON main underlying concepts are the extension of Prolog with theories (“multiple worlds”) and the use of metaprogramming as the basic technique to define new inference engines and tools. Our partial evaluator is oriented towards theories and metainterpreter specialization. Being designed to be used as an automatic compiler, it does not require declarations from the user to control the unfolding process. It handles full Prolog and provides also an elegant solution to the problem of the partial evaluation of incomplete and self-modifying programs, by exploiting the multiple worlds feature added to Prolog. EPSILON partial evaluation system turned out to be a very useful and powerful tool to combine the low cost and the flexibility of metaprogramming with the performance requirements of a practical knowledge based system.

Use of a Forth-based Prolog for real-time expert systems. II. A full Prolog interpreter embedded in Forth

Use of a Forth-based Prolog for real-time expert systems. II. A full Prolog interpreter embedded in Forth