CIAO(ID:5477/cia002)Distributed And/Or parallel prologfor Concurrent, Constraint, Independence-based And/Or parallel Prolog. simple (web-)distributed LP/CLP language CLIP Group, School of Computer Science, Technical University of Madrid (UPM) Related languages
References: A number of parallel logic programming systems, which have been shown to be capable of significant speedups over state of the art sequential Prolog systems, are already being used as platforms by the project partners. These include &-Prolog [39] (developed at Madrid), Muse [2, 3] (developed at SICS), and ElipSys [7] (developed at ECRC). The ElipSys execution platform, a prototype of which was developed as part of ESPRIT Project 2025, EDS, supports OR-parallelism as well as a framework for implementing constraint solvers and a close coupling to databases. Muse is a well established execution platform that allows Prolog to be executed in parallel by exploiting OR-parallelism. The &-Prolog system is also a well established parallel Prolog system that exploits (independent) AND-parallelism. Some parts of the &-Prolog and Muse models were developed by SICS and Madrid in ESPRIT Project 2471, PEPMA. A matter of great interest is the combination of the capabilities of these systems, as well as those of other languages, both from the point of view of concurrency and constraint support. The AGENTS Language (AKL) is a new concurrent logic language developed by SICS in ESPRIT Project 2471, PEPMA, with a large potential for parallel execution. It provides the programming paradigms of search-oriented languages such as Prolog, process-oriented languages such as GHC, and the constraint logic programming languages in a unified framework. A proposal for combining Muse and &-Prolog into one system to exploit their two sources of parallelism while maintaining the high efficiency of both systems is represented by the ACE model [35]. We refer to a further enhancement of this model which also supports constraint solving (and explicit concurrency) in the same framework as Ciao-Prolog --(Concurrent,) Constraint, Independence-based And/Or parallel Prolog. Ciao offers a complete Prolog system, supporting ISO-Prolog, but its novel modular design allows both restricting and extending the language. As a result, it allows working with fully declarative subsets of Prolog and also to extend these subsets (or ISO-Prolog) both syntactically and semantically. Most importantly, these restrictions and extensions can be activated separately on each program module so that several extensions can coexist in the same application for different modules. Ciao also supports (through such extensions) programming with functions, higher-order (with predicate abstractions), constraints, and objects, as well as feature terms (records), persistence, several control rules (breadth-first search, iterative deepening, ...), concurrency (threads/engines), a good base for distributed execution (agents), and parallel execution. Libraries also support WWW programming, sockets, external interfaces (C, Java, TclTk, relational databases, etc.), etc. Ciao offers support for programming in the large with a robust module/object system, module-based separate/incremental compilation (automatically --no need for makefiles), an assertion language for declaring (optional) program properties (including types and modes, but also determinacy, non-failure, cost, etc.), automatic static inference and static/dynamic checking of such assertions, etc. Ciao also offers support for programming in the small producing small executables (including only those builtins used by the program) and support for writing scripts in Prolog. The Ciao programming environment includes a classical top-level and a rich emacs interface with an embeddable source-level debugger and a number of execution visualization tools. The Ciao compiler (which can be run outside the top level shell) generates several forms of architecture-independent and stand-alone executables, which run with speed, efficiency and executable size which are very competive with other commercial and academic Prolog/CLP systems. Library modules can be compiled into compact bytecode or C source files, and linked statically, dynamically, or autoloaded. The novel modular design of Ciao enables, in addition to modular program development, effective global program analysis and static debugging and optimization via source to source program transformation. These tasks are performed by the Ciao preprocessor ( ciaopp, distributed separately). The Ciao programming environment also includes lpdoc, an automatic documentation generator for LP/CLP programs. It processes Prolog files adorned with (Ciao) assertions and machine-readable comments and generates manuals in many formats including postscript, pdf, texinfo, info, HTML, man, etc. , as well as on-line help, ascii README files, entries for indices of manuals (info, WWW, ...), and maintains WWW distribution sites. Extract: Description The Ciao system is a full programming environment for developing programs in the Prolog language and in several other languages which are extensions and modifications of Prolog in several interesting and useful directions. The programming environment offers a number of tools such as the Ciao standalone compiler (ciaoc), a traditional-style top-level interactive shell (ciaosh or ciao), an interpreter of scripts written in Prolog (ciao-shell), a Prolog emacs mode (which greatly helps the task of developing programs with support for editing, debugging, version/change tracking, etc.), numerous libraries, a powerful program preprocessor (ciaopp, which supports static debugging and optimization from program analysis via source to source program transformation), and an automatic documentation generator (lpdoc). A number of execution visualization tools are also available. This manual documents the first four of the tools mentioned above [see PART I - The program development environment], and the Ciao Prolog language and libraries. The ciaopp and lpdoc tools are documented in separate manuals. The Ciao language [see PART II - The Ciao basic language (engine)] has been designed from the ground up to be small, but to also allow extensions and restrictions in a modular way. The first objective allows producing small executables (including only those builtins used by the program), providing basic support for pure logic programming, and being able to write scripts in Prolog. The second one allows supporting standard ISO-Prolog [see PART III - ISO-Prolog library (iso)], as well as powerful extensions such as constraint logic programming, functional logic programming, and object-oriented logic programming [see PART VII - Ciao Prolog extensions], and restrictions such as working with pure horn clauses. The design of Ciao has also focused on allowing modular program development, as well as automatic program manipulation and optimization. Ciao includes a robust module system, module-based automatic incremental compilation, and modular global program analysis, debugging and optimization, based on a rich assertion language [see PART V - Annotated Prolog library (assertions)] for declaring (optional) program properties (including types and modes), which can be checked either statically or dynamically. The program analysis, static debugging and optimization tasks related to these assertions are performed by the ciaopp preprocessor, as mentioned above. These assertions (together with special comment-style declarations) are also the ones used by the lpdoc autodocumenter to generate documentation for programs (the comment-style declarations are documented in the lpdoc manual). Ciao also includes several other features and utilities, such as support for several forms of executables, concurrency (threads), distributed and parallel execution, higher-order, WWW programming (PiLLoW), interfaces to other languages like C and Java, database interfaces, graphical interfaces, etc., etc. [see PARTS VI to XI]. Resources
|