XSB 3.1 Released

[tsw...@cs.sunysb.edu]

Release Notes

Version 3.1 (Incognito)

Version 3.1 is a major rewriting of XSB to new functionalities and
improve XSB's stability, particularly for the multi-threaded engine

Major Improvements

64-bit compilation Both the single-threaded and multi-threaded
engines of XSB have been thoroughly tested on 64-bit Linux. All XSB
functionality and packages now work when XSB is compiled on such
platforms using either 64-bit or 32-bit compilation.

Incremental tabling Incremental tabling has been added for
programs that use tabling with call-variance on program fragments
that do not require tabled negation. If a table depends on dynamic
code (perhaps indirectly) asserts or retracts to the code will
propagate incremental changes to the various depending tables. Thus
the tables are updated automatically and incrementally with respect
to changes in fluents, rather than having to be explicitly
recomputed.

Multi-threading improvements The multi-threaded engine is faster
and far more robust than in previous versions. Libraries have been
expanded for the multi-threaded engine as well.

A single query can now safely intermix private and shared tables,
even if can depend on each other in the same SCC or depend through
conditional answers in the well-founded semantics.

Heap garbage collection now can occur for any thread independently
of any other thread.

Improvements have been made for thread, mutex, and message queue
management, usually based on ISO working document ISO/IEC DTR
13211{5:2007} with which XSB is now mainly in compliance:

Private and shared unification-based message queues are now
supported, user-level mutex are now supported, as are
thread, mutex, and queue aliases.

Thread creation allows a number of parameters to be passed
in via an option list, or alternately taken from settable
defaults. In addition, thread cancellation now cancels
threads when they are waiting for messages or are blocked on
I/O.

Specific to XSB, examples have been added so that XSB can used as
a multi-threaded server with socket-based communication. The
regexp, wildmatch, and libwww libraries have been ported to the
multi-threaded engine.

Improved C-calling XSB interface

XSB now behaves better when embedded in a C process. When XSB
encounters an error, it uses a mechanism to pass the error
back to C. Errors that cause XSB to exit when called as a
stand-alone server have the type "unrecoverable error".

Query caching has been added to the C/XSB interface to make
repeated queries to XSB more efficient.

The C-calling XSB interface has also been updated for the
multi-threaded engine so that a given XSB thread can be safely
queried by multiple C (or Java) threads, a facility that works
for the varstring, fixed string, and register interfaces.
Within a multi-threaded system XSB threads can maintain the
state of queries if desired so that they function analogously
to cursors in a database.

Improved memory management for tables

When a given tabled subgoal (predicate) T1 is abolished, any
tabled subgoal (predicate) T2 that depends conditionally on
T1 will also be abolished by default (this behavior can be
altered by a flag, or by using an option list).

All space for conditional answer information is now reclaimed
when space for a tabled predicate or subgoal is reclaimed
after an abolish or simplification operation. In addition,
all information for private tables, including conditional
table information is thread-private, and is reclaimed upon a
thread's exit.

Added structure manager for private hash tables in tries. In
addition, each shared structure manager now has its own mutex
in the multi-threaded engine. These changes should improve
scalability of tables in the shared engine.

Detailed statistical information is not available on all
table structures, including those for conditional answers.
In the multi-threaded engine, this information is available
for both shared tables and tables private to the calling
thread.

Two new predicates are added for table management in the
multi-threaded engine: abolish_all_shared_tables/0 and
abolish_all_private_tables/0.

Improvements to dynamic clause garbage collection

Dynamic clause garbage collection for private dynamic
predicates now uses private structure managers to improve
concurrency for retracting private clauses.

Dynamic clause garbage collection has been tuned to be more
efficient for routines that call retract(all) repeatedly.

Improved ISO compatibility for numerous cases of error handling. With
relatively minor exceptions, XSB now generally throws ISO-compliant
errors for ISO predicates.

Improvements in Interned Tries Library XSB provides interned tries
as an extremely efficient way of adding and deleting terms to a global
store (private to each thread):

The API for interned tries was redesigned to make it simpler to
use, and in some cases more efficient. Error checking has been
added to make the library more robust.

To check whether a trie may be backtracked over before deleting a
trie, or expanding its hash table.

New syntax for tables allows concise declarations of various
attribute
combinations, including whether the predicate is to use call
subsumption or call variance, is dynamic or static, is private or
shared, and is incremental.