From eslick at csail.mit.edu Sun Jun 4 06:26:34 2006 From: eslick at csail.mit.edu (Ian Eslick) Date: Sun, 04 Jun 2006 02:26:34 -0400 Subject: [elephant-devel] Rucksack and Elephant Message-ID: <44827D1A.6010304@csail.mit.edu> I distracted myself this afternoon by writing a cached binary file and buffer library with serializer as a potential step towards a native backend for Elephant. As I was contemplating some design decisions, I was curious how Arthur Lemmons made similar trade offs in Rucksack, motivating me to give his code a good read. That experience prompted the following comparison. (Rucksack is described in detail here: http://weitz.de/eclm2006/rucksack-eclm2006.txt) At present Elephant is fully functional and has been tested and used extensively in several demanding applications. Rucksack is not yet operational, but has a critical mass of code written for all functionality and has some architectural features worth keeping an eye on. The most exciting feature, of course, is that Rucksack is written entirely in mostly portable Common Lisp! Serialization: Both systems take a similar approach to binary serialization and should perform similarly. Persistent object storage: Rucksack and Elephant handle persistent objects very differently. In Elephant, every slot has a serialized descriptor (oid:class:slotname) that is used as a key to store all slot values in one large BDB BTree. The object oid is stored in class instances and used, along with class and slot names to index into the on-disk BTree to retrieve or overwrite a value. In Rucksack, object OIDs index a large vector which contain the current on-disk location of the serialized objects. On slot-writes, a new instance of the object is written to disk. On transaction commit, the vector pointer is updated. This requires Rucksack to commit to garbage collection in order to reclaim stored objects (something Elephant doesn't do as BDB handles transaction logging differently and does writes in place). However, the Rucksack choice provides a convenient way to handle transaction logging and rollbacks without a separate logging mechanism. This means that Rucksack has to serialize all dirty objects when it commits a transaction. This involve more writing of the disk and more total disk access than Elephant which only writes changed slot values. Within a transaction Rucksack provides an in-memory object cache of dirty objects and maintains a cache of committed objects as well so that future transaction don't need to re-serialize objects. MOP: The metaobject protocol support for persistent objects is similar, although Rucksack's is simpler in part because it makes more commitment to object level storage instead of slot-level storage. Both Elephant and Rucksack support schema evolution, the ability to redefine objects at runtime and have the persistent instances updates as in UPDATE-INSTANCE-FOR-REDEFINED-CLASS. Rucksack saves prior schemas so old instances can be loaded and then updated. Elephant effectively does the same by storing slot names so that the new schema can pick old values stored in the same name, then run the loaded instance through the update function. There are some potential pitfalls here in Elephant and I was intending to fix them in a similar way to Rucksack as part of a serializer enhancement to avoid writing slot names all the time. Garbage collection: Rucksack has a full incremental mark-and-sweep collector. Elephant only has a poor-man's stop-and-copy via the repository migration interface (support for doing this automatically is not built in and it's expensive). Enough said. ACID: Rucksack has an elegant solution to ACID properties by copy-on-write for persistent objects so that each parallel transaction has its own set of live objects. This avoids conflicts but also delays rollbacks. When a transaction has to abort because of a conflict, it just throws away the live objects in memory and restarts. This does mean that rollbacks are caused by object level write conflicts instead of slot conflicts. Summary: Rucksack is an elegant approach to persisting objects in Common Lisp. Its interface and Elephant's are very similar but they take a number of different and incompatible approaches to handling persistent slots, transactions, locking, etc. I don't foresee significant performance advantages on either side, but the serializer in Rucksack seems more efficient for standard objects at the cost of some robustness on class redefinition. I imagine I will be surprised by real-world benchmarks later. For example, I suspect that transaction performance will vary greatly based on workload. Typical website models should work the same on either as there are far fewer possible transaction collisions. Unfortunately Rucksack isn't easily re-targeted as a native lisp backend for Elephant because of the greatly differing assumptions behind persistent objects. There may be a bit of code and design ideas that can be lifted however - such as the heap and btree implementation. There are some smart ideas in the serializer and in schema evolution that I've considered already so it's nice to have a reference implementation to refer to. Notable differences: - Rucksack is a reasonably compact, easy-to-understand system written entirely in Common Lisp. Elephant has complex dependencies between Lisp, C and the architectural commitments of BDB. Elephant performs poorly on SQL today so BDB is the high performance backend. BDB has license issues for even small scale commercial deployment. - Rucksack has full support for garbage collection, Elephant has minimal off-line support for storage reclamation - Elephant will allow multiple lisp processes to use the same persistent store concurrently, a Rucksack store is locked to a single lisp instance. Elephant can be configured with BDB replication, allowing for larger-scale deployment. - Elephant is much more mature and it's disk storage is much more likely to be reliable so it will be some time until Rucksack is sufficiently mature for prime time. - Rucksack performs object-level collision detection, Elephant performs record-based collision in a paged storage system. This has different implications for how classes should be designed (slot values with large arrays, for instance, should be wrapped in their own persistent class so that writes to other slots does not result in multiple copies of that array). This review has been somewhat rambling, but I hope it makes people look forward to playing with Rucksack, produces some good ideas for Elephant and emphasizes that Elephant is ready for real world (although probably non-critical) applications today. Ian From eslick at csail.mit.edu Mon Jun 19 01:21:21 2006 From: eslick at csail.mit.edu (Ian Eslick) Date: Sun, 18 Jun 2006 21:21:21 -0400 Subject: [elephant-devel] 0.6.1 and HEAD Message-ID: <4495FC11.8040100@csail.mit.edu> I've started to make checkins towards the 0.6.1 release of Elephant. The current HEAD is not guaranteed to be backwards compatible (yet) and may contain problematic functionality. Please use the 0.6.0 release unless you specifically need a feature that is checked into HEAD and are willing to accept any discomfort in adapting to the current HEAD. With any luck there will be little perturbation, but I don't want it said folks weren't warned. :) For example I've checked in the efficient Allegro serializer. Unfortunately, it's not backward compatible with 0.6.0 databases. Ian From hayeah at gmail.com Thu Jun 22 05:48:47 2006 From: hayeah at gmail.com (Howard Yeh) Date: Wed, 21 Jun 2006 22:48:47 -0700 Subject: [elephant-devel] SBCL exits abnormally when compiling sleepycat.lisp Message-ID: Hi, I am trying to get Elephant to work. (require :elephant) (require :elephant-tests) (in-package "ELEPHANT-TESTS") (setf *default-spec* *testbdb-spec*) (do-backend-tests) ASDF seems to compile and load :elephant and :elephant-tests ok. But when I try (do-backend-tests), ASDF tries to compile sleepycat.lisp and causes SBCL to exit abnormally (code 256). Then I tried to compile sleepycat.lisp individually to see what happens. (require :elephant) (compile-file #p"/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" :verbose t) Same thing, abnormal exit 256. I did a lot of fiddling around, but still can't get it to work. I have no idea what's going on. I am using Elephant 0.6.0 and SBCL 0.9.12. -Howard ; compiling file "/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE "SLEEPYCAT") ; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...)) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...) ; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...) ; compiling (DEFUN DB-STRERROR ...) ; compiling (DEFINE-CONDITION DB-ERROR ...) ; compiling (DEFCONSTANT DB-BTREE ...) ; compiling (DEFCONSTANT DB-HASH ...) ; compiling (DEFCONSTANT DB-RECNO ...) ; compiling (DEFCONSTANT DB-QUEUE ...) ; compiling (DEFCONSTANT DB-UNKNOWN ...) ; compiling (DEFCONSTANT DB_AUTO_COMMIT ...) ; compiling (DEFCONSTANT DB_JOINENV ...) ; compiling (DEFCONSTANT DB_INIT_CDB ...) ; compiling (DEFCONSTANT DB_INIT_LOCK ...) ; compiling (DEFCONSTANT DB_INIT_LOG ...) ; compiling (DEFCONSTANT DB_INIT_MPOOL ...) ; compiling (DEFCONSTANT DB_INIT_REP ...) ; compiling (DEFCONSTANT DB_INIT_TXN ...) ; compiling (DEFCONSTANT DB_RECOVER ...) ; compiling (DEFCONSTANT DB_RECOVER_FATAL ...) ; compiling (DEFCONSTANT DB_LOCKDOWN ...) ; compiling (DEFCONSTANT DB_PRIVATE ...) ; compiling (DEFCONSTANT DB_SYSTEM_MEM ...) ; compiling (DEFCONSTANT DB_THREAD ...) ; compiling (DEFCONSTANT DB_FORCE ...) ; compiling (DEFCONSTANT DB_DEGREE_2 ...) ; compiling (DEFCONSTANT DB_DIRTY_READ ...) ; compiling (DEFCONSTANT DB_CREATE ...) ; compiling (DEFCONSTANT DB_EXCL ...) ; compiling (DEFCONSTANT DB_NOMMAP ...) ; compiling (DEFCONSTANT DB_RDONLY ...) ; compiling (DEFCONSTANT DB_TRUNCATE ...) ; compiling (DEFCONSTANT DB_TXN_NOSYNC ...) ; compiling (DEFCONSTANT DB_TXN_NOWAIT ...) ; compiling (DEFCONSTANT DB_TXN_SYNC ...) ; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...) ; compiling (DEFCONSTANT DB_DUP ...) ; compiling (DEFCONSTANT DB_DUPSORT ...) ; compiling (DEFCONSTANT DB_CURRENT ...) ; compiling (DEFCONSTANT DB_FIRST ...) ; compiling (DEFCONSTANT DB_GET_BOTH ...) ; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...) ; compiling (DEFCONSTANT DB_LAST ...) ; compiling (DEFCONSTANT DB_NEXT ...) ; compiling (DEFCONSTANT DB_NEXT_DUP ...) ; compiling (DEFCONSTANT DB_NEXT_NODUP ...) ; compiling (DEFCONSTANT DB_PREV ...) ; compiling (DEFCONSTANT DB_PREV_NODUP ...) ; compiling (DEFCONSTANT DB_SET ...) ; compiling (DEFCONSTANT DB_SET_RANGE ...) ; compiling (DEFCONSTANT DB_AFTER ...) ; compiling (DEFCONSTANT DB_BEFORE ...) ; compiling (DEFCONSTANT DB_KEYFIRST ...) ; compiling (DEFCONSTANT DB_KEYLAST ...) ; compiling (DEFCONSTANT DB_NODUPDATA ...) ; compiling (DEFCONSTANT DB_NOOVERWRITE ...) ; compiling (DEFCONSTANT DB_NOSYNC ...) ; compiling (DEFCONSTANT DB_POSITION ...) ; compiling (DEFCONSTANT DB_SEQ_DEC ...) ; compiling (DEFCONSTANT DB_SEQ_INC ...) ; compiling (DEFCONSTANT DB_SEQ_WRAP ...) ; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...) ; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...) ; compiling (DEFCONSTANT DB_KEYEMPTY ...) ; compiling (DEFCONSTANT DB_KEYEXIST ...) ; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...) ; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...) ; compiling (DEFCONSTANT DB_NOTFOUND ...) ; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...) ; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...) ; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...) ; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...) ; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...) ; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...) ; compiling (DEFCONSTANT DB_LOCK_OLDEST ...) ; compiling (DEFCONSTANT DB_LOCK_RANDOM ...) ; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...) ; compiling (DEF-ENUM DB-LOCKOP ...) From eslick at csail.mit.edu Thu Jun 22 15:50:25 2006 From: eslick at csail.mit.edu (Ian Eslick) Date: Thu, 22 Jun 2006 11:50:25 -0400 Subject: [elephant-devel] SBCL exits abnormally when compiling sleepycat.lisp In-Reply-To: References: Message-ID: <449ABC41.8020109@csail.mit.edu> What OS are you running on? Did you get a compile error? The trace looks ok. Ian Howard Yeh wrote: > Hi, > > I am trying to get Elephant to work. > > (require :elephant) > (require :elephant-tests) > (in-package "ELEPHANT-TESTS") > (setf *default-spec* *testbdb-spec*) > (do-backend-tests) > > ASDF seems to compile and load :elephant and :elephant-tests ok. > But when I try (do-backend-tests), ASDF tries to compile sleepycat.lisp > and causes SBCL to exit abnormally (code 256). > > Then I tried to compile sleepycat.lisp individually to see what happens. > > (require :elephant) > (compile-file > #p"/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" > :verbose t) > > Same thing, abnormal exit 256. I did a lot of fiddling around, but > still can't get it to work. I have no idea what's going on. > > I am using Elephant 0.6.0 and SBCL 0.9.12. > > > -Howard > > > ; compiling file > "/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" > (written 10 MAY 2006 07:42:51 PM): > ; compiling (IN-PACKAGE "SLEEPYCAT") > ; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...)) > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY > ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...) > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY > ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...) > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...) > ; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...) > ; compiling (DEFUN DB-STRERROR ...) > ; compiling (DEFINE-CONDITION DB-ERROR ...) > ; compiling (DEFCONSTANT DB-BTREE ...) > ; compiling (DEFCONSTANT DB-HASH ...) > ; compiling (DEFCONSTANT DB-RECNO ...) > ; compiling (DEFCONSTANT DB-QUEUE ...) > ; compiling (DEFCONSTANT DB-UNKNOWN ...) > ; compiling (DEFCONSTANT DB_AUTO_COMMIT ...) > ; compiling (DEFCONSTANT DB_JOINENV ...) > ; compiling (DEFCONSTANT DB_INIT_CDB ...) > ; compiling (DEFCONSTANT DB_INIT_LOCK ...) > ; compiling (DEFCONSTANT DB_INIT_LOG ...) > ; compiling (DEFCONSTANT DB_INIT_MPOOL ...) > ; compiling (DEFCONSTANT DB_INIT_REP ...) > ; compiling (DEFCONSTANT DB_INIT_TXN ...) > ; compiling (DEFCONSTANT DB_RECOVER ...) > ; compiling (DEFCONSTANT DB_RECOVER_FATAL ...) > ; compiling (DEFCONSTANT DB_LOCKDOWN ...) > ; compiling (DEFCONSTANT DB_PRIVATE ...) > ; compiling (DEFCONSTANT DB_SYSTEM_MEM ...) > ; compiling (DEFCONSTANT DB_THREAD ...) > ; compiling (DEFCONSTANT DB_FORCE ...) > ; compiling (DEFCONSTANT DB_DEGREE_2 ...) > ; compiling (DEFCONSTANT DB_DIRTY_READ ...) > ; compiling (DEFCONSTANT DB_CREATE ...) > ; compiling (DEFCONSTANT DB_EXCL ...) > ; compiling (DEFCONSTANT DB_NOMMAP ...) > ; compiling (DEFCONSTANT DB_RDONLY ...) > ; compiling (DEFCONSTANT DB_TRUNCATE ...) > ; compiling (DEFCONSTANT DB_TXN_NOSYNC ...) > ; compiling (DEFCONSTANT DB_TXN_NOWAIT ...) > ; compiling (DEFCONSTANT DB_TXN_SYNC ...) > ; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...) > ; compiling (DEFCONSTANT DB_DUP ...) > ; compiling (DEFCONSTANT DB_DUPSORT ...) > ; compiling (DEFCONSTANT DB_CURRENT ...) > ; compiling (DEFCONSTANT DB_FIRST ...) > ; compiling (DEFCONSTANT DB_GET_BOTH ...) > ; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...) > ; compiling (DEFCONSTANT DB_LAST ...) > ; compiling (DEFCONSTANT DB_NEXT ...) > ; compiling (DEFCONSTANT DB_NEXT_DUP ...) > ; compiling (DEFCONSTANT DB_NEXT_NODUP ...) > ; compiling (DEFCONSTANT DB_PREV ...) > ; compiling (DEFCONSTANT DB_PREV_NODUP ...) > ; compiling (DEFCONSTANT DB_SET ...) > ; compiling (DEFCONSTANT DB_SET_RANGE ...) > ; compiling (DEFCONSTANT DB_AFTER ...) > ; compiling (DEFCONSTANT DB_BEFORE ...) > ; compiling (DEFCONSTANT DB_KEYFIRST ...) > ; compiling (DEFCONSTANT DB_KEYLAST ...) > ; compiling (DEFCONSTANT DB_NODUPDATA ...) > ; compiling (DEFCONSTANT DB_NOOVERWRITE ...) > ; compiling (DEFCONSTANT DB_NOSYNC ...) > ; compiling (DEFCONSTANT DB_POSITION ...) > ; compiling (DEFCONSTANT DB_SEQ_DEC ...) > ; compiling (DEFCONSTANT DB_SEQ_INC ...) > ; compiling (DEFCONSTANT DB_SEQ_WRAP ...) > ; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...) > ; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...) > ; compiling (DEFCONSTANT DB_KEYEMPTY ...) > ; compiling (DEFCONSTANT DB_KEYEXIST ...) > ; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...) > ; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...) > ; compiling (DEFCONSTANT DB_NOTFOUND ...) > ; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...) > ; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...) > ; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...) > ; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...) > ; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...) > ; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...) > ; compiling (DEFCONSTANT DB_LOCK_OLDEST ...) > ; compiling (DEFCONSTANT DB_LOCK_RANDOM ...) > ; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...) > ; compiling (DEF-ENUM DB-LOCKOP ...) > _______________________________________________ > elephant-devel site list > elephant-devel at common-lisp.net > http://common-lisp.net/mailman/listinfo/elephant-devel From eslick at csail.mit.edu Fri Jun 23 18:51:29 2006 From: eslick at csail.mit.edu (Ian Eslick) Date: Fri, 23 Jun 2006 14:51:29 -0400 Subject: [elephant-devel] SBCL exits abnormally when compiling sleepycat.lisp In-Reply-To: References: Message-ID: <449C3831.7000905@csail.mit.edu> I'm not sure I have a bunch of sage advice for you here. The file appears to compile correctly so it must be either something going on in SBCL 0.9.12 interacting with FFI and/or pthreads/libdb library versions or something else. I can run elephant fine on Linux under Allegro and fine on SBCL under Mac OS X. I won't be able to try this out on a Linux box for a few days... Good luck! Let me know if anything changes and if not, remind me early next week and I'll try the latest SBCL under Linux. I last tested under 0.9.7 on Mac OS X and I believe 0.9.9 on Linux. Cheers, Ian Howard Yeh wrote: > Hi, > > I am trying to get Elephant to work. > > (require :elephant) > (require :elephant-tests) > (in-package "ELEPHANT-TESTS") > (setf *default-spec* *testbdb-spec*) > (do-backend-tests) > > ASDF seems to compile and load :elephant and :elephant-tests ok. > But when I try (do-backend-tests), ASDF tries to compile sleepycat.lisp > and causes SBCL to exit abnormally (code 256). > > Then I tried to compile sleepycat.lisp individually to see what happens. > > (require :elephant) > (compile-file > #p"/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" > :verbose t) > > Same thing, abnormal exit 256. I did a lot of fiddling around, but > still can't get it to work. I have no idea what's going on. > > I am using Elephant 0.6.0 and SBCL 0.9.12. > > > -Howard > > > ; compiling file > "/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" > (written 10 MAY 2006 07:42:51 PM): > ; compiling (IN-PACKAGE "SLEEPYCAT") > ; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...)) > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY > ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...) > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY > ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...) > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...) > ; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...) > ; compiling (DEFUN DB-STRERROR ...) > ; compiling (DEFINE-CONDITION DB-ERROR ...) > ; compiling (DEFCONSTANT DB-BTREE ...) > ; compiling (DEFCONSTANT DB-HASH ...) > ; compiling (DEFCONSTANT DB-RECNO ...) > ; compiling (DEFCONSTANT DB-QUEUE ...) > ; compiling (DEFCONSTANT DB-UNKNOWN ...) > ; compiling (DEFCONSTANT DB_AUTO_COMMIT ...) > ; compiling (DEFCONSTANT DB_JOINENV ...) > ; compiling (DEFCONSTANT DB_INIT_CDB ...) > ; compiling (DEFCONSTANT DB_INIT_LOCK ...) > ; compiling (DEFCONSTANT DB_INIT_LOG ...) > ; compiling (DEFCONSTANT DB_INIT_MPOOL ...) > ; compiling (DEFCONSTANT DB_INIT_REP ...) > ; compiling (DEFCONSTANT DB_INIT_TXN ...) > ; compiling (DEFCONSTANT DB_RECOVER ...) > ; compiling (DEFCONSTANT DB_RECOVER_FATAL ...) > ; compiling (DEFCONSTANT DB_LOCKDOWN ...) > ; compiling (DEFCONSTANT DB_PRIVATE ...) > ; compiling (DEFCONSTANT DB_SYSTEM_MEM ...) > ; compiling (DEFCONSTANT DB_THREAD ...) > ; compiling (DEFCONSTANT DB_FORCE ...) > ; compiling (DEFCONSTANT DB_DEGREE_2 ...) > ; compiling (DEFCONSTANT DB_DIRTY_READ ...) > ; compiling (DEFCONSTANT DB_CREATE ...) > ; compiling (DEFCONSTANT DB_EXCL ...) > ; compiling (DEFCONSTANT DB_NOMMAP ...) > ; compiling (DEFCONSTANT DB_RDONLY ...) > ; compiling (DEFCONSTANT DB_TRUNCATE ...) > ; compiling (DEFCONSTANT DB_TXN_NOSYNC ...) > ; compiling (DEFCONSTANT DB_TXN_NOWAIT ...) > ; compiling (DEFCONSTANT DB_TXN_SYNC ...) > ; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...) > ; compiling (DEFCONSTANT DB_DUP ...) > ; compiling (DEFCONSTANT DB_DUPSORT ...) > ; compiling (DEFCONSTANT DB_CURRENT ...) > ; compiling (DEFCONSTANT DB_FIRST ...) > ; compiling (DEFCONSTANT DB_GET_BOTH ...) > ; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...) > ; compiling (DEFCONSTANT DB_LAST ...) > ; compiling (DEFCONSTANT DB_NEXT ...) > ; compiling (DEFCONSTANT DB_NEXT_DUP ...) > ; compiling (DEFCONSTANT DB_NEXT_NODUP ...) > ; compiling (DEFCONSTANT DB_PREV ...) > ; compiling (DEFCONSTANT DB_PREV_NODUP ...) > ; compiling (DEFCONSTANT DB_SET ...) > ; compiling (DEFCONSTANT DB_SET_RANGE ...) > ; compiling (DEFCONSTANT DB_AFTER ...) > ; compiling (DEFCONSTANT DB_BEFORE ...) > ; compiling (DEFCONSTANT DB_KEYFIRST ...) > ; compiling (DEFCONSTANT DB_KEYLAST ...) > ; compiling (DEFCONSTANT DB_NODUPDATA ...) > ; compiling (DEFCONSTANT DB_NOOVERWRITE ...) > ; compiling (DEFCONSTANT DB_NOSYNC ...) > ; compiling (DEFCONSTANT DB_POSITION ...) > ; compiling (DEFCONSTANT DB_SEQ_DEC ...) > ; compiling (DEFCONSTANT DB_SEQ_INC ...) > ; compiling (DEFCONSTANT DB_SEQ_WRAP ...) > ; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...) > ; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...) > ; compiling (DEFCONSTANT DB_KEYEMPTY ...) > ; compiling (DEFCONSTANT DB_KEYEXIST ...) > ; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...) > ; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...) > ; compiling (DEFCONSTANT DB_NOTFOUND ...) > ; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...) > ; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...) > ; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...) > ; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...) > ; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...) > ; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...) > ; compiling (DEFCONSTANT DB_LOCK_OLDEST ...) > ; compiling (DEFCONSTANT DB_LOCK_RANDOM ...) > ; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...) > ; compiling (DEF-ENUM DB-LOCKOP ...) > _______________________________________________ > elephant-devel site list > elephant-devel at common-lisp.net > http://common-lisp.net/mailman/listinfo/elephant-devel From cjstuij at gmail.com Fri Jun 23 19:53:06 2006 From: cjstuij at gmail.com (Ties Stuij) Date: Fri, 23 Jun 2006 20:53:06 +0100 Subject: [elephant-devel] SBCL exits abnormally when compiling sleepycat.lisp In-Reply-To: <449C3831.7000905@csail.mit.edu> References: <449C3831.7000905@csail.mit.edu> Message-ID: > Good luck! Let me know if anything changes and if not, remind me early > next week and I'll try the latest SBCL under Linux. I last tested under > 0.9.7 on Mac OS X and I believe 0.9.9 on Linux. > > > > I am trying to get Elephant to work. > > > > ASDF seems to compile and load :elephant and :elephant-tests ok. > > But when I try (do-backend-tests), ASDF tries to compile sleepycat.lisp > > and causes SBCL to exit abnormally (code 256). > > For what it?s worth, i had exactly the same problems, under linux with sbcl .9.11 and .9.12. Tried a couple of different configurations including compiling sleepycat from source. All with the same result. greets, Ties From hayeah at gmail.com Fri Jun 23 20:49:06 2006 From: hayeah at gmail.com (Howard Yeh) Date: Fri, 23 Jun 2006 13:49:06 -0700 Subject: [elephant-devel] Re: SBCL exits abnormally when compiling sleepycat.lisp In-Reply-To: <449C3831.7000905@csail.mit.edu> References: <449C3831.7000905@csail.mit.edu> Message-ID: I installed allegro lisp (80) to see if it works. Looks like it has trouble loading pthread? (do-backend-tests) . . . ; Fast loading /home/howard/lisp/libs/elephant/src/db-bdb/package.fasl ;;; Compiling file ;;; /home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp ; Loading /lib/tls/libpthread.so.0 ; While compiling (:TOP-LEVEL-FORM "sleepycat.lisp" 1604): Can't have unescaped whitespace in token. [file position = 1] [Condition of type READER-ERROR] Restarts: 0: [RETRY] retry the load of /lib/tls/libpthread.so.0 1: [SKIP] skip loading /lib/tls/libpthread.so.0 2: [NIL] retry the compilation of /home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp 3: [NIL] continue compiling /home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp but generate no output file 4: [RETRY] Retry performing # on #. 5: [ACCEPT] Continue, treating # on # as having been successful. 6: [ABORT-REQUEST] Abort handling SLIME request. 7: [ABORT] Abort entirely from this (lisp) process. From hayeah at gmail.com Thu Jun 22 18:35:02 2006 From: hayeah at gmail.com (Howard Yeh) Date: Thu, 22 Jun 2006 11:35:02 -0700 Subject: [elephant-devel] Re: SBCL exits abnormally when compiling sleepycat.lisp In-Reply-To: <449ABC41.8020109@csail.mit.edu> References: <449ABC41.8020109@csail.mit.edu> Message-ID: I am using Kubuntu Dapper 6.06. Where my files are at: ---------------------------------------------------------------------- /usr/local/BerkeleyDB.4.3/include: total 0 lrwxrwxrwx 1 root root 17 Jun 21 20:58 db.h -> /usr/include/db.h /usr/local/BerkeleyDB.4.3/lib: total 0 lrwxrwxrwx 1 root root 17 Jun 21 21:10 libdb-4.3.so -> /usr/lib/libdb.so lrwxrwxrwx 1 root root 17 Jun 21 20:58 libdb.so -> /usr/lib/libdb.so lrwxrwxrwx 1 root root 12 Jun 18 02:14 /usr/lib/libdb.so -> libdb-4.3.so ---------------------------------------------------------------------- Warnings I get when make: ---------------------------------------------------------------------- ~/wisp/src/libs/elephant > make bdb gcc -shared -Wall -L/usr/local/BerkeleyDB.4.3//lib/ -I/usr/local/BerkeleyDB.4.3//include/ -fPIC -O3 -o src/db-bdb/libsleepycat.so src/db-bdb/libsleepycat.c -ldb -lm src/db-bdb/libsleepycat.c: In function 'lisp_compare': src/db-bdb/libsleepycat.c:291: warning: implicit declaration of function 'wcs_cmp' src/db-bdb/libsleepycat.c: In function 'db_multiple_key_next': src/db-bdb/libsleepycat.c:721: warning: pointer targets in assignment differ in signedness src/db-bdb/libsleepycat.c:721: warning: pointer targets in assignment differ in signedness ---------------------------------------------------------------------- (require :elephant) (require :elephant-tests) ---------------------------------------------------------------------- Compile Notes at the end of this post under the headings 'require.elephant' and 'require.elephant-tests' ---------------------------------------------------------------------- ~/wisp/src/libs/elephant > ls tests/testdb CVS README (in-package "ELEPHANT-TESTS") (setf *default-spec* *testbdb-spec*) (do-backend-tests) ---------------------------------------------------------------------- (do-backend-tests) ; loading system definition from /home/howard/lisp/libs/asd/ele-bdb.asd ; into # ; registering # as ELE-BDB ; compiling file "/home/howard/lisp/libs/elephant/src/db-bdb/package.lisp" (written 18 FEB 2006 08:53:00 PM): ; compiling (IN-PACKAGE :CL-USER) ; compiling (DEFPACKAGE SLEEPYCAT ...) ---------------------------------------------------------------------- Then SBCL exits abnormally. Try again with the compiled .fasl ---------------------------------------------------------------------- CL-USER> (require :elephant) ; loading system definition from /home/howard/lisp/libs/asd/uffi.asd into ; # ; registering # as UFFI ; loading system definition from /home/howard/lisp/libs/asd/cl-base64.asd ; into # ; registering # as CL-BASE64 ; registering # as CL-BASE64-TESTS ; loading system definition from /home/howard/lisp/libs/asd/kmrcl.asd into ; # ; registering # as KMRCL NIL CL-USER> (require :elephant-tests) ; loading system definition from /home/howard/lisp/libs/asd/rt.asd into ; # ; registering # as RT NIL CL-USER> (in-package "ELEPHANT-TESTS") # ELE-TESTS> (setf *default-spec* *testbdb-spec*) (:BDB "/home/howard/lisp/libs/elephant/tests/testdb/") ELE-TESTS> (do-backend-tests) ; loading system definition from /home/howard/lisp/libs/asd/ele-bdb.asd ; into # ; registering # as ELE-BDB ; compiling file "/home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE "SLEEPYCAT") ; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...)) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...) ; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...) ; compiling (DEFUN DB-STRERROR ...) ; compiling (DEFINE-CONDITION DB-ERROR ...) ; compiling (DEFCONSTANT DB-BTREE ...) ; compiling (DEFCONSTANT DB-HASH ...) ; compiling (DEFCONSTANT DB-RECNO ...) ; compiling (DEFCONSTANT DB-QUEUE ...) ; compiling (DEFCONSTANT DB-UNKNOWN ...) ; compiling (DEFCONSTANT DB_AUTO_COMMIT ...) ; compiling (DEFCONSTANT DB_JOINENV ...) ; compiling (DEFCONSTANT DB_INIT_CDB ...) ; compiling (DEFCONSTANT DB_INIT_LOCK ...) ; compiling (DEFCONSTANT DB_INIT_LOG ...) ; compiling (DEFCONSTANT DB_INIT_MPOOL ...) ; compiling (DEFCONSTANT DB_INIT_REP ...) ; compiling (DEFCONSTANT DB_INIT_TXN ...) ; compiling (DEFCONSTANT DB_RECOVER ...) ; compiling (DEFCONSTANT DB_RECOVER_FATAL ...) ; compiling (DEFCONSTANT DB_LOCKDOWN ...) ; compiling (DEFCONSTANT DB_PRIVATE ...) ; compiling (DEFCONSTANT DB_SYSTEM_MEM ...) ; compiling (DEFCONSTANT DB_THREAD ...) ; compiling (DEFCONSTANT DB_FORCE ...) ; compiling (DEFCONSTANT DB_DEGREE_2 ...) ; compiling (DEFCONSTANT DB_DIRTY_READ ...) ; compiling (DEFCONSTANT DB_CREATE ...) ; compiling (DEFCONSTANT DB_EXCL ...) ; compiling (DEFCONSTANT DB_NOMMAP ...) ; compiling (DEFCONSTANT DB_RDONLY ...) ; compiling (DEFCONSTANT DB_TRUNCATE ...) ; compiling (DEFCONSTANT DB_TXN_NOSYNC ...) ; compiling (DEFCONSTANT DB_TXN_NOWAIT ...) ; compiling (DEFCONSTANT DB_TXN_SYNC ...) ; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...) ; compiling (DEFCONSTANT DB_DUP ...) ; compiling (DEFCONSTANT DB_DUPSORT ...) ; compiling (DEFCONSTANT DB_CURRENT ...) ; compiling (DEFCONSTANT DB_FIRST ...) ; compiling (DEFCONSTANT DB_GET_BOTH ...) ; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...) ; compiling (DEFCONSTANT DB_LAST ...) ; compiling (DEFCONSTANT DB_NEXT ...) ; compiling (DEFCONSTANT DB_NEXT_DUP ...) ; compiling (DEFCONSTANT DB_NEXT_NODUP ...) ; compiling (DEFCONSTANT DB_PREV ...) ; compiling (DEFCONSTANT DB_PREV_NODUP ...) ; compiling (DEFCONSTANT DB_SET ...) ; compiling (DEFCONSTANT DB_SET_RANGE ...) ; compiling (DEFCONSTANT DB_AFTER ...) ; compiling (DEFCONSTANT DB_BEFORE ...) ; compiling (DEFCONSTANT DB_KEYFIRST ...) ; compiling (DEFCONSTANT DB_KEYLAST ...) ; compiling (DEFCONSTANT DB_NODUPDATA ...) ; compiling (DEFCONSTANT DB_NOOVERWRITE ...) ; compiling (DEFCONSTANT DB_NOSYNC ...) ; compiling (DEFCONSTANT DB_POSITION ...) ; compiling (DEFCONSTANT DB_SEQ_DEC ...) ; compiling (DEFCONSTANT DB_SEQ_INC ...) ; compiling (DEFCONSTANT DB_SEQ_WRAP ...) ; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...) ; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...) ; compiling (DEFCONSTANT DB_KEYEMPTY ...) ; compiling (DEFCONSTANT DB_KEYEXIST ...) ; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...) ; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...) ; compiling (DEFCONSTANT DB_NOTFOUND ...) ; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...) ; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...) ; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...) ; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...) ; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...) ; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...) ; compiling (DEFCONSTANT DB_LOCK_OLDEST ...) ; compiling (DEFCONSTANT DB_LOCK_RANDOM ...) ; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...) ; compiling (DEF-ENUM DB-LOCKOP ...) ; compiling (DEF-ENUM DB-LOCKMODE ...) ; compiling (DEF-STRUCT DB-LOCK ...) ; compiling (DEF-STRUCT DB-LOCKREQ ...) ; compiling (DEFCONSTANT +2^32+ ...) ; compiling (DEFCONSTANT +2^64+ ...) ; compiling (DEFCONSTANT +2^32-1+ ...) ; compiling (DEFMACRO MAKE-64-BIT-INTEGER ...) ; compiling (DEFMACRO HIGH32 ...) ; compiling (DEFMACRO LOW32 ...) ; compiling (DEFMACRO SPLIT-64-BIT-INTEGER ...) ; compiling (DEFVAR *ERRNO-BUFFER* ...) ; file: /home/howard/lisp/libs/elephant/src/db-bdb/sleepycat.lisp ; in: DEFVAR *ERRNO-BUFFER* ; (UFFI:ALLOCATE-FOREIGN-OBJECT :INT 1) ; --> MAKE-ALIEN ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-ALIEN::%MAKE-ALIEN (* 32 1)) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ---------------------------------------------------------------------- SBCL exits. There was once I somehow managed to compile sleepycat without SBCL dying. But that time SBCL died when compiling bdb-controller.lisp. Sorry I can't give any more intelligent description. -Howard **************************************** Compiled Notes **************************************** (require :elephant) ; loading system definition from /home/howard/lisp/libs/asd/uffi.asd into ; # ; registering # as UFFI ; compiling file "/home/howard/lisp/libs/elephant/src/memutil/memutil.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (DEFPACKAGE ELEPHANT-MEMUTIL ...) ; compiling (IN-PACKAGE "ELEPHANT-MEMUTIL") ; compiling (DEFPARAMETER *C-LIBRARY-EXTENSION* ...) ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...) ; compiling (DEF-TYPE POINTER-INT ...) ; compiling (DEF-TYPE POINTER-VOID ...) ; compiling (DEF-FOREIGN-TYPE ARRAY-OR-POINTER-CHAR ...) ; compiling (DEF-TYPE ARRAY-OR-POINTER-CHAR ...) ; compiling (DEF-FUNCTION ("copy_buf" COPY-BUFS) ...) ; compiling (DECLAIM (INLINE READ-INT ...)) ; compiling (DEFVAR +NULL-VOID+ ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFVAR +NULL-VOID+ ; (UFFI:MAKE-NULL-POINTER :VOID) ; --> SAP-ALIEN ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-SYS:INT-SAP 0) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ; compiling (DEFVAR +NULL-CHAR+ ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFVAR +NULL-CHAR+ ; (UFFI:MAKE-NULL-POINTER :CHAR) ; --> SAP-ALIEN ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-SYS:INT-SAP 0) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ; compiling (DEFVAR *BUFFER-STREAMS* ...) ; compiling (DEFSTRUCT BUFFER-STREAM ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFSTRUCT BUFFER-STREAM ; (UFFI:ALLOCATE-FOREIGN-OBJECT :CHAR 10) ; --> MAKE-ALIEN ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN (SB-ALIEN::%MAKE-ALIEN (* 8 10)) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ; compiling (DEFUN GRAB-BUFFER-STREAM ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN GRAB-BUFFER-STREAM ; (LENGTH ELEPHANT-MEMUTIL::*BUFFER-STREAMS*) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; compiling (DEFUN RETURN-BUFFER-STREAM ...) ; compiling (DEFMACRO WITH-BUFFER-STREAMS ...) ; compiling (DEFUN READ-INT ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN READ-INT ; (DEFUN ELEPHANT-MEMUTIL::READ-INT ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; "Read a 32-bit signed integer from a foreign char buffer." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (THE (SIGNED-BYTE 32) (DEREF (CAST (SAP-ALIEN # #) (* INTEGER))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-INT ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (BLOCK ELEPHANT-MEMUTIL::READ-INT ; (THE (SIGNED-BYTE 32) (DEREF (CAST # #))))) ; ; note: doing signed word to integer coercion (cost 20) to "" ; compiling (DEFUN READ-UINT ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN READ-UINT ; (DEFUN ELEPHANT-MEMUTIL::READ-UINT ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; "Read a 32-bit unsigned integer from a foreign char buffer." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (THE (UNSIGNED-BYTE 32) (DEREF (CAST (SAP-ALIEN # #) (* #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-UINT ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (BLOCK ELEPHANT-MEMUTIL::READ-UINT ; (THE (UNSIGNED-BYTE 32) (DEREF (CAST # #))))) ; ; note: doing unsigned word to integer coercion (cost 20) to "" ; compiling (DEFUN READ-FLOAT ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN READ-FLOAT ; (DEFUN ELEPHANT-MEMUTIL::READ-FLOAT ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; "Read a single-float from a foreign char buffer." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (THE SINGLE-FLOAT (DEREF (CAST (SAP-ALIEN # #) (* SINGLE-FLOAT))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-FLOAT ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (BLOCK ELEPHANT-MEMUTIL::READ-FLOAT ; (THE SINGLE-FLOAT (DEREF (CAST # #))))) ; ; note: doing float to pointer coercion (cost 13) to "" ; compiling (DEFUN READ-DOUBLE ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN READ-DOUBLE ; (DEFUN ELEPHANT-MEMUTIL::READ-DOUBLE ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; "Read a double-float from a foreign char buffer." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (THE DOUBLE-FLOAT (DEREF (CAST (SAP-ALIEN # #) (* DOUBLE-FLOAT))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL::READ-DOUBLE ; (ELEPHANT-MEMUTIL::BUF ELEPHANT-MEMUTIL::OFFSET) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE (ALIEN (* CHAR)) ELEPHANT-MEMUTIL::BUF) ; (TYPE FIXNUM ELEPHANT-MEMUTIL::OFFSET)) ; (BLOCK ELEPHANT-MEMUTIL::READ-DOUBLE ; (THE DOUBLE-FLOAT (DEREF (CAST # #))))) ; ; note: doing float to pointer coercion (cost 13) to "" ; compiling (DEFUN WRITE-INT ...) ; compiling (DEFUN WRITE-UINT ...) ; compiling (DEFUN WRITE-FLOAT ...) ; compiling (DEFUN WRITE-DOUBLE ...) ; compiling (DEFUN OFFSET-CHAR-POINTER ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN OFFSET-CHAR-POINTER ; (SAP-ALIEN ; (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::P) ELEPHANT-MEMUTIL::OFFSET) ; (* CHAR)) ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN ; (SB-SYS:SAP+ (ALIEN-SAP ELEPHANT-MEMUTIL::P) ELEPHANT-MEMUTIL::OFFSET) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ; ; note: doing SAP to pointer coercion (cost 20) ; compiling (DEFMACRO BYTE-LENGTH ...) ; compiling (DEF-FUNCTION ("copy_buf" %COPY-STR-TO-BUF) ...) ; compiling (DEFUN COPY-STR-TO-BUF ...) ; compiling (DEFUN PROCESS-STRUCT-SLOT-DEFS ...) ; compiling (DEFMACRO WITH-STRUCT-SLOTS ...) ; compiling (DEFUN RESIZE-BUFFER-STREAM ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN RESIZE-BUFFER-STREAM ; (UFFI:ALLOCATE-FOREIGN-OBJECT :CHAR ELEPHANT-MEMUTIL::NEWLEN) ; --> MAKE-ALIEN ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN ; (SB-ALIEN::%MAKE-ALIEN (* 8 ELEPHANT-MEMUTIL::NEWLEN)) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ; ; note: doing SAP to pointer coercion (cost 20) ; compiling (DEFUN RESIZE-BUFFER-STREAM-NO-COPY ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN RESIZE-BUFFER-STREAM-NO-COPY ; (UFFI:ALLOCATE-FOREIGN-OBJECT :CHAR ELEPHANT-MEMUTIL::NEWLEN) ; --> MAKE-ALIEN ; ==> ; (SB-ALIEN-INTERNALS:%SAP-ALIEN ; (SB-ALIEN::%MAKE-ALIEN (* 8 ELEPHANT-MEMUTIL::NEWLEN)) ; '#) ; ; note: unable to ; optimize ; because: ; could not optimize away %SAP-ALIEN: forced to do runtime ; allocation of alien-value structure ; ; note: doing SAP to pointer coercion (cost 20) ; compiling (DEFUN RESET-BUFFER-STREAM ...) ; compiling (DEFUN BUFFER-WRITE-BYTE ...) ; compiling (DEFUN BUFFER-WRITE-INT ...) ; compiling (DEFUN BUFFER-WRITE-UINT ...) ; compiling (DEFUN BUFFER-WRITE-FLOAT ...) ; compiling (DEFUN BUFFER-WRITE-DOUBLE ...) ; compiling (DEFUN BUFFER-WRITE-STRING ...) ; compiling (DEFUN BUFFER-READ-BYTE ...) ; compiling (DEFUN BUFFER-READ-BYTE-VECTOR ...) ; compiling (DEFUN BUFFER-WRITE-BYTE-VECTOR ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN BUFFER-WRITE-BYTE-VECTOR ; (LENGTH ELEPHANT-MEMUTIL::BV) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (AREF ELEPHANT-MEMUTIL::BV ELEPHANT-MEMUTIL::I) ; --> LET* ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; compiling (DEFUN BUFFER-READ-FIXNUM ...) ; compiling (DEFUN BUFFER-READ-INT ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN BUFFER-READ-INT ; (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-INT (ELEPHANT-MEMUTIL::BS) ; "Read a 32-bit signed integer." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS)) ; (LET ((POSITION ; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS))) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS) ; (+ POSITION 4)) ; (THE (SIGNED-BYTE 32) ; (ELEPHANT-MEMUTIL::READ-INT ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS) ; POSITION)))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-INT ; (ELEPHANT-MEMUTIL::BS) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ; ELEPHANT-MEMUTIL::BS)) ; (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-INT ; (LET ((POSITION #)) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ; ELEPHANT-MEMUTIL::BS) ; (+ POSITION 4)) ; (THE (SIGNED-BYTE 32) ; (ELEPHANT-MEMUTIL::READ-INT # POSITION))))) ; ; note: doing signed word to integer coercion (cost 20) to "" ; compiling (DEFUN BUFFER-READ-UINT ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN BUFFER-READ-UINT ; (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-UINT (ELEPHANT-MEMUTIL::BS) ; "Read a 32-bit unsigned integer." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS)) ; (LET ((POSITION ; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS))) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS) ; (+ POSITION 4)) ; (THE (UNSIGNED-BYTE 32) ; (ELEPHANT-MEMUTIL::READ-UINT ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS) ; POSITION)))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-UINT ; (ELEPHANT-MEMUTIL::BS) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ; ELEPHANT-MEMUTIL::BS)) ; (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-UINT ; (LET ((POSITION #)) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ; ELEPHANT-MEMUTIL::BS) ; (+ POSITION 4)) ; (THE (UNSIGNED-BYTE 32) ; (ELEPHANT-MEMUTIL::READ-UINT # POSITION))))) ; ; note: doing unsigned word to integer coercion (cost 20) to "" ; compiling (DEFUN BUFFER-READ-FLOAT ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN BUFFER-READ-FLOAT ; (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT (ELEPHANT-MEMUTIL::BS) ; "Read a single-float." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS)) ; (LET ((POSITION ; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS))) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS) ; (+ POSITION 4)) ; (ELEPHANT-MEMUTIL::READ-FLOAT ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS) ; POSITION))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT ; (ELEPHANT-MEMUTIL::BS) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ; ELEPHANT-MEMUTIL::BS)) ; (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT ; (LET ((POSITION #)) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ; ELEPHANT-MEMUTIL::BS) ; (+ POSITION 4)) ; (ELEPHANT-MEMUTIL::READ-FLOAT ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ; ELEPHANT-MEMUTIL::BS) ; POSITION)))) ; ; note: doing float to pointer coercion (cost 13) to "" ; compiling (DEFUN BUFFER-READ-DOUBLE ...) ; file: /home/howard/lisp/libs/elephant/src/memutil/memutil.lisp ; in: DEFUN BUFFER-READ-DOUBLE ; (DEFUN ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE (ELEPHANT-MEMUTIL::BS) ; "Read a double-float." ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ELEPHANT-MEMUTIL::BS)) ; (LET ((POSITION ; (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS))) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ELEPHANT-MEMUTIL::BS) ; (+ POSITION 8)) ; (ELEPHANT-MEMUTIL::READ-DOUBLE ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS) ; POSITION))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA ; ==> ; #'(SB-INT:NAMED-LAMBDA ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE ; (ELEPHANT-MEMUTIL::BS) ; (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)) ; (TYPE ELEPHANT-MEMUTIL:BUFFER-STREAM ; ELEPHANT-MEMUTIL::BS)) ; (BLOCK ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE ; (LET ((POSITION #)) ; (SETF (ELEPHANT-MEMUTIL::BUFFER-STREAM-POSITION ; ELEPHANT-MEMUTIL::BS) ; (+ POSITION 8)) ; (ELEPHANT-MEMUTIL::READ-DOUBLE ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ; ELEPHANT-MEMUTIL::BS) ; POSITION)))) ; ; note: doing float to pointer coercion (cost 13) to "" ; compiling (DEFUN BUFFER-READ-UCS1-STRING ...) ; compiling (DEFUN BUFFER-READ-UCS4-STRING ...) ; /home/howard/lisp/libs/elephant/src/memutil/memutil.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/package.lisp" (written 26 APR 2006 10:53:44 AM): ; compiling (IN-PACKAGE :CL-USER) ; compiling (DEFPACKAGE ELEPHANT ...) ; compiling (IN-PACKAGE "ELE") ; /home/howard/lisp/libs/elephant/src/elephant/package.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/config.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE :ELEPHANT) ; compiling (DEFPARAMETER *CLSQL-FOREIGN-LIB-PATH* ...) ; compiling (DEFPARAMETER *SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ; compiling (DEFPARAMETER *SLEEPYCAT-PTHREADS-PATH* ...) ; /home/howard/lisp/libs/elephant/src/elephant/../../config.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/variables.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DECLAIM (TYPE FIXNUM ...) ...) ; compiling (DEFVAR *CACHESIZE* ...) ; compiling (DEFVAR *ELEPHANT-CODE-VERSION* ...) ; compiling (DEFVAR *ELEPHANT-UNMARKED-CODE-VERSION* ...) ; compiling (DEFVAR *ELEPHANT-PROPERTIES-LABEL* ...) ; compiling (DEFPARAMETER *STORE-CONTROLLER* ...) ; compiling (DEFVAR *AUTO-COMMIT* ...) ; compiling (DEFVAR *TRANSACTION-STACK* ...) ; compiling (DEFVAR *CURRENT-TRANSACTION* ...) ; compiling (DEFVAR *LISP-OBJ-ID* ...) ; compiling (DEFVAR *CIRCULARITY-HASH* ...) ; compiling (DEFVAR *RESOURCED-BYTE-SPEC* ...) ; compiling (DEFUN REMOVE-INDEXED-ELEMENT-AND-ADJUST ...) ; /home/howard/lisp/libs/elephant/src/elephant/variables.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/transactions.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFGENERIC EXECUTE-TRANSACTION ...) ; compiling (DEFMACRO WITH-TRANSACTION ...) ; compiling (DEFGENERIC CONTROLLER-START-TRANSACTION ...) ; compiling (DEFGENERIC CONTROLLER-COMMIT-TRANSACTION ...) ; compiling (DEFGENERIC CONTROLLER-ABORT-TRANSACTION ...) ; compiling (DEFUN START-ELE-TRANSACTION ...) ; compiling (DEFUN COMMIT-TRANSACTION ...) ; compiling (DEFUN ABORT-TRANSACTION ...) ; /home/howard/lisp/libs/elephant/src/elephant/transactions.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/metaclasses.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFCLASS PERSISTENT ...) ; compiling (DEFCLASS PERSISTENT-METACLASS ...) ; compiling (DEFMACRO DEFPCLASS ...) ; compiling (DEFUN ADD-PERSISTENT-METACLASS-ARGUMENT ...) ; compiling (DEFMETHOD PERSISTENT-SLOTS ...) ; compiling (DEFMETHOD PERSISTENT-SLOTS ...) ; compiling (DEFMETHOD OLD-PERSISTENT-SLOTS ...) ; compiling (DEFMETHOD UPDATE-PERSISTENT-SLOTS ...) ; compiling (DEFCLASS PERSISTENT-SLOT-DEFINITION ...) ; compiling (DEFCLASS PERSISTENT-DIRECT-SLOT-DEFINITION ...) ; compiling (DEFCLASS PERSISTENT-EFFECTIVE-SLOT-DEFINITION ...) ; compiling (DEFCLASS TRANSIENT-SLOT-DEFINITION ...) ; compiling (DEFCLASS TRANSIENT-DIRECT-SLOT-DEFINITION ...) ; compiling (DEFCLASS TRANSIENT-EFFECTIVE-SLOT-DEFINITION ...) ; compiling (DEFGENERIC TRANSIENT ...) ; compiling (DEFMETHOD TRANSIENT ...) ; compiling (DEFMETHOD TRANSIENT ...) ; compiling (DEFCLASS INDEXING-RECORD ...) ; compiling (DEFMETHOD PRINT-OBJECT ...) ; compiling (DEFMETHOD INDEXED-RECORD ...) ; compiling (DEFMETHOD INDEXED-RECORD ...) ; compiling (DEFMETHOD OLD-INDEXED-RECORD ...) ; compiling (DEFMETHOD UPDATE-INDEXED-RECORD ...) ; compiling (DEFMETHOD MAKE-NEW-INDEXED-RECORD ...) ; compiling (DEFMETHOD REMOVED-INDEXING? ...) ; compiling (DEFUN INDEXED-SLOT-NAMES-FROM-DEFS ...) ; compiling (DEFMETHOD REGISTER-INDEXED-SLOT ...) ; compiling (DEFMETHOD UNREGISTER-INDEXED-SLOT ...) ; compiling (DEFMETHOD REGISTER-DERIVED-INDEX ...) ; compiling (DEFMETHOD UNREGISTER-DERIVED-INDEX ...) ; compiling (DEFMETHOD INDEXED ...) ; compiling (DEFMETHOD PREVIOUSLY-INDEXED ...) ; compiling (DEFMETHOD INDEXED ...) ; compiling (DEFMETHOD INDEXED ...) ; compiling (DEFVAR *INHIBIT-INDEXING-LIST* ...) ; compiling (DEFUN INHIBIT-INDEXING ...) ; compiling (DEFUN UNINHIBIT-INDEXING ...) ; compiling (DEFMETHOD SLOT-DEFINITION-ALLOCATION ...) ; compiling (DEFMETHOD DIRECT-SLOT-DEFINITION-CLASS ...) ; compiling (DEFMETHOD VALIDATE-SUPERCLASS ...) ; compiling (DEFMETHOD VALIDATE-SUPERCLASS ...) ; compiling (DEFGENERIC PERSISTENT-P ...) ; compiling (DEFMETHOD PERSISTENT-P ...) ; compiling (DEFMETHOD PERSISTENT-P ...) ; compiling (DEFMETHOD PERSISTENT-P ...) ; compiling (DEFMETHOD EFFECTIVE-SLOT-DEFINITION-CLASS ...) ; compiling (DEFUN ENSURE-TRANSIENT-CHAIN ...) ; compiling (DEFMETHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS ...) ; compiling (DEFUN FIND-SLOT-DEF-BY-NAME ...) ; compiling (DEFUN PERSISTENT-SLOT-DEFS ...) ; compiling (DEFUN TRANSIENT-SLOT-DEFS ...) ; compiling (DEFUN PERSISTENT-SLOT-NAMES ...) ; compiling (DEFUN TRANSIENT-SLOT-NAMES ...) ; /home/howard/lisp/libs/elephant/src/elephant/metaclasses.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/classes.lisp" (written 26 APR 2006 06:43:53 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFVAR *DEBUG-SI* ...) ; compiling (DEFMETHOD INITIALIZE-INSTANCE ...) ; compiling (DEFCLASS PERSISTENT-OBJECT ...) ; compiling (DEFMETHOD ENSURE-CLASS-USING-CLASS ...) ; compiling (DEFMETHOD ENSURE-CLASS-USING-CLASS ...) ; compiling (DEFUN REMOVE-INDEX-KEYWORD ...) ; compiling (DEFMETHOD SHARED-INITIALIZE ...) ; compiling (DEFMETHOD FINALIZE-INHERITANCE ...) ; compiling (DEFMETHOD REINITIALIZE-INSTANCE ...) ; compiling (DEFMETHOD SHARED-INITIALIZE ...) ; compiling (DEFUN INITIALIZE-PERSISTENT-SLOTS ...) ; compiling (DEFMETHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS ...) ; compiling (DEFMETHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS ...) ; compiling (DEFMETHOD SLOT-VALUE-USING-CLASS ...) ; compiling (DEFMETHOD (SETF SLOT-VALUE-USING-CLASS) ...) ; compiling (DEFMETHOD SLOT-BOUNDP-USING-CLASS ...) ; compiling (DEFMETHOD SLOT-BOUNDP-USING-CLASS ...) ; compiling (DEFMETHOD SLOT-MAKUNBOUND-USING-CLASS ...) ; compiling (DEFUN MAKE-PERSISTENT-READER ...) ; compiling (DEFUN MAKE-PERSISTENT-WRITER ...) ; compiling (DEFUN MAKE-PERSISTENT-SLOT-BOUNDP ...) ; compiling (DEFMETHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS ...) ; /home/howard/lisp/libs/elephant/src/elephant/classes.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/serializer.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DECLAIM (INLINE INT-BYTE-SPEC ...)) ; compiling (UFFI:DEF-TYPE FOREIGN-CHAR ...) ; compiling (DEFCONSTANT +FIXNUM+ ...) ; compiling (DEFCONSTANT +CHAR+ ...) ; compiling (DEFCONSTANT +SINGLE-FLOAT+ ...) ; compiling (DEFCONSTANT +DOUBLE-FLOAT+ ...) ; compiling (DEFCONSTANT +NEGATIVE-BIGNUM+ ...) ; compiling (DEFCONSTANT +POSITIVE-BIGNUM+ ...) ; compiling (DEFCONSTANT +RATIONAL+ ...) ; compiling (DEFCONSTANT +NIL+ ...) ; compiling (DEFCONSTANT +UCS1-SYMBOL+ ...) ; compiling (DEFCONSTANT +UCS1-STRING+ ...) ; compiling (DEFCONSTANT +UCS1-PATHNAME+ ...) ; compiling (DEFCONSTANT +UCS2-SYMBOL+ ...) ; compiling (DEFCONSTANT +UCS2-STRING+ ...) ; compiling (DEFCONSTANT +UCS2-PATHNAME+ ...) ; compiling (DEFCONSTANT +UCS4-SYMBOL+ ...) ; compiling (DEFCONSTANT +UCS4-STRING+ ...) ; compiling (DEFCONSTANT +UCS4-PATHNAME+ ...) ; compiling (DEFCONSTANT +PERSISTENT+ ...) ; compiling (DEFCONSTANT +CONS+ ...) ; compiling (DEFCONSTANT +HASH-TABLE+ ...) ; compiling (DEFCONSTANT +OBJECT+ ...) ; compiling (DEFCONSTANT +ARRAY+ ...) ; compiling (DEFCONSTANT +FILL-POINTER-P+ ...) ; compiling (DEFCONSTANT +ADJUSTABLE-P+ ...) ; compiling (DEFUN CLEAR-CIRCULARITY-HASH ...) ; compiling (DEFUN SERIALIZE ...) ; file: /home/howard/lisp/libs/elephant/src/elephant/serializer.lisp ; in: DEFUN SERIALIZE ; (CEILING (/ (INTEGER-LENGTH ELEPHANT::NUM) 32)) ; ==> ; (CEILING (/ (INTEGER-LENGTH ELEPHANT::NUM) 32) 1) ; ; note: unable to ; convert division by 2^k to shift ; due to type uncertainty: ; The first argument is a (RATIONAL 0 536870911/32), not a INTEGER. ; (LENGTH ELEPHANT::SVS) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (ARRAY-RANK ELEPHANT::FROB) ; ; note: unable to optimize because: The array rank is not known at compile time: * ; (ARRAY-TOTAL-SIZE ELEPHANT::FROB) ; ; note: unable to optimize because: can't tell the rank at compile time ; (ROW-MAJOR-AREF ELEPHANT::FROB ELEPHANT::I) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY ; (SB-KERNEL:%CHECK-BOUND ARRAY ; (ARRAY-TOTAL-SIZE ; ARRAY) ; SB-INT:INDEX)) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a ARRAY, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; (ARRAY-DIMENSION ELEPHANT::FROB ELEPHANT::I) ; ; note: unable to optimize because: The axis is not constant. ; (ABS ELEPHANT::FROB) ; --> IF ; ==> ; (< SB-C::X 0) ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 3) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; --> IF - ; ==> ; (SB-KERNEL:%NEGATE SB-C::X) ; ; note: forced to do GENERIC-NEGATE (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a (INTEGER * -1), not a FIXNUM. ; The result is a (VALUES (INTEGER 1) ; &OPTIONAL), not a (VALUES FIXNUM &REST T). ; unable to do inline (signed-byte 32) arithmetic (cost 2) because: ; The first argument is a (INTEGER * -1), not a (SIGNED-BYTE 32). ; The result is a (VALUES (INTEGER 1) ; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) ; &REST ; T). ; (INTEGER-LENGTH ELEPHANT::NUM) ; ; note: forced to do full call ; unable to do inline (unsigned-byte 32) integer-length (cost 26) because: ; The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32). ; (< ELEPHANT::FROB 0) ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 3) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a INTEGER, not a FIXNUM. ; etc. ; (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE ELEPHANT::FROB)) ; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB) ; ELEPHANT::+FILL-POINTER-P+ ; 0) ; (IF (ADJUSTABLE-ARRAY-P ELEPHANT::FROB) ELEPHANT::+ADJUSTABLE-P+ 0)) ; --> LOGIOR ; ==> ; (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE ELEPHANT::FROB)) ; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB) ; ELEPHANT::+FILL-POINTER-P+ ; 0)) ; ; note: forced to do static-fun Two-arg-ior (cost 53) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T). ; unable to do inline (signed-byte 32) arithmetic (cost 3) because: ; The first argument is a INTEGER, not a (SIGNED-BYTE 32). ; The result is a (VALUES INTEGER ; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) ; &REST ; T). ; etc. ; ==> ; (LOGIOR ; (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE ELEPHANT::FROB)) ; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB) ; ELEPHANT::+FILL-POINTER-P+ ; 0)) ; (IF (ADJUSTABLE-ARRAY-P ELEPHANT::FROB) ELEPHANT::+ADJUSTABLE-P+ 0)) ; ; note: forced to do static-fun Two-arg-ior (cost 53) ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a INTEGER, not a FIXNUM. ; unable to do inline (signed-byte 32) arithmetic (cost 3) because: ; The first argument is a INTEGER, not a (SIGNED-BYTE 32). ; etc. ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::FROB ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+FIXNUM+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+NIL+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT::S) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ; (ETYPECASE ELEPHANT::S ; (BASE-STRING ELEPHANT::+UCS1-SYMBOL+) ; (STRING ELEPHANT::+UCS4-SYMBOL+)) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-FLOAT ELEPHANT::FROB ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+SINGLE-FLOAT+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-DOUBLE ELEPHANT::FROB ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+DOUBLE-FLOAT+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT (CHAR-CODE ELEPHANT::FROB) ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+CHAR+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+RATIONAL+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+CONS+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (FILL-POINTER ELEPHANT::FROB) ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ; (ARRAY-DIMENSION ELEPHANT::FROB ELEPHANT::I) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::RANK ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ; (LOGIOR (ELEPHANT::BYTE-FROM-ARRAY-TYPE (ARRAY-ELEMENT-TYPE ELEPHANT::FROB)) ; (IF (ARRAY-HAS-FILL-POINTER-P ELEPHANT::FROB) ; ELEPHANT::+FILL-POINTER-P+ ; 0) ; (IF (ADJUSTABLE-ARRAY-P ELEPHANT::FROB) ELEPHANT::+ADJUSTABLE-P+ 0)) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+ARRAY+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+OBJECT+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::IDP ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT::%SERIALIZE (HASH-TABLE-REHASH-THRESHOLD ELEPHANT::FROB)) ; ; note: doing float to pointer coercion (cost 13) to FROB ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (INCF ELEPHANT::*LISP-OBJ-ID*) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+HASH-TABLE+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-UINT ; (SB-BIGNUM:%BIGNUM-REF ELEPHANT::NUM ELEPHANT::I) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ELEPHANT::NEEDED ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+NEGATIVE-BIGNUM+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+POSITIVE-BIGNUM+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT::S) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ; (ETYPECASE ELEPHANT::S ; (BASE-STRING ELEPHANT::+UCS1-PATHNAME+) ; (STRING ELEPHANT::+UCS4-PATHNAME+)) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT (ELEPHANT::OID ELEPHANT::FROB) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ELEPHANT::+PERSISTENT+ ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-INT ; (ELEPHANT-MEMUTIL:BYTE-LENGTH ELEPHANT::FROB) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; (ELEPHANT-MEMUTIL:BUFFER-WRITE-BYTE ; (ETYPECASE ELEPHANT::FROB ; (BASE-STRING ELEPHANT::+UCS1-STRING+) ; (STRING ELEPHANT::+UCS4-STRING+)) ; ELEPHANT::BS) ; --> BLOCK ELEPHANT-MEMUTIL::WITH-STRUCT-SLOTS SYMBOL-MACROLET LET WHEN ; --> COND IF PROGN ; ==> ; (ELEPHANT-MEMUTIL:RESIZE-BUFFER-STREAM ELEPHANT-MEMUTIL::BS ; ELEPHANT-MEMUTIL::NEEDED) ; ; note: doing signed word to integer coercion (cost 20) ; compiling (DEFUN SLOTS-AND-VALUES ...) ; compiling (DEFUN DESERIALIZE ...) ; file: /home/howard/lisp/libs/elephant/src/elephant/serializer.lisp ; in: DEFUN DESERIALIZE ; (OR ; (ELEPHANT-MEMUTIL:BUFFER-READ-UCS1-STRING ELEPHANT::BS ; (ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM ; ELEPHANT::BS)) ; "") ; --> LET IF OR ; ==> ; "" ; ; note: deleting unreachable code ; (OR ; (ELEPHANT-MEMUTIL:BUFFER-READ-UCS4-STRING ELEPHANT::BS ; (ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM ; ELEPHANT::BS)) ; "") ; --> LET IF OR ; ==> ; "" ; ; note: deleting unreachable code ; (MAKE-ARRAY ; (LOOP ELEPHANT::FOR ; ELEPHANT::I ; FIXNUM ; ELEPHANT::FROM ; 0 ; ELEPHANT::BELOW ; (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS) ; ELEPHANT::COLLECT ; (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS)) ; :ELEMENT-TYPE ; (ELEPHANT::ARRAY-TYPE-FROM-BYTE (LOGAND 63 ELEPHANT::FLAGS)) ; :FILL-POINTER ; (/= 0 (LOGAND ELEPHANT::+FILL-POINTER-P+ ELEPHANT::FLAGS)) ; :ADJUSTABLE ; (/= 0 (LOGAND ELEPHANT::+ADJUSTABLE-P+ ELEPHANT::FLAGS))) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR (MOD 536870911) CONS NULL), not a INTEGER. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR (MOD 536870911) CONS NULL), not a LIST. ; (ARRAY-TOTAL-SIZE ELEPHANT::A) ; ; note: unable to optimize because: can't tell the rank at compile time ; (SETF (ROW-MAJOR-AREF ELEPHANT::A ELEPHANT::I) ; (ELEPHANT::%DESERIALIZE ELEPHANT::BS)) ; --> SB-KERNEL:%SET-ROW-MAJOR-AREF ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY ; (SB-KERNEL:%CHECK-BOUND ARRAY ; (ARRAY-TOTAL-SIZE ; ARRAY) ; SB-INT:INDEX) ; SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a ARRAY, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; (ELEPHANT-MEMUTIL:BUFFER-READ-FIXNUM ELEPHANT::BS) ; --> BLOCK LET ; ==> ; (THE FIXNUM ; (ELEPHANT-MEMUTIL::READ-INT ; (ELEPHANT-MEMUTIL:BUFFER-STREAM-BUFFER ELEPHANT-MEMUTIL::BS) ; POSITION)) ; ; note: doing signed word to integer coercion (cost 20) to "" ; (ELEPHANT-MEMUTIL:BUFFER-READ-FLOAT ELEPHANT::BS) ; --> BLOCK LET ELEPHANT-MEMUTIL::READ-FLOAT BLOCK THE DEREF ; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE ; ==> ; ALIEN ; ; note: doing float to pointer coercion (cost 13) to "" ; (ELEPHANT-MEMUTIL:BUFFER-READ-DOUBLE ELEPHANT::BS) ; --> BLOCK LET ELEPHANT-MEMUTIL::READ-DOUBLE BLOCK THE DEREF ; --> SB-ALIEN-INTERNALS:EXTRACT-ALIEN-VALUE SB-ALIEN-INTERNALS:NATURALIZE ; ==> ; ALIEN ; ; note: doing float to pointer coercion (cost 13) to "" ; (LOOP ELEPHANT::FOR ; ELEPHANT::I ; FIXNUM ; ELEPHANT::FROM ; 0 ; ELEPHANT::BELOW ; (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS) ; ELEPHANT::COLLECT ; (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS)) ; --> BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* ; --> SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-COLLECT-RPLACD RPLACD LET ; --> PROGN SETF SB-KERNEL:%RPLACD SETQ THE ; ==> ; (LIST (ELEPHANT-MEMUTIL:BUFFER-READ-INT ELEPHANT::BS)) ; ; note: doing signed word to integer coercion (cost 20) ; compiling (DEFUN DESERIALIZE-BIGNUM ...) ; file: /home/howard/lisp/libs/elephant/src/elephant/serializer.lisp ; in: DEFUN DESERIALIZE-BIGNUM ; (DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS) ; ELEPHANT::BYTE-SPEC ; ELEPHANT::NUM) ; --> LET ; ==> ; (SB-KERNEL:%DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS) ; (BYTE-SIZE #:G898) ; (BYTE-POSITION #:G898) ; ELEPHANT::NUM) ; ; note: unable to ; convert to inline logical operations ; due to type uncertainty: ; The result is a (VALUES INTEGER ; &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T). ; ; note: unable to ; convert to inline logical operations ; due to type uncertainty: ; The result is a (VALUES INTEGER ; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) &REST T). ; (LOOP ELEPHANT::FOR ; ELEPHANT::I ; ELEPHANT::FROM ; 0 ; ELEPHANT::BELOW ; (/ LENGTH 4) ; ELEPHANT::FOR ; ELEPHANT::BYTE-SPEC ; = ; (ELEPHANT::INT-BYTE-SPEC ELEPHANT::I) ; ELEPHANT::WITH ; ...) ; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF ; ==> ; (< ELEPHANT::I #:LOOP-LIMIT-897) ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The second argument is a (RATIONAL -134217728 536870911/4), not a FIXNUM. ; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY ; --> SB-LOOP::LOOP-REALLY-DESETQ SETQ THE 1+ ; ==> ; (+ ELEPHANT::I 1) ; ; note: forced to do GENERIC-+ (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES (INTEGER 1) ; &OPTIONAL), not a (VALUES FIXNUM &REST T). ; unable to do inline fixnum arithmetic (cost 2) because: ; The first argument is a UNSIGNED-BYTE, not a FIXNUM. ; The result is a (VALUES (INTEGER 1) ; &OPTIONAL), not a (VALUES FIXNUM &REST T). ; etc. ; (- ELEPHANT::NUM) ; ==> ; (SB-KERNEL:%NEGATE ELEPHANT::NUM) ; ; note: forced to do GENERIC-NEGATE (cost 10) ; unable to do inline fixnum arithmetic (cost 1) because: ; The first argument is a INTEGER, not a FIXNUM. ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T). ; unable to do inline (signed-byte 32) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (SIGNED-BYTE 32). ; The result is a (VALUES INTEGER ; &OPTIONAL), not a (VALUES (SIGNED-BYTE 32) ; &REST ; T). ; (DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS) ; ELEPHANT::BYTE-SPEC ; ELEPHANT::NUM) ; --> LET ; ==> ; (SB-KERNEL:%DPB (ELEPHANT-MEMUTIL:BUFFER-READ-UINT ELEPHANT::BS) ; (BYTE-SIZE #:G898) ; (BYTE-POSITION #:G898) ; ELEPHANT::NUM) ; ; note: doing unsigned word to integer coercion (cost 20) ; compiling (DECLAIM (TYPE HASH-TABLE ...)) ; compiling (DEFVAR ARRAY-TYPE-TO-BYTE ...) ; compiling (DEFVAR BYTE-TO-ARRAY-TYPE ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (SETF (GETHASH # ...) ...) ; compiling (DEFUN TYPE= ...) ; compiling (LET (#) ...) ; compiling (LOOP FOR ...) ; compiling (DEFUN ARRAY-TYPE-FROM-BYTE ...) ; compiling (DEFUN BYTE-FROM-ARRAY-TYPE ...) ; compiling (DEFUN INT-BYTE-SPEC ...) ; compiling (ASDF:OPERATE (QUOTE ASDF:LOAD-OP) ...) ; loading system definition from /home/howard/lisp/libs/asd/cl-base64.asd ; into # ; registering # as CL-BASE64 ; registering # as CL-BASE64-TESTS ; loading system definition from /home/howard/lisp/libs/asd/kmrcl.asd into ; # ; registering # as KMRCL ; compiling (DEFUN SER-DESER-EQUAL ...) ; compiling (DEFUN SERIALIZE-TO-BASE64-STRING ...) ; compiling (DEFUN DESERIALIZE-FROM-BASE64-STRING ...) ; /home/howard/lisp/libs/elephant/src/elephant/serializer.fasl written ; compilation finished in 0:00:02 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/cache.lisp" (written 18 FEB 2006 08:53:00 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFUN MAKE-CACHE-TABLE ...) ; compiling (DEFUN GET-CACHE ...) ; compiling (DEFUN MAKE-FINALIZER ...) ; compiling (DEFUN SETF-CACHE ...) ; compiling (DEFSETF GET-CACHE ...) ; /home/howard/lisp/libs/elephant/src/elephant/cache.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/controller.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFPARAMETER *ELEPHANT-BACKENDS* ...) ; compiling (DEFVAR *ELEPHANT-CONTROLLER-INIT* ...) ; compiling (DEFUN REGISTER-BACKEND-CON-INIT ...) ; compiling (DEFUN LOOKUP-BACKEND-CON-INIT ...) ; compiling (DEFVAR *DBCONNECTION-SPEC* ...) ; compiling (DEFMETHOD GET-CON ...) ; compiling (DEFUN GET-CONTROLLER ...) ; compiling (DEFUN BUILD-CONTROLLER ...) ; compiling (DEFUN LOAD-BACKEND ...) ; compiling (DEFUN SATISFY-ASDF-DEPENDENCIES ...) ; compiling (DEFUN OPEN-STORE ...) ; compiling (DEFUN CLOSE-STORE ...) ; compiling (DEFMACRO WITH-OPEN-STORE ...) ; compiling (DEFCLASS STORE-CONTROLLER ...) ; compiling (DEFVAR *RESTRICTED-PROPERTIES* ...) ; compiling (DEFMETHOD CONTROLLER-PROPERTIES ...) ; compiling (DEFMETHOD SET-ELE-PROPERTY ...) ; compiling (DEFMETHOD GET-ELE-PROPERTY ...) ; compiling (DEFMETHOD ENSURE-MARKED-VERSION ...) ; compiling (DEFMETHOD CONTROLLER-VERSION ...) ; compiling (DEFMETHOD UP-TO-DATE-P ...) ; compiling (DEFPARAMETER *ELEPHANT-UPGRADE-TABLE* ...) ; compiling (DEFUN PRIOR-VERSION-P ...) ; compiling (DEFMETHOD UPGRADABLE-P ...) ; compiling (DEFMETHOD UPGRADE ...) ; compiling (DEFUN CACHE-INSTANCE ...) ; compiling (DEFUN GET-CACHED-INSTANCE ...) ; compiling (DEFMETHOD FLUSH-INSTANCE-CACHE ...) ; compiling (DEFPARAMETER *LEGACY-CONVERSIONS-DB* ...) ; compiling (DEFUN HANDLE-LEGACY-CLASSES ...) ; compiling (DEFUN SYMBOL->STRING-PAIR ...) ; compiling (DEFUN STRING-PAIR->SYMBOL ...) ; compiling (DEFGENERIC OPEN-CONTROLLER ...) ; compiling (DEFGENERIC CLOSE-CONTROLLER ...) ; compiling (DEFGENERIC CONNECTION-IS-INDEED-OPEN ...) ; compiling (DEFMETHOD CONNECTION-IS-INDEED-OPEN ...) ; compiling (DEFGENERIC NEXT-OID ...) ; compiling (DEFMETHOD CLOSE-CONTROLLER ...) ; compiling (DEFGENERIC PERSISTENT-SLOT-READER ...) ; compiling (DEFGENERIC PERSISTENT-SLOT-WRITER ...) ; compiling (DEFGENERIC PERSISTENT-SLOT-BOUNDP ...) ; compiling (DEFGENERIC PERSISTENT-SLOT-MAKUNBOUND ...) ; compiling (DEFUN ADD-TO-ROOT ...) ; compiling (DEFUN GET-FROM-ROOT ...) ; compiling (DEFUN ROOT-EXISTSP ...) ; compiling (DEFUN REMOVE-FROM-ROOT ...) ; compiling (DEFUN MAP-ROOT ...) ; compiling (DEFMETHOD DROP-POBJECT ...) ; /home/howard/lisp/libs/elephant/src/elephant/controller.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/collections.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFCLASS PERSISTENT-COLLECTION ...) ; compiling (DEFUN MAKE-BTREE ...) ; compiling (DEFGENERIC BUILD-BTREE ...) ; compiling (DEFCLASS BTREE ...) ; compiling (DEFGENERIC GET-VALUE ...) ; compiling (DEFGENERIC (SETF GET-VALUE) ...) ; compiling (DEFGENERIC REMOVE-KV ...) ; compiling (DEFGENERIC EXISTSP ...) ; compiling (DEFUN MAKE-INDEXED-BTREE ...) ; compiling (DEFGENERIC BUILD-INDEXED-BTREE ...) ; compiling (DEFCLASS INDEXED-BTREE ...) ; compiling (DEFGENERIC ADD-INDEX ...) ; compiling (DEFGENERIC GET-INDEX ...) ; compiling (DEFGENERIC REMOVE-INDEX ...) ; compiling (DEFGENERIC MAP-INDICES ...) ; compiling (DEFGENERIC BUILD-BTREE-INDEX ...) ; compiling (DEFCLASS BTREE-INDEX ...) ; compiling (DEFMETHOD SHARED-INITIALIZE ...) ; compiling (DEFGENERIC GET-PRIMARY-KEY ...) ; compiling (DEFMETHOD (SETF GET-VALUE) ...) ; compiling (DEFMETHOD REMOVE-KV ...) ; compiling (DEFCLASS CURSOR ...) ; compiling (DEFGENERIC MAKE-CURSOR ...) ; compiling (DEFGENERIC CURSOR-CLOSE ...) ; compiling (DEFGENERIC CURSOR-DUPLICATE ...) ; compiling (DEFGENERIC CURSOR-CURRENT ...) ; compiling (DEFGENERIC CURSOR-FIRST ...) ; compiling (DEFGENERIC CURSOR-LAST ...) ; compiling (DEFGENERIC CURSOR-NEXT ...) ; compiling (DEFGENERIC CURSOR-PREV ...) ; compiling (DEFGENERIC CURSOR-SET ...) ; compiling (DEFGENERIC CURSOR-SET-RANGE ...) ; compiling (DEFGENERIC CURSOR-GET-BOTH ...) ; compiling (DEFGENERIC CURSOR-GET-BOTH-RANGE ...) ; compiling (DEFGENERIC CURSOR-DELETE ...) ; compiling (DEFGENERIC CURSOR-PUT ...) ; compiling (DEFCLASS SECONDARY-CURSOR ...) ; compiling (DEFGENERIC CURSOR-PCURRENT ...) ; compiling (DEFGENERIC CURSOR-PFIRST ...) ; compiling (DEFGENERIC CURSOR-PLAST ...) ; compiling (DEFGENERIC CURSOR-PNEXT ...) ; compiling (DEFGENERIC CURSOR-PPREV ...) ; compiling (DEFGENERIC CURSOR-PSET ...) ; compiling (DEFGENERIC CURSOR-PSET-RANGE ...) ; compiling (DEFGENERIC CURSOR-PGET-BOTH ...) ; compiling (DEFGENERIC CURSOR-PGET-BOTH-RANGE ...) ; compiling (DEFGENERIC CURSOR-NEXT-DUP ...) ; compiling (DEFGENERIC CURSOR-NEXT-NODUP ...) ; compiling (DEFGENERIC CURSOR-PREV-NODUP ...) ; compiling (DEFGENERIC CURSOR-PNEXT-DUP ...) ; compiling (DEFGENERIC CURSOR-PNEXT-NODUP ...) ; compiling (DEFGENERIC CURSOR-PPREV-NODUP ...) ; compiling (DEFMACRO WITH-BTREE-CURSOR ...) ; compiling (DEFMETHOD MAP-BTREE ...) ; compiling (DEFMETHOD EMPTY-BTREE-P ...) ; compiling (DEFUN DUMP-BTREE ...) ; compiling (DEFUN BTREE-DIFFER ...) ; /home/howard/lisp/libs/elephant/src/elephant/collections.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/classindex-utils.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE :ELEPHANT) ; compiling (DEFPARAMETER *DEFAULT-INDEXED-CLASS-SYNCH-POLICY* ...) ; compiling (DEFMETHOD CLASS-INDEX-CACHED? ...) ; compiling (DEFMETHOD DETERMINE-SYNCH-METHOD ...) ; compiling (DEFMETHOD SET-DB-SYNCH ...) ; compiling (DEFPARAMETER *DERIVED-INDEX-MARKER* ...) ; compiling (DEFUN MAKE-DERIVED-NAME ...) ; compiling (DEFUN DERIVED-NAME? ...) ; compiling (DEFUN GET-DERIVED-NAME-ROOT ...) ; compiling (DEFUN MAKE-SLOT-KEY-FORM ...) ; compiling (DEFUN READ-SLOT-FOR-INDEX ...) ; compiling (DEFUN FIND-EFFECTIVE-SLOT-DEF ...) ; compiling (DEFUN MAKE-DERIVED-KEY-FORM ...) ; compiling (DEFUN COMPUTE-DERIVED-KEY-RESULT ...) ; compiling (DEFCLASS SYNCH-RULE ...) ; compiling (DEFUN MAKE-SYNCH-RULE ...) ; compiling (DEFPARAMETER *SYNCHRONIZE-RULES* ...) ; compiling (DEFUN SYNCHRONIZE-CLASS-TO-STORE ...) ; compiling (DEFUN SYNCH-RULE-APPLICABLE? ...) ; compiling (DEFUN SIMPLE-MATCH-SET ...) ; compiling (DEFPARAMETER *PRINT-SYNCH-MESSAGES* ...) ; compiling (DEFUN APPLY-SYNCH-RULE ...) ; compiling (DEFUN APPLY-SYNCH-RULES ...) ; compiling (DEFUN COMPUTE-CLASS-AND-ELE-STATUS ...) ; compiling (DEFUN DESCRIBE-DB-CLASS-INDEX ...) ; compiling (DEFUN WIPE-INDEXED-CLASS ...) ; compiling (DEFUN DUMP-CLASS-INDEX ...) ; compiling (DEFUN REPORT-INDEXED-CLASSES ...) ; /home/howard/lisp/libs/elephant/src/elephant/classindex-utils.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/classindex.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFGENERIC FIND-CLASS-INDEX ...) ; compiling (DEFGENERIC FIND-INVERTED-INDEX ...) ; compiling (DEFGENERIC ENABLE-CLASS-INDEXING ...) ; compiling (DEFGENERIC DISABLE-CLASS-INDEXING ...) ; compiling (DEFGENERIC ADD-CLASS-SLOT-INDEX ...) ; compiling (DEFGENERIC REMOVE-CLASS-SLOT-INDEX ...) ; compiling (DEFGENERIC ADD-CLASS-DERIVED-INDEX ...) ; compiling (DEFGENERIC REMOVE-CLASS-DERIVED-INDEX ...) ; compiling (DEFMETHOD INDEXED-SLOT-WRITER ...) ; compiling (DEFUN NO-INDEXING-NEEDED? ...) ; compiling (DEFMETHOD FIND-CLASS-INDEX ...) ; compiling (DEFMETHOD CLASS-INDEXEDP-BY-NAME ...) ; compiling (DEFMETHOD FIND-CLASS-INDEX ...) ; compiling (DEFUN ENSURE-FINALIZED ...) ; compiling (DEFUN CACHE-EXISTING-CLASS-INDEX ...) ; compiling (DEFINE-CONDITION PERSISTENT-CLASS-NOT-INDEXED ...) ; compiling (DEFUN CACHE-NEW-CLASS-INDEX ...) ; compiling (DEFMETHOD FIND-INVERTED-INDEX ...) ; compiling (DEFMETHOD FIND-INVERTED-INDEX ...) ; compiling (DEFMETHOD FIND-INVERTED-INDEX-NAMES ...) ; compiling (DEFMETHOD CLOSE-CONTROLLER ...) ; compiling (DEFMETHOD ENABLE-CLASS-INDEXING ...) ; compiling (DEFMETHOD DISABLE-CLASS-INDEXING ...) ; compiling (DEFMETHOD DISABLE-CLASS-INDEXING ...) ; file: /home/howard/lisp/libs/elephant/src/elephant/classindex.lisp ; in: DEFMETHOD DISABLE-CLASS-INDEXING (PERSISTENT-METACLASS) ; (RETURN-FROM ELEPHANT:DISABLE-CLASS-INDEXING NIL) ; ; note: deleting unreachable code ; compiling (DEFMETHOD WIPE-CLASS-INDEXING ...) ; compiling (DEFMETHOD ADD-CLASS-SLOT-INDEX ...) ; compiling (DEFMETHOD ADD-CLASS-SLOT-INDEX ...) ; compiling (DEFMETHOD REMOVE-CLASS-SLOT-INDEX ...) ; compiling (DEFMETHOD REMOVE-CLASS-SLOT-INDEX ...) ; compiling (DEFMETHOD ADD-CLASS-DERIVED-INDEX ...) ; compiling (DEFMETHOD ADD-CLASS-DERIVED-INDEX ...) ; compiling (DEFMETHOD REMOVE-CLASS-DERIVED-INDEX ...) ; compiling (DEFMETHOD REMOVE-CLASS-DERIVED-INDEX ...) ; compiling (DEFGENERIC MAKE-INVERTED-CURSOR ...) ; compiling (DEFGENERIC MAKE-CLASS-CURSOR ...) ; compiling (DEFMETHOD MAKE-INVERTED-CURSOR ...) ; compiling (DEFMACRO WITH-INVERTED-CURSOR ...) ; compiling (DEFMETHOD MAKE-CLASS-CURSOR ...) ; compiling (DEFMACRO WITH-CLASS-CURSOR ...) ; compiling (DEFGENERIC GET-INSTANCES-BY-CLASS ...) ; compiling (DEFGENERIC GET-INSTANCE-BY-VALUE ...) ; compiling (DEFGENERIC GET-INSTANCES-BY-VALUE ...) ; compiling (DEFGENERIC GET-INSTANCES-BY-RANGE ...) ; compiling (DEFMETHOD GET-INSTANCES-BY-CLASS ...) ; compiling (DEFMETHOD GET-INSTANCES-BY-CLASS ...) ; compiling (DEFMETHOD GET-INSTANCES-BY-VALUE ...) ; compiling (DEFMETHOD GET-INSTANCES-BY-VALUE ...) ; compiling (DEFMETHOD GET-INSTANCE-BY-VALUE ...) ; compiling (DEFMETHOD GET-INSTANCE-BY-VALUE ...) ; compiling (DEFMETHOD GET-INSTANCES-BY-RANGE ...) ; compiling (DEFMETHOD GET-INSTANCES-BY-RANGE ...) ; compiling (DEFMACRO DO-SUBSETS ...) ; compiling (DEFUN DROP-INSTANCES ...) ; /home/howard/lisp/libs/elephant/src/elephant/classindex.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/migrate.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE "ELEPHANT") ; compiling (DEFGENERIC MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFVAR *MIGRATE-COPIED-OIDS* ...) ; compiling (DEFVAR *MIGRATING* ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFUN COPY-CINDEX-CONTENTS ...) ; compiling (DEFVAR *INHIBIT-SLOT-COPY* ...) ; compiling (DEFMACRO WITH-INHIBITED-SLOT-COPY ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFUN RESET-MIGRATE-DUPLICATE-DETECTION ...) ; compiling (DEFUN OBJECT-WAS-COPIED-P ...) ; compiling (DEFUN REGISTER-COPIED-OBJECT ...) ; compiling (DEFUN RETRIEVE-COPIED-OBJECT ...) ; compiling (DEFUN COPY-PERSISTENT-OBJECT ...) ; compiling (DEFUN INHIBIT-INDEXED-SLOT-COPY? ...) ; compiling (DEFUN COPY-PERSISTENT-SLOTS ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD COPY-BTREE-CONTENTS ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; compiling (DEFMETHOD MIGRATE ...) ; /home/howard/lisp/libs/elephant/src/elephant/migrate.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/src/elephant/backend.lisp" (written 20 FEB 2006 07:45:37 AM): ; compiling (IN-PACKAGE :CL-USER) ; compiling (DEFPACKAGE :ELEPHANT-BACKEND ...) ; /home/howard/lisp/libs/elephant/src/elephant/backend.fasl written ; compilation finished in 0:00:00 ; ; compilation unit finished ; printed 94 notes NIL **************************************** 'require.elephant-tests' **************************************** (require :elephant-tests) ; loading system definition from /home/howard/lisp/libs/asd/rt.asd into ; # ; registering # as RT ; compiling file "/home/howard/lisp/libs/elephant/tests/elephant-tests.lisp" (written 27 MAR 2006 12:22:47 PM): ; compiling (DEFPACKAGE ELEPHANT-TESTS ...) ; compiling (IN-PACKAGE :ELE-TESTS) ; compiling (DEFTYPE ARRAY-OR-POINTER-CHAR ...) ; compiling (DEFVAR *TESTBDB-SPEC* ...) ; compiling (DEFVAR *TESTBDB-SPEC2* ...) ; compiling (DEFVAR *TESTPG-SPEC* ...) ; compiling (DEFVAR *TESTSQLITE3-SPEC* ...) ; compiling (DEFVAR *TESTSQLITE3-SPEC2* ...) ; compiling (DEFVAR *TESTSQLITE3-MEMORY-SPEC* ...) ; compiling (DEFVAR *DEFAULT-SPEC* ...) ; compiling (DEFUN DO-BACKEND-TESTS ...) ; compiling (DEFUN DO-TEST-SPEC ...) ; compiling (DEFUN DO-MIGRATION-TESTS ...) ; compiling (DEFUN DO-MIGRATION-TEST-SPEC ...) ; compiling (DEFUN DO-INDEXING-TESTS ...) ; compiling (DEFUN DO-CRAZY-PG-TESTS ...) ; compiling (DEFUN FIND-SLOT-DEF ...) ; compiling (DEFVAR *SLEEPYCATDB-SPEC* ...) ; compiling (DEFMACRO FINISHES ...) ; compiling (DEFMACRO SIGNALS-CONDITION ...) ; compiling (DEFMACRO SIGNALS-ERROR ...) ; compiling (DEFMACRO IS-NOT-NULL ...) ; compiling (DEFMACRO ARE-NOT-NULL ...) ; /home/howard/lisp/libs/elephant/tests/elephant-tests.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/tests/testserializer.lisp" (written 18 FEB 2006 08:53:02 PM): ; compiling (IN-PACKAGE :ELE-TESTS) ; compiling (DEFUN IN-OUT-VALUE ...) ; compiling (DEFUN IN-OUT-EQ ...) ; compiling (DEFUN IN-OUT-EQUAL ...) ; compiling (DEFUN IN-OUT-EQUALP ...) ; compiling (DEFTEST FIXNUMS ...) ; compiling (DEFTEST FIXNUM-TYPE-1 ...) ; compiling (DEFTEST BIGNUMS ...) ; compiling (DEFTEST FLOATS ...) ; compiling (DEFTEST RATIONALS ...) ; compiling (DEFTEST BASE-STRINGS ...) ; compiling (DEFTEST STRINGS ...) ; compiling (DEFUN IN-OUT-UNINTERNED-EQUAL ...) ; compiling (DEFTEST SYMBOLS ...) ; compiling (DEFTEST CHARS ...) ; compiling (DEFTEST PATHNAMES ...) ; compiling (DEFTEST CONSES ...) ; compiling (DEFTEST HASH-TABLES-1 ...) ; compiling (DEFTEST HASH-TABLES-2 ...) ; compiling (DEFUN TYPE= ...) ; compiling (DEFTEST ARRAYS-1 ...) ; compiling (DEFTEST ARRAYS-2 ...) ; compiling (DEFUN DEEP-EQUALP ...) ; compiling (DEFCLASS FOO ...) ; compiling (DEFCLASS BAR ...) ; compiling (DEFTEST TEST-DEEP-EQUALP ...) ; compiling (DEFUN IN-OUT-DEEP-EQUALP ...) ; compiling (DEFTEST OBJECTS ...) ; compiling (DEFTEST CIRCULAR ...) ; compiling (DEFCLASS PFOO ...) ; compiling (DEFCLASS PBAR ...) ; compiling (DEFTEST PERSISTENT ...) ; /home/howard/lisp/libs/elephant/tests/testserializer.fasl written ; compilation finished in 0:00:01 ; compiling file "/home/howard/lisp/libs/elephant/tests/mop-tests.lisp" (written 18 FEB 2006 08:53:02 PM): ; compiling (IN-PACKAGE :ELE-TESTS) ; compiling (DEFTEST NON-TRANSIENT-CLASS-SLOT-1 ...) ; compiling (DEFTEST NON-TRANSIENT-CLASS-SLOT-2 ...) ; compiling (DEFTEST TRANSIENT-CLASS-SLOT ...) ; compiling (DEFTEST CLASS-DEFINERS ...) ; compiling (DEFTEST BAD-INHERITENCE ...) ; compiling (DEFTEST MIXES ...) ; compiling (DEFTEST MIXES-RIGHT-SLOTS ...) ; compiling (DEFTEST INHERIT ...) ; compiling (DEFTEST INHERIT-RIGHT-SLOTS ...) ; compiling (DEFTEST INITFORM-CLASSES ...) ; compiling (DEFTEST INITFORM-TEST ...) ; compiling (DEFTEST INITARG-TEST ...) ; compiling (DEFTEST NO-EVAL-INITFORM ...) ; compiling (DEFTEST REDEFCLASS ...) ; compiling (DEFTEST MAKUNBOUND ...) ; compiling (DEFTEST UPDATE-CLASS ...) ; compiling (DEFTEST CHANGE-CLASS ...) ; compiling (DEFTEST CHANGE-CLASS3 ...) ; /home/howard/lisp/libs/elephant/tests/mop-tests.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/tests/testcollections.lisp" (written 19 APR 2006 07:07:15 PM): ; compiling (IN-PACKAGE :ELE-TESTS) ; compiling (DEFTEST BASICPERSISTENCE ...) ; compiling (DEFTEST TESTOID ...) ; compiling (DEFCLASS BLOB ...) ; compiling (DEFVAR KEYS ...) ; compiling (DEFVAR OBJS ...) ; compiling (DEFVAR BT) ; compiling (DEFTEST BTREE-MAKE ...) ; compiling (DEFTEST BTREE-PUT ...) ; compiling (DEFTEST BTREE-GET ...) ; compiling (DEFVAR FIRST-KEY ...) ; compiling (DEFTEST REMOVE-KV ...) ; compiling (DEFTEST REMOVED ...) ; compiling (DEFTEST MAP-BTREE ...) ; compiling (DEFVAR INDEXED) ; compiling (DEFVAR INDEX1) ; compiling (DEFVAR INDEX2) ; compiling (DEFTEST INDEXED-BTREE-MAKE ...) ; compiling (DEFUN KEY-MAKER ...) ; compiling (DEFTEST ADD-INDICES ...) ; compiling (DEFTEST TEST-INDICES ...) ; compiling (DEFTEST INDEXED-PUT ...) ; compiling (DEFTEST INDEXED-GET ...) ; compiling (DEFTEST SIMPLE-SLOT-GET ...) ; compiling (DEFTEST INDEXED-GET-FROM-SLOT1 ...) ; compiling (DEFTEST INDEXED-GET-FROM-SLOT2 ...) ; compiling (DEFTEST REMOVE-KV-INDEXED ...) ; compiling (DEFTEST NO-KEY-NOR-INDICES ...) ; compiling (DEFTEST REMOVE-KV-FROM-SLOT1 ...) ; compiling (DEFTEST NO-KEY-NOR-INDICES-SLOT1 ...) ; compiling (DEFTEST REMOVE-KV-FROM-SLOT2 ...) ; compiling (DEFTEST NO-KEY-NOR-INDICES-SLOT2 ...) ; compiling (DEFTEST MAP-INDEXED ...) ; compiling (DEFTEST GET-FIRST ...) ; compiling (DEFTEST GET-FIRST2 ...) ; compiling (DEFTEST GET-LAST ...) ; compiling (DEFTEST GET-LAST2 ...) ; compiling (DEFTEST SET ...) ; compiling (DEFTEST SET2 ...) ; compiling (DEFTEST SET-RANGE ...) ; compiling (DEFTEST SET-RANGE2 ...) ; compiling (DEFTEST REM-KV ...) ; compiling (DEFUN ODD ...) ; compiling (DEFTEST REM-IDEXKV ...) ; compiling (DEFVAR INDEXED2) ; compiling (DEFVAR INDEX3) ; compiling (DEFTEST MAKE-INDEXED2 ...) ; compiling (DEFUN CRUNCH ...) ; compiling (DEFTEST ADD-INDICES2 ...) ; compiling (DEFTEST PUT-INDEXED2 ...) ; compiling (DEFTEST GET-INDEXED2 ...) ; compiling (DEFTEST GET-FROM-INDEX3 ...) ; compiling (DEFTEST DUP-TEST ...) ; compiling (DEFTEST NODUP-TEST ...) ; compiling (DEFTEST PREV-NODUP-TEST ...) ; compiling (DEFTEST PNODUP-TEST ...) ; compiling (DEFTEST PPREV-NODUP-TEST ...) ; compiling (DEFTEST CUR-DEL1 ...) ; compiling (DEFTEST INDEXED-DELETE ...) ; compiling (DEFTEST TEST-DELETED ...) ; compiling (DEFTEST INDEXED-DELETE2 ...) ; compiling (DEFTEST TEST-DELETED2 ...) ; compiling (DEFTEST CUR-DEL2 ...) ; compiling (DEFTEST GET-BOTH ...) ; compiling (DEFTEST PGET-BOTH ...) ; compiling (DEFTEST PGET-BOTH-RANGE ...) ; compiling (DEFMACRO PCURSOR-PKEY ...) ; compiling (DEFTEST PCURSOR ...) ; compiling (DEFVAR INDEX4) ; compiling (DEFTEST NEWINDEX ...) ; compiling (DEFTEST PCURSOR2 ...) ; compiling (DEFTEST ADD-GET-REMOVE ...) ; compiling (DEFTEST ADD-GET-REMOVE-SYMBOL ...) ; compiling (DEFTEST EXISTSP ...) ; /home/howard/lisp/libs/elephant/tests/testcollections.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/tests/testindexing.lisp" (written 10 MAY 2006 07:42:51 PM): ; compiling (IN-PACKAGE :ELE-TESTS) ; compiling (DEFUN SETUP-TESTING ...) ; compiling (DEFVAR INST1) ; compiling (DEFVAR INST2) ; compiling (DEFVAR INST3) ; compiling (DEFTEST DISABLE-CLASS-INDEXING-TEST ...) ; compiling (DEFTEST INDEXING-BASIC-TRIVIAL ...) ; compiling (DEFTEST INDEXING-BASIC ...) ; compiling (DEFTEST INDEXING-INHERIT ...) ; compiling (DEFTEST INDEXING-RANGE ...) ; compiling (DEFTEST INDEXING-WIPE-INDEX ...) ; compiling (DEFTEST INDEXING-RECONNECT-DB ...) ; compiling (DEFTEST INDEXING-CHANGE-CLASS ...) ; compiling (DEFTEST INDEXING-REDEF-CLASS ...) ; compiling (DEFVAR NORMAL-INDEX ...) ; compiling (DEFUN MAKE-STRESS-CLASSES ...) ; compiling (DEFUN NORMAL-STRESS-SETUP ...) ; compiling (DEFUN INDEXED-STRESS-SETUP ...) ; compiling (DEFUN NORMAL-RANGE-LOOKUP ...) ; file: /home/howard/lisp/libs/elephant/tests/testindexing.lisp ; in: DEFUN NORMAL-RANGE-LOOKUP ; (ELEPHANT:WITH-BTREE-CURSOR ; (ELEPHANT-TESTS::CUR ELEPHANT-TESTS::NORMAL-INDEX) ; (LOOP ; (MULTIPLE-VALUE-BIND ; (ELEPHANT-TESTS::VALUE? ELEPHANT-TESTS::KEY ELEPHANT-TESTS::VAL) ; (ELEPHANT:CURSOR-NEXT ELEPHANT-TESTS::CUR) ; (DECLARE (IGNORE ELEPHANT-TESTS::KEY)) ; (COND (# #) (# #)))) ; ELEPHANT-TESTS::OBJECTS) ; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN ; ==> ; ELEPHANT-TESTS::OBJECTS ; ; note: deleting unreachable code ; compiling (DEFUN INDEXED-RANGE-LOOKUP ...) ; compiling (DEFPARAMETER *STRESS-COUNT* ...) ; compiling (DEFPARAMETER *RANGE-SIZE* ...) ; compiling (DEFTEST INDEXING-TIMING ...) ; /home/howard/lisp/libs/elephant/tests/testindexing.fasl written ; compilation finished in 0:00:00 ; compiling file "/home/howard/lisp/libs/elephant/tests/testmigration.lisp" (written 26 APR 2006 06:27:51 PM): ; compiling (IN-PACKAGE :ELE-TESTS) ; compiling (DEFTEST REMOVE-ELEMENT ...) ; compiling (DEFTEST MIGRATE-BASIC ...) ; compiling (DEFTEST MIGRATE-BTREE ...) ; compiling (DEFTEST MIGRATE-IDX-BTREE ...) ; compiling (DEFTEST MIGRATE-PCLASS ...) ; compiling (DEFPCLASS IPFOO ...) ; compiling (DEFTEST MIGRATE-IPCLASS ...) ; /home/howard/lisp/libs/elephant/tests/testmigration.fasl written ; compilation finished in 0:00:00 ; ; compilation unit finished ; printed 1 note NIL On 6/22/06, Ian Eslick wrote: > What OS are you running on? Did you get a compile error? The trace > looks ok. > > Ian > > Howard Yeh wrote: > > Hi, > > > > I am trying to get Elephant to work. > > > > (require :elephant) > > (require :elephant-tests) > > (in-package "ELEPHANT-TESTS") > > (setf *default-spec* *testbdb-spec*) > > (do-backend-tests) > > > > ASDF seems to compile and load :elephant and :elephant-tests ok. > > But when I try (do-backend-tests), ASDF tries to compile sleepycat.lisp > > and causes SBCL to exit abnormally (code 256). > > > > Then I tried to compile sleepycat.lisp individually to see what happens. > > > > (require :elephant) > > (compile-file > > #p"/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" > > :verbose t) > > > > Same thing, abnormal exit 256. I did a lot of fiddling around, but > > still can't get it to work. I have no idea what's going on. > > > > I am using Elephant 0.6.0 and SBCL 0.9.12. > > > > > > -Howard > > > > > > ; compiling file > > "/home/howard/wisp/src/libs/elephant/src/db-bdb/sleepycat.lisp" > > (written 10 MAY 2006 07:42:51 PM): > > ; compiling (IN-PACKAGE "SLEEPYCAT") > > ; compiling (DECLAIM (INLINE %DB-GET-KEY-BUFFERED ...)) > > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY > > ELEPHANT::*SLEEPYCAT-PTHREADS-PATH* ...) ...) > > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY > > ELEPHANT::*SLEEPYCAT-FOREIGN-LIBRARY-PATH* ...) ...) > > ; compiling (UNLESS (LOAD-FOREIGN-LIBRARY # ...) ...) > > ; compiling (DEF-FUNCTION ("db_strerr" %DB-STRERROR) ...) > > ; compiling (DEFUN DB-STRERROR ...) > > ; compiling (DEFINE-CONDITION DB-ERROR ...) > > ; compiling (DEFCONSTANT DB-BTREE ...) > > ; compiling (DEFCONSTANT DB-HASH ...) > > ; compiling (DEFCONSTANT DB-RECNO ...) > > ; compiling (DEFCONSTANT DB-QUEUE ...) > > ; compiling (DEFCONSTANT DB-UNKNOWN ...) > > ; compiling (DEFCONSTANT DB_AUTO_COMMIT ...) > > ; compiling (DEFCONSTANT DB_JOINENV ...) > > ; compiling (DEFCONSTANT DB_INIT_CDB ...) > > ; compiling (DEFCONSTANT DB_INIT_LOCK ...) > > ; compiling (DEFCONSTANT DB_INIT_LOG ...) > > ; compiling (DEFCONSTANT DB_INIT_MPOOL ...) > > ; compiling (DEFCONSTANT DB_INIT_REP ...) > > ; compiling (DEFCONSTANT DB_INIT_TXN ...) > > ; compiling (DEFCONSTANT DB_RECOVER ...) > > ; compiling (DEFCONSTANT DB_RECOVER_FATAL ...) > > ; compiling (DEFCONSTANT DB_LOCKDOWN ...) > > ; compiling (DEFCONSTANT DB_PRIVATE ...) > > ; compiling (DEFCONSTANT DB_SYSTEM_MEM ...) > > ; compiling (DEFCONSTANT DB_THREAD ...) > > ; compiling (DEFCONSTANT DB_FORCE ...) > > ; compiling (DEFCONSTANT DB_DEGREE_2 ...) > > ; compiling (DEFCONSTANT DB_DIRTY_READ ...) > > ; compiling (DEFCONSTANT DB_CREATE ...) > > ; compiling (DEFCONSTANT DB_EXCL ...) > > ; compiling (DEFCONSTANT DB_NOMMAP ...) > > ; compiling (DEFCONSTANT DB_RDONLY ...) > > ; compiling (DEFCONSTANT DB_TRUNCATE ...) > > ; compiling (DEFCONSTANT DB_TXN_NOSYNC ...) > > ; compiling (DEFCONSTANT DB_TXN_NOWAIT ...) > > ; compiling (DEFCONSTANT DB_TXN_SYNC ...) > > ; compiling (DEFCONSTANT DB_LOCK_NOWAIT ...) > > ; compiling (DEFCONSTANT DB_DUP ...) > > ; compiling (DEFCONSTANT DB_DUPSORT ...) > > ; compiling (DEFCONSTANT DB_CURRENT ...) > > ; compiling (DEFCONSTANT DB_FIRST ...) > > ; compiling (DEFCONSTANT DB_GET_BOTH ...) > > ; compiling (DEFCONSTANT DB_GET_BOTH_RANGE ...) > > ; compiling (DEFCONSTANT DB_LAST ...) > > ; compiling (DEFCONSTANT DB_NEXT ...) > > ; compiling (DEFCONSTANT DB_NEXT_DUP ...) > > ; compiling (DEFCONSTANT DB_NEXT_NODUP ...) > > ; compiling (DEFCONSTANT DB_PREV ...) > > ; compiling (DEFCONSTANT DB_PREV_NODUP ...) > > ; compiling (DEFCONSTANT DB_SET ...) > > ; compiling (DEFCONSTANT DB_SET_RANGE ...) > > ; compiling (DEFCONSTANT DB_AFTER ...) > > ; compiling (DEFCONSTANT DB_BEFORE ...) > > ; compiling (DEFCONSTANT DB_KEYFIRST ...) > > ; compiling (DEFCONSTANT DB_KEYLAST ...) > > ; compiling (DEFCONSTANT DB_NODUPDATA ...) > > ; compiling (DEFCONSTANT DB_NOOVERWRITE ...) > > ; compiling (DEFCONSTANT DB_NOSYNC ...) > > ; compiling (DEFCONSTANT DB_POSITION ...) > > ; compiling (DEFCONSTANT DB_SEQ_DEC ...) > > ; compiling (DEFCONSTANT DB_SEQ_INC ...) > > ; compiling (DEFCONSTANT DB_SEQ_WRAP ...) > > ; compiling (DEFCONSTANT DB_SET_LOCK_TIMEOUT ...) > > ; compiling (DEFCONSTANT DB_SET_TXN_TIMEOUT ...) > > ; compiling (DEFCONSTANT DB_KEYEMPTY ...) > > ; compiling (DEFCONSTANT DB_KEYEXIST ...) > > ; compiling (DEFCONSTANT DB_LOCK_DEADLOCK ...) > > ; compiling (DEFCONSTANT DB_LOCK_NOTGRANTED ...) > > ; compiling (DEFCONSTANT DB_NOTFOUND ...) > > ; compiling (DEFCONSTANT DB_LOCK_DEFAULT ...) > > ; compiling (DEFCONSTANT DB_LOCK_EXPIRE ...) > > ; compiling (DEFCONSTANT DB_LOCK_MAXLOCKS ...) > > ; compiling (DEFCONSTANT DB_LOCK_MAXWRITE ...) > > ; compiling (DEFCONSTANT DB_LOCK_MINLOCKS ...) > > ; compiling (DEFCONSTANT DB_LOCK_MINWRITE ...) > > ; compiling (DEFCONSTANT DB_LOCK_OLDEST ...) > > ; compiling (DEFCONSTANT DB_LOCK_RANDOM ...) > > ; compiling (DEFCONSTANT DB_LOCK_YOUNGEST ...) > > ; compiling (DEF-ENUM DB-LOCKOP ...) > > _______________________________________________ > > elephant-devel site list > > elephant-devel at common-lisp.net > > http://common-lisp.net/mailman/listinfo/elephant-devel > _______________________________________________ > elephant-devel site list > elephant-devel at common-lisp.net > http://common-lisp.net/mailman/listinfo/elephant-devel > From hayeah at gmail.com Fri Jun 30 21:34:30 2006 From: hayeah at gmail.com (Howard Yeh) Date: Fri, 30 Jun 2006 14:34:30 -0700 Subject: [elephant-devel] Re: SBCL exits abnormally when compiling sleepycat.lisp In-Reply-To: <449ABC41.8020109@csail.mit.edu> References: <449ABC41.8020109@csail.mit.edu> Message-ID: I figured out the problem for ACL80. Haven't tried to get SBCL working yet... I think the reason is that for allegro UFFI simply uses the "load" function. Apparently load expects the ".so" extension for foreign libraries. So if your system has a version number attached to the end, then allegro will load it as a lisp source... or whatever. Hence the "whitespace in token" error. I am guessing your pthread .so has a version number, whereas libpth doesn't. All tests passed for ACL80. \0/