Abstract: Mode and data dependency analyses find many applications in the generation of efficient exe-cutable code for logic programs. For example, mode information can be used to generate specialized unification instructions where permissible; to detect determinacy and functionality of programs; to gen-erate index structures more intelligently; to reduce the amount of runtime tests in systems that support goal suspension; and in the integration of logic and functional languages. Data dependency information can be used for various source-level optimizing transformations, to improve backtracking behavior, and to parallelize logic programs. This paper describes and proves correct an algorithm for the static infer-ence of modes and data dependencies in a program. The algorithm is shown to be quite efficient for pro-grams commonly encountered in practice.

In general, logic programs are undirected, i.e. there is no concept of "input" and "output" arguments to a procedure. An argument may be used either as an input or as an output argument, and programs may be executed either in a "forward" direction or in a "backward" direction. However, it is often the case that in a given program, a predicate is used with some of its arguments used consistently as input arguments and others as output arguments. Such mode information can be used by a compiler to effect various optimizations. This paper considers the problem of automatically inferring the modes of the predicates in a program. The dataflow analysis we use is more powerful than approaches relying on syntactic characteristics of programs, e.g. [18]. Our work differs from that of Mellish [14, 15] in that (i) we give a sound and efficient treatment of variable aliasing in mode inference; (ii) by propagating instantiation information using state transformations rather than through dependen...

This paper examines the problem of adding non-deterministic constructs to a declarative database language based on Horn Clause Logic. We revise a previously proposed approach, the choice construct introduced by Krishnamurthy and Naqvi, from the viewpoints of amenability to efficient implementation and expressive power.

Abstract: Research on flow analysis and optimization of logic programs typically assumes that the pro-grams being analyzed are static, i.e. any code that can be executed at runtime is available for analysis at compile time. This assumption may not hold for ‘‘real’ ’ programs, which can contain dynamic goals of the form call(X), where X is a variable at compile time, or where predicates may be modified via features like assert and retract. In such contexts, a compiler must be able to take the effects of such dynamic con-structs into account in order to perform nontrivial flow analyses that can be guaranteed to be sound. This paper outlines how this may be done for certain kinds of dynamic programs. Our techniques allow analysis and optimization techniques that have been developed for static programs to be extended to a large class of ‘‘well-behaved’ ’ dynamic programs. Address for correspondence and proofs:

Abstract: Profilers play an important role in the development of efficient programs. Profiling techniques developed for traditional languages are inadequate for logic programming languages, for a number of rea-sons: first, the flow of control in logic programming languages, involving backtracking and failure, is significantly more complex than in traditional languages; second, the time taken by a unification opera-tion, the principal primitive operation of such languages, cannot be predicted statically because it depends on the size of the input; and finally, programs may change at runtime because clauses may be added or deleted using primitives like assert and retract. In this paper we describe a simple profiler for Prolog. The ideas outlined here may either be used to implement a simple interactive profiler, or be integrated into Prolog compilers. 1.

The ROCK & ROLL database system cleanly integrates deductive and object-oriented capabilities by defining an imperative programming language, ROCK, and a declarative, deductive language, ROLL, over a common object-oriented (OO) data model. Existing techniques for evaluation and optimization of deductive languages fail to address key requirements imposed by ROLL such as: strict typing; placement of deductive methods (predicates) within classes; encapsulation; overriding and late binding. This paper describes the task of implementing an evaluator and optimizer for ROLL, explaining how existing implementation techniques for deductive languages were adapted to meet these requirements and extended to support novel types of optimization. a a Accepted for publication in: Proc. 4th Int. Conf. on Deductive and ObjectOriented Databases (DOOD'95) 1 Introduction This paper describes the task of implementing of an evaluator and optimizer for a deductive query language (DQL) operating over an ob...

Hassan Ait-Kaci introduced the -term, an informational structure resembling feature- based functional structures but which also includes taxonomic inheritance (Ait-Kaci, 1984). We describe -terms and how they have been incorporated into the Logic Grammar formalism. The result, which we call Inheritance Grammar, is a proper superset of DCG and includes many features of PATR-II. Its taxonomic reasoning facilitates semantic type-class reasoning during grammatical analysis.