On the practicality of global flow analysis of logic programs

This paper addresses the issue of the practicality of global flow analysis in logic program compilation, in terms of both speed and precision of analysis. It discusses design and implementation aspects of two practical abstract interpretation-based flow analysis systems: MA3, the MOO Andparallel Analyzer and Annotator; and Ms, an experimental mode inference system developed for SB-Prolog. The paper also provides performance data obtained from these implementations. Based on these results, it is concluded that the overhead of global flow analysis is not prohibitive, while the results of analysis can be quite precise and useful

Precise Goal-Independent Abstract Interpretation of Constraint Logic Programs

AbstractWe present a goal-independent abstract interpretation framework for pure constraint logic programs, and prove the sufficiency of a set of conditions for abstract domains to ensure that the analysis will never lose precision. Along the way, we formally define pure constraint logic programming systems, give a formal semantics that is independent of the actual constraint domain, and formally define the maximally precise abstraction of a pure constraint logic program

Global flow analysis as a practical compilation tool

This paper addresses the issue of the practicality of global flow analysis in logic program compilation, in terms of speed of the analysis, precisión, and usefulness of the information obtained. To this end, design and implementation aspects are discussed for two practical abstract interpretation-based flow analysis systems: MA , the MCC And-parallel Analyzer and Annotator; and Ms, an experimental mode inference system developed for SB-Prolog. The paper also provides performance data obtained (rom these implementations and, as an example of an application, a study of the usefulness of the mode information obtained in reducing run-time checks in independent and-parallelism.Based on the results obtained, it is concluded that the overhead of global flow analysis is not prohibitive, while the results of analysis can be quite precise and useful

Task granularity analysis in logic programs

While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a sepárate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results

Design of abstract domains using first-order logic

In this paper we propose a simple framework based on first-order logic, for the design and decomposition of abstract domains for static analysis. An assertion language is chosen that specifies the properties of interest, and abstract domains are defined to be suitably chosen sets of assertions. Composition and decomposition of abstract domains is facilitated by their logical specification in first-order logic. In particular, the operations of reduced product and disjunctive completion are formalized in this framework. Moreover, the notion of (conjunctive) factorization of sets of assertions is introduced, that allows one to decompose domains in `disjoint' parts. We illustrate the use of this framework by studying typical abstract domains for ground-dependency and aliasing analysis in logic programming

Analysis of nonlinear constraints in CLP(R)

Solving nonlinear constraints over real numbers is a complex problem. Hence constraint logic programming languages like CLP(R) or Prolog III solve only linear constraints and delay nonlinear constraints until they become linear. This efficient implementation method has the disadvantage that sometimes computed answers are unsatisfiable or infinite loops occur due to the unsatisfiability of delayed nonlinear constraints. These problems could be solved by using a more powerful constraint solver which can deal with nonlinear constraints like in RISC-CLP(Real). Since such powerful constraint solvers are not very efficient, we propose a compromise between these two extremes. We characterize a class of CLP(R) programs for which all delayed nonlinear constraints become linear at run time. Programs belonging to this class can be safely executed with the efficient CLP(R) method while the remaining programs need a more powerful constraint solver

Object-oriented implementation of Prolog

Logic programming is a discipline of describing problems in high-level abstraction by separating logic from control. Conventional Prolog interpretation or compilation models take a procedural view of Prolog programs. A description of interpretation models was summarized by Bruynooghe[Bru82] and a well-known compilation model was introduced by Warren[War83]. The goal of this study is to present an alternative approach to construct Prolog execution model to tackle the complexities caused by conventional Prolog execution models. By taking the advantage of object-oriented techniques, a new model - object-oriented model is proposed. Instead of decomposing a given Prolog program into a set of procedures, the model translates it into a collection of coordinated objects which simulate components of the problem to be solved. First, the object-oriented model is described in terms of the object base and inference engine. The object base represents the components of Prolog programs naturally with corresponding objects in terms of AND/OR network. The inference engine, which specifies the operational behaviour of the objects, is embedded in the object base and independent of any specific Prolog program. Secondly, implementation issues of a Prolog system based on the object-oriented model are presented. A transformation program is developed to translate any given Prolog program into a set of objects and assign the corresponding relations among them. The implementation of the inference engine adopts Robinson’s resolution [Rob79] which consists of two major algorithms; unification and backtracking. Finally, the first parameter hashing optimization and a uniform interface to adopt new built-in predicates are addressed to show the extensibility of proposed Prolog system. An experimental object-oriented Prolog system, LU-Prolog, has been developed based on the proposed model. An evaluation of the performance of LU-Prolog and its future directions are also presented in this thesis