MOP Inside! PERSISTENT LISP OBJECTS!

Version 2.11 of May 28, 2005

by Heiko Kirschke SourceForge Logo


It's funny I thought I should do things differently for a database, but Plob lets you do things in a Lisp way.
-- M. A.

What is it about?

The system PLOB! (Persistent Lisp OBjects!) implements orthogonal persistency for LISP and CLOS objects. Besides offering pure persistency, on the one side it contains important database features like transactions, locking and associative search over persistent objects. On the other side, PLOB! mimics the features of CLOS' Metaobject Protocol (MOP) as far as possible, e.g. by its implemented self-describing persistent objects and support for class changes promoted dynamically to persistent objects (schema evolution).

Transparent Persistency

An important topic was to make the interface between LISP and persistency as transparent to the user as possible, without sacrificing efficiency. PLOB! solves both problems: By employing the possibilites of CLOS' MOP, the user interface to persistency is as simple as it can be. In fact, using only a few statements of LISP code will make instances of CLOS classes persistent, e.g.
CL-USER 3 > (defclass person ()
              ((name :initarg :name :index (btree :test equal)))
              (:metaclass persistent-metaclass))
declares a class person with its instances being persistent and an index for associative search on its slot name (actually, the class metaobject which represents the class person itself will become persistent, too). Using some other statements will make ordinary LISP and structure objects persistent. It is also possible to make CLOS objects persistent which are out of the user's control, for example, instances where the defclass defining the class is not available and cannot be modified as indicated in the example above. Besides that, PLOB! has the notion of persistent packages and persistent symbols for binding persistent objects:
CL-USER 4 > (setf #!*a-person*
                  (make-instance 'person :name "Kirschke"))
will bind the persistent instance generated from the make-instance call to the persistent symbol *a-person*. Similar to transient packages and symbols, an object can be bound to a persistent symbol and thereby gets persistent and identifyable:
CL-USER 5 > (setf #!*a-string* "A persistent string.")
... some years and LISP processes later ...
CL-USER 99 > #!*a-string*
"A persistent string."

Client/server architecture

PLOB!'s architecture is a true client/server-approach, communicating by UNIX' standard RPCs. The server administers a persistent object space; one or more clients can access the persistent objects contained in the persistent object space. The multi-user access is completely serialized, since the implemented transactions and locking algorithm results in an isolation level of 3 according to the SQL-92 definition. The server is a UNIX process running on one of the machines mentioned below; the clients are processes running one of the LISP systems mentioned below (especially, clients with different LISP systems can connect concurrently to one server). By using UNIX' standard RPCs, heterogenous operation is supported too, i.e. the server and client can run on different operating or LISP systems. Access to the persistent object space can be allowed or denied on a per-host level.

Efficiency

Efficiency is gained by the low-level layers implemented in C, coupled with sophisticated data modelling and object handling. By implementing most of LISP's base types directly as base types into PLOB!, the requirement for time-consuming conversions between transient LISP objects and the persistent objects stored within the persistent object space is kept to a minimum. To reduce the data exchange between client and server, the client code provides for object preallocation and object caching. A reference from a referencing persistent object to a referenced persistent object can be marked as being dependent; when a client loads the referee, the referenced object will be transmitted within the same data block to the client, too.

Database features

Persistency itself is only half of the business; besides that, PLOB! has implemented many database features, namely transactions, locks and indices. Each access to persistent objects is embedded into well-formed transactions, either by an explicit transaction block opened by the user's code:
CL-USER 6 > (with-transaction ()
              (setf #!*a-string* "Next persistent string.")
             
... lots of more code ...
              (setf #!*b-string* "Second string."))
or, if the user didn't specify a transaction block, PLOB! will surround each access by a transaction internally. In the above example, embedding the code into a transaction assures that either all changes done to persistent objects in the block will be committed to the persistent object space or, e.g. in the case of an error at proceeding the statements in the block, none of the changes will be promoted to the database. Serialization between concurrent transactions is provided by the two-phase transaction model adopted within PLOB!

The precondition for a transaction to be well-formed is that each object accessed within a transaction is reserved for the accessor; this is accomplished by PLOB's hierarchical lock protocol. Locks can be requested on one of the levels slot, object or whole database with the modes read, write or read-only. Page locking is not supported, since this makes no sense for the heterogenous population found in an object-oriented database.

For indices, PLOB! has persistent btrees, which are used internally for various tables and are made available for the user's purpose too as shown already above in the person class example. It is also possible to use btrees directly:

CL-USER 7 > (setf *my-btree* (make-btree :test 'equal))
will set *my-btree* to a persistent btree. The operations on persistent btrees are very similar to those of hash tables, with the difference of the keys being sorted. (Of course, LISP's hash tables are supported too; PLOB! infringes no mapping from hash tables to btrees.)


System requirements for a successfull installation

PLOB! is distributed as free software, see the User's Guide for details. PLOB! will run on the following LISP and operating systems:
LISP systems
Supported are Harlequin LispWorks Common LISP up to and including version 4.2 and Franz Allegro Common LISP up to and including version 6.2.
Operating systems
Full supported are Solaris 2.x, Linux kernel version 2.x, Windows NT 4.0, Windows 2000 and Windows XP. The current distribution contains an old IRIX distribution; if you are interested in an up-to-date IRIX distribution, contact the author. For client-only installations on other operating systems, see the explanations given below.
System Resources needed
The complete installation will take around 50 MB disk space, plus the space allocated by the persistent objects administered by PLOB. The memory requirements for the client are around 32 MB, the server should be able to run with less memory.
The server of PLOB! uses the POSTORE subsystem, created within the scope of the persistent programming language Napier88 at the University of St. Andrews. Since the copyright on POSTORE is owned by the University of St. Andrews, a server installation is possible on request to me for other operating systems. A client-only installation should be possible for other operating systems with the distribution provided here, but requires a Solaris, IRIX, Linux or Windows/NT machine running the PLOB server near the client.


Downloadable Software & Documentation

Please use the download possibility referenced by PLOB's SourceForge project page.

Bugfixes

 
 
 
 
 
 
 
 
What
do
you
want
to
debug
today?TM
Please consult the bug tracking feature referenced by PLOB's SourceForge project page.

Changes from version 2.09 to 2.10

Please read the release notes associated to the latest release referenced by PLOB's SourceForge project page. Here is the list of changes for older versions.


References

If you have any LISP software using PLOB!, please contact me if you would like a link to be added here.


Publications

All publications are in german unless otherwise noted.
 \\/
Book
Heiko Kirschke: Persistenz in objekt-orientierten Programmiersprachen. Logos Verlag, Berlin. 1997.

Contact Address

Feel free to contact me on any questions, remarks and hints:
Mailing list
There is a mailing list plob-discussion@lists.sourceforge.net on PLOB. To subscribe, use either the mailing list administration interface, or send an email with `subscribe' in the email's body to plob-discussion-request@lists.sourceforge.net:
To: plob-discussion-request@lists.sourceforge.net
--text follows this line--
subscribe
end
For unsubscribing, send an email with `unsubscribe' in the email's body to plob-discussion-request@lists.sourceforge.net:
To: plob-discussion-request@lists.sourceforge.net
--text follows this line--
unsubscribe
end
The end line is only necessary if there might be a following signature.

Post your messages to plob-discussion@lists.sourceforge.net, plob-discussion-request@lists.sourceforge.net is used only for subscribing and administration. Purpose of this mailing list is to get support on installing and using PLOB, for reporting bugs, for getting announcements on new versions and for general topics on persistency, in this order. It is by intention a low-traffic mailing list.

Email
Heiko.Kirschke@acm.org
Disclaimer
The opinions expressed on this page and in the written documentation are completely that of my own.
Fun
Here is a translation of an older version of this page into german done by AltaVista's babelfish.

Heiko.Kirschke@acm.org
Last modified: Wed May 25 11:04:50 2005