311 research outputs found
Incremental copying garbage collection for WAM-based Prolog systems
The design and implementation of an incremental copying heap garbage
collector for WAM-based Prolog systems is presented. Its heap layout consists
of a number of equal-sized blocks. Other changes to the standard WAM allow
these blocks to be garbage collected independently. The independent collection
of heap blocks forms the basis of an incremental collecting algorithm which
employs copying without marking (contrary to the more frequently used mark©
or mark&slide algorithms in the context of Prolog). Compared to standard
semi-space copying collectors, this approach to heap garbage collection lowers
in many cases the memory usage and reduces pause times. The algorithm also
allows for a wide variety of garbage collection policies including generational
ones. The algorithm is implemented and evaluated in the context of hProlog.Comment: 33 pages, 22 figures, 5 tables. To appear in Theory and Practice of
Logic Programming (TPLP
Applying Prolog to Develop Distributed Systems
Development of distributed systems is a difficult task. Declarative
programming techniques hold a promising potential for effectively supporting
programmer in this challenge. While Datalog-based languages have been actively
explored for programming distributed systems, Prolog received relatively little
attention in this application area so far. In this paper we present a
Prolog-based programming system, called DAHL, for the declarative development
of distributed systems. DAHL extends Prolog with an event-driven control
mechanism and built-in networking procedures. Our experimental evaluation using
a distributed hash-table data structure, a protocol for achieving Byzantine
fault tolerance, and a distributed software model checker - all implemented in
DAHL - indicates the viability of the approach
A semantics and implementation of a causal logic programming language
The increasingly widespread availability of multicore and manycore computers demands new programming languages that make parallel programming dramatically easier and less error prone. This paper describes a semantics for a new class of declarative programming languages that support massive amounts of implicit parallelism
A Design and Implementation of the Extended Andorra Model
Logic programming provides a high-level view of programming, giving
implementers a vast latitude into what techniques to explore to achieve the
best performance for logic programs. Towards obtaining maximum performance, one
of the holy grails of logic programming has been to design computational models
that could be executed efficiently and that would allow both for a reduction of
the search space and for exploiting all the available parallelism in the
application. These goals have motivated the design of the Extended Andorra
Model, a model where goals that do not constrain non-deterministic goals can
execute first.
In this work we present and evaluate the Basic design for Extended Andorra
Model (BEAM), a system that builds upon David H. D. Warren's original EAM with
Implicit Control. We provide a complete description and implementation of the
BEAM System as a set of rewrite and control rules. We present the major data
structures and execution algorithms that are required for efficient execution,
and evaluate system performance.
A detailed performance study of our system is included. Our results show that
the system achieves acceptable base performance, and that a number of
applications benefit from the advanced search inherent to the EAM.Comment: 43 pages, To appear in Theory and Practice of Logic Programming
(TPLP
- ā¦