[2-3] Free Parallel Prolog Implementations

This section contains free parallel Prolog and logic programming
implementations. 

BAP:
   Brain Aid Prolog (BAP) is a Concurrent Sequential Processes (CSP)
   based standard Prolog for Transputer networks. BAP uses its own MS
   Windows or X Windows server for I/O. Special features include
   automatic topology adapation and concurrent source level debugging
   (see several processes exchange messages). Performance is pretty high,
   comparable to that of other Prolog compilers. BAP has achieved good
   results (>80% efficiency) when executing applications like N-queens or
   checkers in parallel on an 8 processor network. A demo version that
   supports Transputer systems with a maximum of 2 processors is
   available by anonymous ftp from 
      unlisys.in-berlin.de:/pub/brainaid/
   and also from the CMU AI Repository, in
      ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/parallel/bap/
   A full version for up to 128 nodes is also available for both SUN and
   PC. Write to Frank Bergmann <fraber@cs.tu-berlin.de> or 
   <bap_info@brainaid.in-berlin.de> for more information. 

BeBOP:
   The BeBOP language combines sequential and parallel Logic Programming
   (LP), object oriented programming and meta-level programming. The LP
   component offers both don't know non-determinism and stream AND
   parallelism, a combination not possible with concurrent LP languages.
   BeBOP's object oriented features include object IDs, encapsulation,
   message passing, state updating, and object behaviour modification.
   The meta-level capabilities are based on the treatment of Prolog
   theories as first order entities, which enables them to be updated
   easily and lets fragments to be passed between objects in messages.
   BeBOP is implemented by translation down to NU-Prolog, and its
   parallel extension, PNU-Prolog.  The BeBOP system (BeBOP and bp) and
   the PNU-Prolog preprocessor pnp can be obtained by anonymous ftp from
   munnari.oz.au:/pub/bebop.tar.Z [128.250.1.21].  The release comes with
   a user manual, several papers (in Postscript format), sample programs,
   and source code.  The BeBOP system requires the NU-Prolog system,
   compiler and interpreter, the pnp preprocessor (which is included as
   part of the BeBOP system release), GCC or a similar compiler, Yacc (or
   Bison) and Lex. For more information, contact Andrew Davison,
   <ad@cs.mu.oz.au>, Dept. of Computer Science, University of Melbourne,
   Parkville, Victoria 3052, Australia, call +61 3-287-9172/9101, or fax
   +61 3-348-1184.

KLIC:
   KLIC is a portable implementation of KL1 (an extended Flat GHC), a
   concurrent logic programming language developed at ICOT in Japan.
   Runs on Suns, HPs, DECs, and Linux PC's and marks 2 MLIPS on
   SparcStation 10/30 and 4MLIPS on system with 200MHz Alpha.  A
   sequential version available via anonymous ftp from ftp.icot.or.jp.
   Parallel versions planned shortly.  A representative paper on the
   language is Kazunori Ueda and Takashi Chikayama, "Design of the
   Kernel Language for the Parallel Inference Machine", The Computer
   Journal, December, 1990.  A paper on its KLIC implementation is
   Takashi Chikayama, Tetsuro Fujise and Daigo Sekita, "A Portable and
   Efficient Implementation of KL1", PLILP'94 (LNCS #844,
   Springer-Verlag).  For more information, send an email to
   klic-requests@icot.or.jp or write to ICOT Free Software Desk,
   Institute for New Generation Computer Technology, 21st Floor, Mita
   Kokusai Bldg., 4-28, Mita 1-chome, Minato-ku, Tokyo 108, Japan, fax
   +81-3-3456-1618.

Multi-BinProlog:
   Multi-BinProlog 2.00 is a prototype Linda-style parallel extension to
   BinProlog 1.71 developed by Koen De Bosschere and Paul Tarau. It uses
   Koen's C-parser and C-writer which together speed-up IO considerably.
   It works with shared-memory and remote procedure calls and is
   available from clement.info.umoncton.ca:MultiBinProlog/
   See BinProlog in [2-1] for more information.

NCL:
   NCL (Net-Clause Language) is aimed at describing distributed
   computation models using term unification as a basic processing and
   control mechanism. It is embedded in standard Prolog and comprises two
   parts -- net-clauses and data-driven rules, which can communicate each
   to other and to standard Prolog programs.  A net-clause is a special
   domain in the database defining a network of nodes and links. The
   nodes are represented by Prolog compound terms. The variables
   occurring within the nodes are global logical variables, which can be
   shared within the scope of the net-clause thus playing the role of
   network links.  Two control mechanisms are implemented: a spreading
   activation scheme similar to the connectionist spreading activation
   and to the marker passing mechanism in SN (in logic programming it is
   seen as a restricted forward chaining) and a default mechanism based
   on using variables to propagate terms without being bound to them,
   thus implementing the non-monotonicity of default reasoning.  The
   Data-driven Rules implement a full scale forward chaining for Horn
   clauses.  They simulate a data-driven parallel computation, where each
   rule is a process (in contrast to the traditional parallel logic
   programming where each goal is a process). The NCL/Prolog interpreter
   along with a reference manual and a set of examples is available by
   anonymous ftp at ai.uga.edu:/pub/misc/ncl.tar.Z. For more information
   contact Zdravko Markov, Institute of Informatics, Bulgarian Academy of
   Sciences Acad.G.Bonchev Street, Block 29A, 1113 Sofia, Bulgaria,
   <markov@iinf.bg>.

PCN:
   PCN (Program Composition Notation) is not a logic programming
   language, but it has similarities to Strand and other concurrent logic
   programming languages. PCN is a parallel programming system that
   provides a simple language for specifying concurrent algorithms,
   interfaces to Fortran and C, a portable toolkit that allows
   applications to be developed on a workstation or small parallel
   computer and run unchanged on supercomputers, and integrated debugging
   and performance analysis tools. PCN includes a runtime system,
   compiler, linker, a set of standard libraries, virtual topology tools,
   a symbolic debugger (PDB), an execution profiler (Gauge), and a trace
   analysis tool (Upshot). PCN was developed at Argonne National
   Laboratory and the California Institute of Technology.  PCN runs on
   Sun4, NeXT, IBM RS/6000, SGI Iris, Intel iPSC/860, Intel Touchstone
   DELTA, Sequent Symmetry running Dynix (not PTX), and should be easy to
   port to other architectures. PCN is in the public domain and can be
   obtained by anonymous ftp from
      info.mcs.anl.gov:/pub/pcn/pcn_v2.0.tar.Z 
   The distribution includes a user's guide containing a tutorial and
   reference material. For further information on PCN, please send email to
   <pcn@mcs.anl.gov> or contact Ian Foster <foster@mcs.anl.gov>
   708-252-4619 or Steve Tuecke <tuecke@mcs.anl.gov> 708-252-8711.

ROLOG: 
   ROLOG is a parallel PROLOG compiler with a reduce-OR process model.
   It is available by anonymous ftp from cs.uiuc.edu:/pub/ROLOG/.

See also IC-Prolog II (a multi-threaded Prolog) in [2-1].