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.