From alemmens at xs4all.nl Thu Aug 3 11:15:47 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 03 Aug 2006 13:15:47 +0200 Subject: [rucksack-devel] Patch for FIND-BLOCK In-Reply-To: References: Message-ID: Edi Weitz wrote (ages ago): > Here's a patch for FIND-BLOCK in heap.lisp which in its current form > always returns NIL. This is probably not what was intended. Oops. > I've also taken the liberty to rename all occurences of "full" to > "empty" to make the inline docs and the function names more > consistent. Thanks. Committed to CVS now. Arthur From alemmens at xs4all.nl Thu Aug 3 11:20:02 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 03 Aug 2006 13:20:02 +0200 Subject: [rucksack-devel] GC patch In-Reply-To: References: Message-ID: Edi Weitz wrote: > Here's a tiny patch to make sure that the MAX-HEAP-VALUE is always an > integer. Thanks. Committed. Arthur From alemmens at xs4all.nl Thu Aug 3 11:46:24 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 03 Aug 2006 13:46:24 +0200 Subject: [rucksack-devel] GC question In-Reply-To: References: Message-ID: Edi Weitz wrote: > But then the default value for GROW-SIZE probably shouldn't be 2.0 > because that'll result in an enormous growth. I'd propose to set > GROW-SIZE to the (integral) size of MAX-HEAP-END in the :AFTER method > of INITIALIZE-INSTANCE (unless the user had set it already) - something > like in the attached patch. OK, fine. Committed. Arthur From alemmens at xs4all.nl Thu Aug 3 11:53:43 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 03 Aug 2006 13:53:43 +0200 Subject: [rucksack-devel] More patches In-Reply-To: References: Message-ID: Edi Weitz wrote: > Here are two more small patches for Rucksack. The first one fixes all > SETF functions which had a wrong return value. Thanks. Committed. Arthur From alemmens at xs4all.nl Thu Aug 3 12:08:22 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 03 Aug 2006 14:08:22 +0200 Subject: [rucksack-devel] More patches In-Reply-To: References: Message-ID: Edi Weitz wrote: > The second one fixes a syntax error in WITH-TRANSACTION and makes > sure the first return value is what the body returns as is usual > with WITH- macros. Thanks. Committed. > Note that these patches are relative to what I've sent in June, so > they might not work with what's in CVS as nothing has been commited > there since May. Yeah, sorry about that. I was just too bloody busy with other stuff (followed by two weeks of vacation). Arthur From alemmens at xs4all.nl Thu Aug 3 18:51:38 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 03 Aug 2006 20:51:38 +0200 Subject: [rucksack-devel] Rucksack error In-Reply-To: References: <137061277@web.de> Message-ID: Edi wrote: >> Attached is a patch for unique transaction IDs. > > And here's a fix for it... :) Thanks. Committed. Arthur From alemmens at xs4all.nl Fri Aug 4 10:40:58 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Fri, 04 Aug 2006 12:40:58 +0200 Subject: [rucksack-devel] SCAN-CONTENTS In-Reply-To: References: Message-ID: Edi Weitz wrote: >> This patch adds the missing SCAN-CONTENTS methods (for efficiency). > > Forgot one - see attachment. Thanks. Committed. Arthur From alemmens at xs4all.nl Fri Aug 4 10:53:51 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Fri, 04 Aug 2006 12:53:51 +0200 Subject: [rucksack-devel] Mutating the argument list In-Reply-To: References: Message-ID: Edi Weitz wrote: > Here's a small patch for WITH-TRANSACTION which replaces the REMF > part. Thanks. It turns out there was another function which used this REMF trick. I replaced both by Erik Naggum's SANS. Arthur From alemmens at xs4all.nl Fri Aug 4 11:12:14 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Fri, 04 Aug 2006 13:12:14 +0200 Subject: [rucksack-devel] Restarts for BTREE-SEARCH In-Reply-To: References: Message-ID: Edi Weitz wrote: > Subject says it all. Thanks. Committed. Arthur From alemmens at xs4all.nl Fri Aug 4 11:19:13 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Fri, 04 Aug 2006 13:19:13 +0200 Subject: [rucksack-devel] Error reporting for btree errors In-Reply-To: References: Message-ID: Edi Weitz wrote: > Yes, I'm on a roll today... :) Hehe. Keep on rolling... Committed. Arthur From alemmens at xs4all.nl Fri Aug 4 22:16:42 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Sat, 05 Aug 2006 00:16:42 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: References: Message-ID: Edi Weitz wrote: > The attached patch cleans up (at least I hope so) the btree code a bit > and adds the missing delete function and some more tests. Very nice, thanks a lot. > In particular, I convinced myself that KEY= is really not needed > although I said the opposite at the ECLM. Yes, I suppose you're right. At the time I thought it might be useful to support keys that only have a partial order, but that probably doesn't make any sense. > Also, the old version of BTREE-NODE-INSERT sometimes split too early > because it eagerly split downwards. The new version splits upwards > and only if needed. Great. I've committed your patch (with some minor modifications). But there's one thing in your patch that I think is wrong. You removed the VALUE argument for INDEX-DELETE: > -(defgeneric index-delete (index key value &key if-does-not-exist) > - (:documentation "Remove a key/value pair from an index. > +(defgeneric index-delete (index key &key if-does-not-exist) > + (:documentation "Remove a key from an index. And your new BTREE-DELETE function doesn't take a VALUE argument either: > (defgeneric btree-delete (btree key &key if-does-not-exist)) That's fine for btrees with unique keys (where each key corresponds to one value), but I think it's not good enough for btrees with non-unique keys (where each key can correspond to more than one value). The most important reason for also having btrees with non-unique keys is that they can be used to implement indexing for slot values. The index for slots that don't have unique values can be implemented as a btree where the keys are the slot values and the values are the instances containing that slot value. (I'm not explaining this very well, but I hope you understand what I mean.) Suppose an object EDI of class PERSON has an indexed slot AGE. Suppose this AGE slot changes from 20 to 21. Then we need to do something like (INDEX-DELETE 20 EDI) (INDEX-ADD 21 EDI) We can't just do (INDEX-DELETE 20) because that would remove all persons of age 20 from the index. (See also the definition of RUCKSACK-MAYBE-INDEX-CHANGED-SLOT.) So I think that INDEX-DELETE needs the VALUE argument, and so does BTREE-DELETE. Do you agree with this or am I missing something? Arthur From alemmens at xs4all.nl Fri Aug 4 22:22:01 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Sat, 05 Aug 2006 00:22:01 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: References: Message-ID: Edi Weitz wrote: > BTW, you'll notice that I changed your "split downwards" approach to > the usual "split upwards" way which is slightly more efficient. It > just occurred to me, though, that you might have done this on purpose > to implement (a variant of) the Guibas/Sedgewick algorithm. Erm, no. I just implemented the first thing that I could get working. Actually, I don't even know what the Guibas/Sedgewick algorithm is. Should I Google it up? Arthur From edi at agharta.de Fri Aug 4 22:27:54 2006 From: edi at agharta.de (Edi Weitz) Date: Sat, 05 Aug 2006 00:27:54 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: (Arthur Lemmens's message of "Sat, 05 Aug 2006 00:16:42 +0200") References: Message-ID: On Sat, 05 Aug 2006 00:16:42 +0200, "Arthur Lemmens" wrote: > But there's one thing in your patch that I think is wrong. You > removed the VALUE argument for INDEX-DELETE: > >> -(defgeneric index-delete (index key value &key if-does-not-exist) >> - (:documentation "Remove a key/value pair from an index. >> +(defgeneric index-delete (index key &key if-does-not-exist) >> + (:documentation "Remove a key from an index. > > And your new BTREE-DELETE function doesn't take a VALUE argument > either: > >> (defgeneric btree-delete (btree key &key if-does-not-exist)) > > That's fine for btrees with unique keys (where each key corresponds > to one value), but I think it's not good enough for btrees with > non-unique keys (where each key can correspond to more than one > value). > > The most important reason for also having btrees with non-unique > keys is that they can be used to implement indexing for slot values. > The index for slots that don't have unique values can be implemented > as a btree where the keys are the slot values and the values are the > instances containing that slot value. (I'm not explaining this very > well, but I hope you understand what I mean.) > > Suppose an object EDI of class PERSON has an indexed slot AGE. Suppose > this AGE slot changes from 20 to 21. Then we need to do something like > > (INDEX-DELETE 20 EDI) > (INDEX-ADD 21 EDI) > > We can't just do > > (INDEX-DELETE 20) > > because that would remove all persons of age 20 from the index. > (See also the definition of RUCKSACK-MAYBE-INDEX-CHANGED-SLOT.) > > So I think that INDEX-DELETE needs the VALUE argument, and so does > BTREE-DELETE. > > Do you agree with this or am I missing something? You're right, I didn't think of that. I just thought about "standard" btrees with one value per key. From edi at agharta.de Fri Aug 4 22:31:00 2006 From: edi at agharta.de (Edi Weitz) Date: Sat, 05 Aug 2006 00:31:00 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: (Arthur Lemmens's message of "Sat, 05 Aug 2006 00:16:42 +0200") References: Message-ID: On Sat, 05 Aug 2006 00:16:42 +0200, "Arthur Lemmens" wrote: >> -(defgeneric index-delete (index key value &key if-does-not-exist) >> - (:documentation "Remove a key/value pair from an index. But then the documentation shouldn't say "removes a key/value pair", but something like "removes value from key, if keys are unique, removes the key as well". BTW, what happens if I have a btree with non-unique keys and remove the last value from a key? From edi at agharta.de Fri Aug 4 22:37:21 2006 From: edi at agharta.de (Edi Weitz) Date: Sat, 05 Aug 2006 00:37:21 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: (Arthur Lemmens's message of "Sat, 05 Aug 2006 00:22:01 +0200") References: Message-ID: On Sat, 05 Aug 2006 00:22:01 +0200, "Arthur Lemmens" wrote: > Erm, no. I just implemented the first thing that I could get > working. Actually, I don't even know what the Guibas/Sedgewick > algorithm is. Should I Google it up? Not necessary, I think. It's a paper cited in some articles, but the paper itself is not available online, even if you're willing to pay for it. From what I've gathered it's basically about a technique where you don't have to go upwards if you insert keys which is interesting if you try to implement concurrent access to btrees and want to lock as few nodes as possible. I think that /might/ be interesting for low-level btrees, but probably not for Rucksack's btrees. From alemmens at xs4all.nl Fri Aug 4 22:37:41 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Sat, 05 Aug 2006 00:37:41 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: References: Message-ID: Edi Weitz wrote: >>> -(defgeneric index-delete (index key value &key if-does-not-exist) >>> - (:documentation "Remove a key/value pair from an index. > > But then the documentation shouldn't say "removes a key/value pair", > but something like "removes value from key, if keys are unique, > removes the key as well". Yes, that's right. > BTW, what happens if I have a btree with non-unique keys and remove > the last value from a key? The key should be removed too, I think. Unless you want to take a shot at this, I'll try to implement this tomorrow or next week. (Or we could do it together on Sunday.) Arthur From alemmens at xs4all.nl Fri Aug 4 22:38:59 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Sat, 05 Aug 2006 00:38:59 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: References: Message-ID: Edi Weitz wrote: >> Actually, I don't even know what the Guibas/Sedgewick algorithm is. >> Should I Google it up? > > Not necessary, I think. It's a paper cited in some articles, but the > paper itself is not available online, even if you're willing to pay > for it. From what I've gathered it's basically about a technique > where you don't have to go upwards if you insert keys which is > interesting if you try to implement concurrent access to btrees and > want to lock as few nodes as possible. > > I think that /might/ be interesting for low-level btrees, but probably > not for Rucksack's btrees. OK. Thanks for the info. Arthur From edi at agharta.de Fri Aug 4 22:57:01 2006 From: edi at agharta.de (Edi Weitz) Date: Sat, 05 Aug 2006 00:57:01 +0200 Subject: [rucksack-devel] Btrees In-Reply-To: (Arthur Lemmens's message of "Sat, 05 Aug 2006 00:37:41 +0200") References: Message-ID: On Sat, 05 Aug 2006 00:37:41 +0200, "Arthur Lemmens" wrote: > The key should be removed too, I think. Agreed. > Unless you want to take a shot at this, I'll try to implement this > tomorrow or next week. (Or we could do it together on Sunday.) I'm busy with other stuff, so it's fine for me if you do it. From alemmens at xs4all.nl Tue Aug 8 10:44:00 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 08 Aug 2006 12:44:00 +0200 Subject: [rucksack-devel] Re: btree-delete bug In-Reply-To: References: Message-ID: > Reinserting works well, but 1 out of, say, 10 times I still get a > problem while deleting very much stuff from the btree. Did you try > that earlier with your tests? My impression is that your original > delete works well as long as you don't delete very much, but once > you start deleting a lot (say more than 60 percent or so), you can > run into problems, depending on the exact structure of the btree. It looks like sometimes leaf nodes could become totally empty without being merged with another node. I fixed this by changing < to <= in NODE-HAS-MIN-SIZE-P: (defun node-has-min-size-p (btree node) (<= (btree-node-index-count node) (floor (btree-max-node-size btree) 2))) This makes the test in ENLARGE-NODE less rigid and means that JOIN-NODES will also be called when nodes happen to become less than half full instead of exactly half full. This seems to work well. But I still haven't reached the finish. Once every 20 runs or so I now get a problem when re-inserting. Oh well... At least I'm making progress. Arthur From alemmens at xs4all.nl Tue Aug 8 13:57:42 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 08 Aug 2006 15:57:42 +0200 Subject: [rucksack-devel] Re: btree-delete bug In-Reply-To: References: Message-ID: I wrote: > But I still haven't reached the finish. Once every 20 runs or so I > now get a problem when re-inserting. This turned out to be a rarely occurring problem when recursively splitting parent nodes during BTREE-INSERT. I think I solved it now. Running the new test 1000 times (each time with different random inserts and deletes) doesn't show any new problems, so I guess the new code is good enough to commit to CVS. While I still had the btree stuff in my head, I also implemented the :MIN, :MAX, :INCLUDE-MIN, :INCLUDE-MAX and :DESCENDING arguments for BTREE-MAP. And I added a few more CL mirror functions like P-MAPC, P-MAPCAR, P-DELETE-IF, etcetera. Arthur From alemmens at xs4all.nl Tue Aug 8 14:15:08 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 08 Aug 2006 16:15:08 +0200 Subject: [rucksack-devel] Rucksack error In-Reply-To: References: <137061277@web.de> Message-ID: Edi Weitz wrote: > Suppose you're writing a big aggregate object (like a btree) to the > heap. A, B, and C are parts of this object where A is a Rucksack > root. A points to B and B points to C, i.e. the garbage collector in > its marking phase reaches C through B. > > Now suppose that A and C have been created pretty early while B has > been created much later, i.e. it's far behind in the dirty queue of > the transaction. This is not unusual, especially for btrees. > > When the transaction is committed, A and C get written to disk. > HANDLE-WRITTEN-OBJECT adds C to the roots of the heap (A is there > anyway) if necessary so it will be marked live. > > However, this only applies to the /current/ garbage collection. It is > not impossible (and this is what happens in the TEST-BTREE-INSERT > case) that another GC will be started while B is still not written to > disk. This time C will simply be marked dead in the > :MARKING-OBJECT-TABLE phase and it won't be marked live in the > :SCANNING phase because (B still not being there) it can't be reached > from the root A. > > This will eventually result in C being deallocated and overwritten by > other objects in the same transaction commit. That's it... :( I agree with your analysis. We already discussed this privately, but just for the record: At the moment I think that the best solution for this problem is to make sure that dirty objects (like B in your example) are serialized to disk when the GC sees them during the scanning phase. Sooner or later they must be written to disk anyway, so we might as well do it when the GC needs them to be on disk. The only potential problem I see is that this could recursively trigger another GC step (when we're already within a GC step). But I suppose we could use some kind of flag to indicate that the GC is active, so we know that we shouldn't call the GC when that flag is true. Unless someone has a better idea, I think I'll try to implement this. Arthur From alemmens at xs4all.nl Tue Aug 8 14:20:27 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 08 Aug 2006 16:20:27 +0200 Subject: [rucksack-devel] Rucksack error In-Reply-To: References: <137061277@web.de> Message-ID: Edi Weitz wrote: >> Anyway, I'll try to come up with a solution as outlined above > > See attachment. You have to apply the two transaction ID patches > first. I think I won't use this patch, because it doesn't really solve the GC problem (you mention this in another email, if I understand it correctly). If I'm wrong about this and you think I should commit this patch, please say so. Arthur From edi at agharta.de Tue Aug 8 14:25:04 2006 From: edi at agharta.de (Edi Weitz) Date: Tue, 08 Aug 2006 16:25:04 +0200 Subject: [rucksack-devel] Rucksack error In-Reply-To: (Arthur Lemmens's message of "Tue, 08 Aug 2006 16:20:27 +0200") References: <137061277@web.de> Message-ID: On Tue, 08 Aug 2006 16:20:27 +0200, "Arthur Lemmens" wrote: > I think I won't use this patch, because it doesn't really solve the > GC problem (you mention this in another email, if I understand it > correctly). > > If I'm wrong about this and you think I should commit this patch, > please say so. No, you're right. The patch didn't work. Before you implement something please also look at these to messages: http://common-lisp.net/pipermail/rucksack-devel/2006-July/000108.html http://common-lisp.net/pipermail/rucksack-devel/2006-July/000110.html Cheers, Edi (who is busy). From alemmens at xs4all.nl Tue Aug 8 14:31:05 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 08 Aug 2006 16:31:05 +0200 Subject: [rucksack-devel] GC problems In-Reply-To: References: <137061277@web.de> Message-ID: Edi Weitz wrote: > Yeah, I realize I'm soliloquizing... :) Now it's my turn ;-) > 1. Hook into the host (Lisp) GC (in an implementation-dependent way, > obviously) I try to avoid implementation-dependent solutions as much as possible, and hooking into the implementation's GC is not the kind of thing that is easy to port (unlike simple locking, for example). So I'm not going to do this unless there really is no other way. > 2. Similar, but portable and coupled to transactions: Whenever a > PERSISTENT-THING object is created, annotate its object ID in an > IDS-IN-USE structure (for example a hash table) belonging to the > current transaction. During (Rucksack) GC, add the IDs in this > structure to the roots. IDS-IN-USE will obviously vanish once the > transaction is finished. > > The idea is that transient references to persistent objects which > were created in the current transaction are also traversed during > the scanning phase of the GC. I think that my solution of saving dirty in-memory objects to disk when the scanner encounters them will be easier and more reliable. Do you agree or do you think that your #2 approach is still worth exploring? > Both "solutions" fail because objects are in a way written to disk too > late Exactly. That's why I prefer to write them to disk early enough ;-) > A. We could abandon the idea of a concurrent GC and only run the GC > when there's no transaction, similar to what Plob! does. Yeah, that's an "if everything else fails" solution. But I'm not ready for that yet. > B. We could abandon the idea of roots and reachability and instead > explicitely delete objects, similar to what AllegroCache does. That's an "if everything else (including off-line GC) fails" solution. I don't think I'll ever be ready for that... Arthur From alemmens at xs4all.nl Tue Aug 8 14:47:44 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 08 Aug 2006 16:47:44 +0200 Subject: [rucksack-devel] GC problems In-Reply-To: References: <137061277@web.de> Message-ID: Edi Weitz wrote: > (defun check-gc (n) > (with-rucksack (rucksack *test-suite* :if-exists :supersede) > (with-transaction () > ;; after this, INNER can be reached directly from the root > (let* ((inner (p-cons "Waldorf" "Statler")) > (root (p-cons 42 inner))) > (add-rucksack-root root rucksack))) > (with-transaction () > (let* ((root (first (rucksack-roots rucksack))) > (inner (p-cdr root)) > (array (p-make-array n))) > ;; after this, INNER can't be reached from the root anymore > (setf (p-cdr root) 43) > ;; now let the GC do some work > (dotimes (i n) > (let ((string (format nil "~R" i))) > (setf (p-aref array i) (p-cons string string)))) > ;; hook INNER back to the root again before we finish the > ;; transaction > (setf (p-car root) array > (p-cdr root) (p-cons 'bar (p-cons 'foo inner))))) ; [***] > (with-transaction () > (let* ((root (first (rucksack-roots rucksack))) > (inner (p-cdr (p-cdr (p-cdr root))))) > ;; we expect the list ("Waldorf" "Statler") here > (list (p-car inner) (p-cdr inner)))))) Thanks, that's a nice test case. (It's already committed to CVS from one of your other patches.) > What happens is similar to what I described on July 20, but not the > same: In the second transaction, the GC has to do a lot of work if N > is large enough, one pass won't suffice. But then on the first pass > already, INNER can't be reached from the one and only root anymore > because it can only be reached through the P-CONS objects created in > the [***] line, and these are at the end of the dirty queue and > haven't been written to disc when the GC scans the heap for the first > time. > > So, the GC marks INNER dead and frees its space. INNER's block will > then be re-allocated for some other object from the dirty queue. > Bang... > > The important difference between the July 20 case and this one is that > INNER was not written in the current transaction - it's an "old" > object. Still, the GC is wrong when it frees its space. Yes. Would you agree that this problem can also be solved by writing dirty objects to disk when the scanner sees them? Or am I missing something? > I /think/ there were discussion about similar cases on this mailing > list two months ago or so, but IIRC they were about more "esoteric" > scenarios where you hold references to persistent objects while you're > not within a transaction or somesuch. IMHO, the example above is a > completely legitimate usage of Rucksack, though. Yes, I agree. Arthur From edi at agharta.de Wed Aug 9 13:21:36 2006 From: edi at agharta.de (Edi Weitz) Date: Wed, 09 Aug 2006 15:21:36 +0200 Subject: [rucksack-devel] GC problems In-Reply-To: (Arthur Lemmens's message of "Tue, 08 Aug 2006 16:47:44 +0200") References: <137061277@web.de> Message-ID: On Tue, 08 Aug 2006 16:47:44 +0200, "Arthur Lemmens" wrote: > Edi Weitz wrote: > >> (defun check-gc (n) >> (with-rucksack (rucksack *test-suite* :if-exists :supersede) >> (with-transaction () >> ;; after this, INNER can be reached directly from the root >> (let* ((inner (p-cons "Waldorf" "Statler")) >> (root (p-cons 42 inner))) >> (add-rucksack-root root rucksack))) >> (with-transaction () >> (let* ((root (first (rucksack-roots rucksack))) >> (inner (p-cdr root)) >> (array (p-make-array n))) >> ;; after this, INNER can't be reached from the root anymore >> (setf (p-cdr root) 43) >> ;; now let the GC do some work >> (dotimes (i n) >> (let ((string (format nil "~R" i))) >> (setf (p-aref array i) (p-cons string string)))) >> ;; hook INNER back to the root again before we finish the >> ;; transaction >> (setf (p-car root) array >> (p-cdr root) (p-cons 'bar (p-cons 'foo inner))))) ; [***] >> (with-transaction () >> (let* ((root (first (rucksack-roots rucksack))) >> (inner (p-cdr (p-cdr (p-cdr root))))) >> ;; we expect the list ("Waldorf" "Statler") here >> (list (p-car inner) (p-cdr inner)))))) > > > [snip] > > Would you agree that this problem can also be solved by writing > dirty objects to disk when the scanner sees them? Or am I missing > something? I'm not sure. When you're in the DOTIMES loop above (which is supposed to take a /long/ time), the only reference to INNER is from an object which is in RAM. Whatever you write to disk, you won't be able to reach INNER unless you have left the loop. But at that point it'll probably be too late. From edi at agharta.de Wed Aug 9 13:45:34 2006 From: edi at agharta.de (Edi Weitz) Date: Wed, 09 Aug 2006 15:45:34 +0200 Subject: [rucksack-devel] GC problems In-Reply-To: (Arthur Lemmens's message of "Tue, 08 Aug 2006 16:31:05 +0200") References: <137061277@web.de> Message-ID: On Tue, 08 Aug 2006 16:31:05 +0200, "Arthur Lemmens" wrote: > Edi Weitz wrote: > >> A. We could abandon the idea of a concurrent GC and only run the GC >> when there's no transaction, similar to what Plob! does. > > Yeah, that's an "if everything else fails" solution. But I'm not > ready for that yet. Isn't what you just committed to CVS pretty similar to that? "Don't do any GC at all while a transaction is writing objects to disk." Cheers, Edi. From alemmens at xs4all.nl Wed Aug 9 13:59:12 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Wed, 09 Aug 2006 15:59:12 +0200 Subject: [rucksack-devel] GC problems In-Reply-To: References: <137061277@web.de> Message-ID: Edi Weitz wrote: >> Would you agree that this problem can also be solved by writing >> dirty objects to disk when the scanner sees them? Or am I missing >> something? > > I'm not sure. When you're in the DOTIMES loop above (which is > supposed to take a /long/ time), the only reference to INNER is from > an object which is in RAM. Whatever you write to disk, you won't be > able to reach INNER unless you have left the loop. But at that point > it'll probably be too late. Yeah, maybe. Anyway, after some more thinking I've decided to solve the GC problem for now by not doing any GC while a transaction is writing objects to disk. Instead I keep track of the amount of disk space allocated by the committing transaction. Then I do a (partial) GC immediately after committing the transaction. This turns out to be good enough to pass your CHECK-GC test (and TEST-BTREE & friends now finally work for large values of N). I also added a SERIAL-TRANSACTION-RUCKSACK class that allows for only one transaction at a time (by using a transaction lock). This allows for a fast track towards a working Rucksack implementation. Once we get all the basics working, we can add parallel transactions. At that point, we may also have to find a more fine-grained solution for the GC problem. And for you non-Lispworks users of Rucksack (if there are any left): to implement serial transactions I had to use PROCESS-LOCK and PROCESS-UNLOCK. If you don't use Lispworks you'll have to add your own implementation-dependent definitions of these functions. But that shouldn't be too difficult for any implementation that supports threads, I hope. Patches welcome, of course. Arthur From alemmens at xs4all.nl Wed Aug 9 14:06:33 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Wed, 09 Aug 2006 16:06:33 +0200 Subject: [rucksack-devel] GC problems In-Reply-To: References: <137061277@web.de> Message-ID: Edi Weitz wrote: >>> A. We could abandon the idea of a concurrent GC and only run the GC >>> when there's no transaction, similar to what Plob! does. >> >> Yeah, that's an "if everything else fails" solution. But I'm not >> ready for that yet. > > Isn't what you just committed to CVS pretty similar to that? > > "Don't do any GC at all while a transaction is writing objects to > disk." Yes. I misunderstood your remark about PLOB as not doing any GC while a rucksack is open. See also my other message. And, just to repeat myself: I do intend to come up with a more fine-grained solution, but my current priority is to get all the basics in place so we get a version of Rucksack that can be used for some real (even if relatively small) projects. Arthur From ocorrain at gmail.com Fri Aug 11 12:50:59 2006 From: ocorrain at gmail.com (Tiarnan O'Corrain) Date: Fri, 11 Aug 2006 13:50:59 +0100 Subject: [rucksack-devel] Rucksack on sbcl: serialize error Message-ID: Hi-- I'm trying to get rucksack working on SBCL/NetBSD, and am running into an error that seems to be an old chestnut (question was posted in July of this year): There is no applicable method for the generic function # when called with arguments (# #). [Condition of type SIMPLE-ERROR] Someone mentioned that there was a fix/workaround for this, but it didn't get posted (or if it did, I couldn't find it). Could someone post it here, please? regards Tiarn?n -------------- next part -------------- An HTML attachment was scrubbed... URL: From alemmens at xs4all.nl Fri Aug 11 13:03:42 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Fri, 11 Aug 2006 15:03:42 +0200 Subject: [rucksack-devel] Rucksack on sbcl: serialize error In-Reply-To: References: Message-ID: Tiarnan O'Corrain wrote: > I'm trying to get rucksack working on SBCL/NetBSD, and am running into an > error that seems to be an old chestnut (question was posted in July of this > year): > > There is no applicable method for the generic function > # > when called with arguments > (# #). > [Condition of type SIMPLE-ERROR] > > Someone mentioned that there was a fix/workaround for this, but it didn't > get posted (or if it did, I couldn't find it). Could someone post it here, > please? I've just committed the fix (using HOST-NAMESTRING instead of PATHNAME-HOST, conditionalized on #+SBCL) to CVS, as part of some improvements to the indexing mechanism. Please let me know if it doesn't work for you. Arthur From ocorrain at gmail.com Fri Aug 11 15:47:29 2006 From: ocorrain at gmail.com (Tiarnan O'Corrain) Date: Fri, 11 Aug 2006 16:47:29 +0100 Subject: [rucksack-devel] Rucksack on sbcl: serialize error In-Reply-To: References: Message-ID: Hi Arthur-- your fix works for the pathname problem, unfortunately I've encountered another bug later in the test suite. I've started a separate thread for that. thanks, Tiarn?n From ocorrain at gmail.com Fri Aug 11 15:46:19 2006 From: ocorrain at gmail.com (Tiarnan O'Corrain) Date: Fri, 11 Aug 2006 16:46:19 +0100 Subject: [rucksack-devel] Rucksack tests fail when trying to deserialize object Message-ID: Hi-- I'm running SBCL 0.9.15 on NetBSD 3.01. The rucksack test suite fails with: end of file on # [Condition of type END-OF-FILE] Backtrace (from slime): 0: (RUCKSACK::DESERIALIZE # T NIL) 1: (RUCKSACK::DESERIALIZE-LIST #) 2: (RUCKSACK::LOAD-OBJECTS #P"/tmp/rucksack-test-suite/schemas") 3: (RUCKSACK::OPEN-SCHEMA-TABLE #P"/tmp/rucksack-test-suite/schemas" :IF-EXISTS :OVERWRITE :IF-DOES-NOT-EXIST :CREATE) 4: ((SB-PCL::FAST-METHOD INITIALIZE-INSTANCE :AFTER (RUCKSACK:STANDARD-CACHE)) #) 5: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB-PCL::.ARG0. SB-PCL::.DFUN-REST-ARG.)) #) 6: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:DIRECTORY #1=#P"/$ 7: (RUCKSACK:OPEN-CACHE #P"/tmp/rucksack-test-suite/" :CLASS RUCKSACK:STANDARD-CACHE :RUCKSACK # # # # # # (:DIR$ 11: (RUCKSACK:OPEN-RUCKSACK # :IF-EXISTS :SUPERSEDE) 12: (TEST-RUCKSACK::TEST-BASICS) 13: (SB-FASL::LOAD-FASL-GROUP #) 14: (SB-FASL::LOAD-AS-FASL # NIL #) 15: (SB-FASL::INTERNAL-LOAD #P"/home/ocorrait/src/rucksack/test.fasl" #P"/home/ocorrait/src/rucksack/test.fasl" :ERROR NIL NIL :BINARY NIL) 16: (SB-FASL::INTERNAL-LOAD #P"/home/ocorrait/src/rucksack/test.fasl" #P"/home/ocorrait/src/rucksack/test.fasl" :ERROR NIL NIL NIL :DEFAULT) 17: (LOAD #P"/home/ocorrait/src/rucksack/test.fasl") 18: ((SB-PCL::FAST-METHOD ASDF:PERFORM (ASDF:LOAD-OP ASDF:CL-SOURCE-FILE)) # # # # # #) 22: (ASDF:OPERATE ASDF:LOAD-OP RUCKSACK) When I look at the temporary store, I see that the file is empty $ ls -l /tmp/rucksack-test-suite/ total 12 -rw-r--r-- 1 ocorrait wheel 259 Aug 11 16:41 heap -rw-r--r-- 1 ocorrait wheel 10 Aug 11 16:41 objects -rw-r--r-- 1 ocorrait wheel 0 Aug 4 16:25 schemas -rw-r--r-- 1 ocorrait wheel 73 Aug 11 16:41 store Any ideas? regards Tiarn?n From alemmens at xs4all.nl Fri Aug 11 20:02:15 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Fri, 11 Aug 2006 22:02:15 +0200 Subject: [rucksack-devel] Rucksack tests fail when trying to deserialize object In-Reply-To: References: Message-ID: Tiarn?n O'Corrain wrote: > The rucksack test suite fails with: > > end of file on # > [Condition of type END-OF-FILE] > > Backtrace (from slime): > 0: (RUCKSACK::DESERIALIZE # T NIL) > 1: (RUCKSACK::DESERIALIZE-LIST #) > 2: (RUCKSACK::LOAD-OBJECTS #P"/tmp/rucksack-test-suite/schemas") > 3: (RUCKSACK::OPEN-SCHEMA-TABLE #P"/tmp/rucksack-test-suite/schemas" > :IF-EXISTS :OVERWRITE :IF-DOES-NOT-EXIST :CREATE) > 4: ((SB-PCL::FAST-METHOD INITIALIZE-INSTANCE :AFTER > (RUCKSACK:STANDARD-CACHE)) #) > 5: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. > SB-PCL::.ARG0. SB-PCL::.DFUN-REST-ARG.)) #) > 6: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # argument> # # RUCKSACK:STANDARD-CACHE> (:DIRECTORY #1=#P"/$ > 7: (RUCKSACK:OPEN-CACHE #P"/tmp/rucksack-test-suite/" :CLASS > RUCKSACK:STANDARD-CACHE :RUCKSACK > # 8: ((SB-PCL::FAST-METHOD INITIALIZE-INSTANCE :AFTER > (RUCKSACK:STANDARD-RUCKSACK)) (#(NIL 0) . #()) # > # 9: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. > SB-PCL::.ARG0. SB-PCL::.DFUN-REST-ARG.)) # > # # 10: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # argument> # # RUCKSACK::SERIAL-TRANSACTION-RUCKSACK> (:DIR$ > 11: (RUCKSACK:OPEN-RUCKSACK # :IF-EXISTS :SUPERSEDE) > > When I look at the temporary store, I see that the file is empty > > $ ls -l /tmp/rucksack-test-suite/ > total 12 > -rw-r--r-- 1 ocorrait wheel 259 Aug 11 16:41 heap > -rw-r--r-- 1 ocorrait wheel 10 Aug 11 16:41 objects > -rw-r--r-- 1 ocorrait wheel 0 Aug 4 16:25 schemas > -rw-r--r-- 1 ocorrait wheel 73 Aug 11 16:41 store Hmmm.... I'm just guessing here, but maybe the :IF-EXISTS :SUPERSEDE case for OPEN-RUCKSACK doesn't delete the schema file correctly? If there's an empty schema table file left, OPEN-CACHE will try to load the schemas from that file, even if it's empty. And then it will fail because the file is empty. Does the test suite also fail when you first remove all files from the test-suite directory by hand? The code used to delete all files in the specified rucksack directory is: (mapc #'delete-file (directory (make-pathname :name :wild :type :wild :version :wild :defaults directory)) I wouldn't be very surprised if SBCL doesn't interpret this code the way I intended it. Unfortunately, I don't have time this evening to test Rucksack on SBCL. And I'll be away for the next 10 days or so, so I won't be able to help any further until I come back. Arthur From nem at lisp.geek.nz Wed Aug 23 20:23:50 2006 From: nem at lisp.geek.nz (Geoff Cant) Date: Thu, 24 Aug 2006 08:23:50 +1200 Subject: [rucksack-devel] SBCL Support for process-{lock, unlock} (resend as list member :) Message-ID: Hi all, here's a tiny patch for rucksack.lisp to get process-lock and process-unlock working on SBCL. Cheers, -- Geoff -------------- next part -------------- A non-text attachment was scrubbed... Name: not available Type: application/pgp-signature Size: 185 bytes Desc: not available URL: -------------- next part -------------- A non-text attachment was scrubbed... Name: sbcl-process-lock.patch Type: text/x-patch Size: 622 bytes Desc: not available URL: -------------- next part -------------- A non-text attachment was scrubbed... Name: not available Type: application/pgp-signature Size: 185 bytes Desc: not available URL: From nem at lisp.geek.nz Wed Aug 23 20:23:50 2006 From: nem at lisp.geek.nz (Geoff Cant) Date: Thu, 24 Aug 2006 08:23:50 +1200 Subject: [rucksack-devel] SBCL Support for process-{lock,unlock} Message-ID: Hi all, here's a tiny patch for rucksack.lisp to get process-lock and process-unlock working on SBCL. Cheers, -- Geoff -------------- next part -------------- A non-text attachment was scrubbed... Name: not available Type: application/pgp-signature Size: 185 bytes Desc: not available URL: -------------- next part -------------- A non-text attachment was scrubbed... Name: sbcl-process-lock.patch Type: text/x-patch Size: 622 bytes Desc: not available URL: -------------- next part -------------- A non-text attachment was scrubbed... Name: not available Type: application/pgp-signature Size: 185 bytes Desc: not available URL: From alemmens at xs4all.nl Thu Aug 24 15:43:46 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 24 Aug 2006 17:43:46 +0200 Subject: [rucksack-devel] SBCL Support for process-{lock,unlock} In-Reply-To: References: Message-ID: Geoff Cant wrote: > Hi all, here's a tiny patch for rucksack.lisp to get process-lock and > process-unlock working on SBCL. Thanks, I committed your patch. Do the basic tests (TEST-BASICS) run correctly with your version of SBCL, by the way? Arthur Lemmens From kingruedi at c-plusplus.de Thu Aug 24 16:51:56 2006 From: kingruedi at c-plusplus.de (=?ISO-8859-1?Q?R=FCdiger_Sonderfeld?=) Date: Thu, 24 Aug 2006 18:51:56 +0200 Subject: [rucksack-devel] SBCL Support for process-{lock,unlock} In-Reply-To: References: Message-ID: I get the following error message: Control stack exhausted (no more space for function call frames). This is probably due to heavily nested or infinitely recursive function calls, or a tail call that SBCL cannot or has not optimized away. [Condition of type SB-KERNEL::CONTROL-STACK-EXHAUSTED] Restarts: 0: [ABORT] Abort # 1: [RETRY] Retry # 2: [RETRY] Retry performing # on #. 3: [ACCEPT] Continue, treating # on # as having been successful. 4: [ABORT-REQUEST] Abort handling SLIME request. 5: [ABORT] Exit debugger, returning to top level. Backtrace: 0: (SB-KERNEL::CONTROL-STACK-EXHAUSTED-ERROR) 1: ("foreign function: call_into_lisp") 2: ("foreign function: post_signal_tramp") 3: (SB-INT:%FIND-PACKAGE-OR-LOSE #) 4: (PACKAGE-NAME #) 5: (SB-INT:SANE-PACKAGE) 6: (INTERN "KEY<") 7: (SB-INT:SYMBOLICATE) 8: (SB-INT:KEYWORDICATE) 9: (SB-PCL::ANALYZE-LAMBDA-LIST (RUCKSACK:BTREE &REST RUCKSACK::INITARGS &KEY RUCKSACK::KEY< RUCKSACK::KEY-KEY RUCKSACK::VALUE= RUCKSACK::VALUE-KEY &ALLOW-OTHER-KEYS)) 10: (SB-PCL::CHECK-INITARGS-VALUES # (# # # # #)) 11: (SB-PCL::CHECK-INITARGS-1 # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T) (# # # # #) T T) 12: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 13: ((FLET RUCKSACK::DO-IT)) 14: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 15: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 16: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 17: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 18: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 19: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 20: ((FLET RUCKSACK::DO-IT)) 21: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 22: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 23: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 24: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 25: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 26: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 27: ((FLET RUCKSACK::DO-IT)) 28: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 29: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 30: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 31: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 32: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 33: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 34: ((FLET RUCKSACK::DO-IT)) 35: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 36: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 37: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 38: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 39: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 40: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 41: ((FLET RUCKSACK::DO-IT)) 42: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 43: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 44: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 45: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 46: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 47: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 48: ((FLET RUCKSACK::DO-IT)) 49: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 50: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 51: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 52: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 53: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 54: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 55: ((FLET RUCKSACK::DO-IT)) 56: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 57: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 58: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 59: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 60: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 61: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 62: ((FLET RUCKSACK::DO-IT)) 63: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 64: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 65: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 66: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 67: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 68: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 69: ((FLET RUCKSACK::DO-IT)) 70: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 71: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 72: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 73: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 74: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 75: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 76: ((FLET RUCKSACK::DO-IT)) 77: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 78: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 79: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 80: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 81: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 82: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 83: ((FLET RUCKSACK::DO-IT)) 84: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 85: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 86: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 87: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 88: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 89: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 90: ((FLET RUCKSACK::DO-IT)) 91: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 92: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 93: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 94: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 95: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 96: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 97: ((FLET RUCKSACK::DO-IT)) 98: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 99: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 100: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 101: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 102: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 103: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 104: ((FLET RUCKSACK::DO-IT)) 105: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 106: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 107: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 108: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 109: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 110: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 111: ((FLET RUCKSACK::DO-IT)) 112: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 113: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 114: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 115: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 116: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 117: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 118: ((FLET RUCKSACK::DO-IT)) 119: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 120: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 121: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 122: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 123: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 124: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 125: ((FLET RUCKSACK::DO-IT)) 126: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 127: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 128: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 129: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 130: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 131: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 132: ((FLET RUCKSACK::DO-IT)) 133: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 134: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 135: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 136: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 137: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 138: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 139: ((FLET RUCKSACK::DO-IT)) 140: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 141: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 142: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 143: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 144: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 145: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 146: ((FLET RUCKSACK::DO-IT)) 147: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 148: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 149: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 150: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 151: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 152: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 153: ((FLET RUCKSACK::DO-IT)) 154: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 155: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 156: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 157: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 158: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 159: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 160: ((FLET RUCKSACK::DO-IT)) 161: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 162: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 163: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 164: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 165: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 166: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 167: ((FLET RUCKSACK::DO-IT)) 168: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 169: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 170: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 171: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 172: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 173: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 174: ((FLET RUCKSACK::DO-IT)) 175: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 176: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 177: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 178: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 179: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 180: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 181: ((FLET RUCKSACK::DO-IT)) 182: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 183: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 184: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 185: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 186: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 187: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 188: ((FLET RUCKSACK::DO-IT)) 189: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 190: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 191: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 192: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 193: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 194: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 195: ((FLET RUCKSACK::DO-IT)) 196: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 197: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 198: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 199: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 200: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 201: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 202: ((FLET RUCKSACK::DO-IT)) 203: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 204: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 205: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 206: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 207: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 208: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 209: ((FLET RUCKSACK::DO-IT)) 210: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 211: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 212: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 213: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 214: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 215: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 216: ((FLET RUCKSACK::DO-IT)) 217: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 218: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 219: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 220: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 221: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 222: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 223: ((FLET RUCKSACK::DO-IT)) 224: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 225: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 226: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 227: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 228: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 229: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 230: ((FLET RUCKSACK::DO-IT)) 231: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 232: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 233: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 234: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 235: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 236: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 237: ((FLET RUCKSACK::DO-IT)) 238: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 239: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 240: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 241: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 242: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 243: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 244: ((FLET RUCKSACK::DO-IT)) 245: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 246: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 247: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 248: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 249: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 250: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 251: ((FLET RUCKSACK::DO-IT)) 252: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 253: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 254: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 255: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 256: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 257: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 258: ((FLET RUCKSACK::DO-IT)) 259: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 260: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 261: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 262: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 263: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 264: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 265: ((FLET RUCKSACK::DO-IT)) 266: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 267: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 268: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 269: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 270: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 271: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 272: ((FLET RUCKSACK::DO-IT)) 273: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 274: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 275: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 276: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 277: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 278: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 279: ((FLET RUCKSACK::DO-IT)) 280: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 281: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 282: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 283: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 284: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 285: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 286: ((FLET RUCKSACK::DO-IT)) 287: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 288: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 289: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 290: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 291: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 292: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 293: ((FLET RUCKSACK::DO-IT)) 294: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 295: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 296: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 297: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 298: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 299: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 300: ((FLET RUCKSACK::DO-IT)) 301: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 302: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 303: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 304: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 305: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 306: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 307: ((FLET RUCKSACK::DO-IT)) 308: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 309: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 310: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 311: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 312: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 313: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 314: ((FLET RUCKSACK::DO-IT)) 315: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 316: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 317: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 318: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 319: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 320: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 321: ((FLET RUCKSACK::DO-IT)) 322: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 323: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 324: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 325: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 326: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 327: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 328: ((FLET RUCKSACK::DO-IT)) 329: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 330: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 331: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 332: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 333: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 334: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 335: ((FLET RUCKSACK::DO-IT)) 336: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 337: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 338: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 339: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 340: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 341: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 342: ((FLET RUCKSACK::DO-IT)) 343: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 344: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 345: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 346: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 347: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 348: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 349: ((FLET RUCKSACK::DO-IT)) 350: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 351: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 352: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 353: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 354: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 355: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 356: ((FLET RUCKSACK::DO-IT)) 357: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 358: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 359: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 360: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 361: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 362: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 363: ((FLET RUCKSACK::DO-IT)) 364: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 365: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 366: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 367: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 368: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 369: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 370: ((FLET RUCKSACK::DO-IT)) 371: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 372: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 373: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 374: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 375: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 376: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 377: ((FLET RUCKSACK::DO-IT)) 378: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 379: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 380: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 381: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 382: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 383: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 384: ((FLET RUCKSACK::DO-IT)) 385: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 386: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 387: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 388: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 389: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 390: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 391: ((FLET RUCKSACK::DO-IT)) 392: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 393: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 394: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 395: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 396: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 397: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 398: ((FLET RUCKSACK::DO-IT)) 399: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 400: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 401: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 402: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 403: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 404: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 405: ((FLET RUCKSACK::DO-IT)) 406: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 407: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 408: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 409: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 410: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 411: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 412: ((FLET RUCKSACK::DO-IT)) 413: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 414: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 415: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 416: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 417: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 418: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 419: ((FLET RUCKSACK::DO-IT)) 420: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 421: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 422: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 423: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 424: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 425: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 426: ((FLET RUCKSACK::DO-IT)) 427: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 428: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 429: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 430: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 431: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 432: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 433: ((FLET RUCKSACK::DO-IT)) 434: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 435: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 436: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 437: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 438: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 439: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 440: ((FLET RUCKSACK::DO-IT)) 441: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) 442: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-MAYBE-INDEX-CHANGED-SLOT (RUCKSACK:STANDARD-RUCKSACK T T T T T T T)) # # # # #> # NIL STRING< NIL T) 443: ((SB-PCL::FAST-METHOD (SETF SB-MOP:SLOT-VALUE-USING- CLASS) :AROUND (T RUCKSACK:PERSISTENT-CLASS T T)) # # STRING< # #> #) 444: ((SB-PCL::FAST-METHOD SHARED-INITIALIZE (SB-PCL::SLOT-OBJECT T)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P- EQL :UNIQUE-KEYS-P T)) 445: ((LAMBDA (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. SB- PCL::.ARG0. SB-PCL::.ARG1. SB-PCL::.DFUN-REST-ARG.)) # # #> T (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 446: ((SB-PCL::FAST-METHOD MAKE-INSTANCE (CLASS)) # # # (:RUCKSACK # :KEY< STRING< :VALUE= RUCKSACK:P-EQL :UNIQUE-KEYS-P T)) 447: ((FLET RUCKSACK::DO-IT)) 448: ((SB-PCL::FAST-METHOD RUCKSACK:RUCKSACK-SLOT-INDEX (RUCKSACK:STANDARD-RUCKSACK T T)) # # # # # NIL) --more-- Am 24.08.2006 um 17:43 schrieb Arthur Lemmens: > Geoff Cant wrote: > >> Hi all, here's a tiny patch for rucksack.lisp to get process-lock and >> process-unlock working on SBCL. > > Thanks, I committed your patch. > > Do the basic tests (TEST-BASICS) run correctly with your version of > SBCL, > by the way? > > Arthur Lemmens > > _______________________________________________ > rucksack-devel mailing list > rucksack-devel at common-lisp.net > http://common-lisp.net/cgi-bin/mailman/listinfo/rucksack-devel From alemmens at xs4all.nl Thu Aug 24 17:24:48 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Thu, 24 Aug 2006 19:24:48 +0200 Subject: [rucksack-devel] SBCL Support for process-{lock,unlock} In-Reply-To: References: Message-ID: "R?diger Sonderfeld" wrote: > I get the following error message: > > Control stack exhausted (no more space for function call frames). > This is probably due to heavily nested or infinitely recursive > function calls, or a tail call that SBCL cannot or has not optimized > away. > [Condition of type SB-KERNEL::CONTROL-STACK-EXHAUSTED] Is this caused by a call to TEST-BASICS? Or by something else? (And this is with today's version of Rucksack, right?) Arthur From b.butterfield at f5.com Thu Aug 24 17:25:36 2006 From: b.butterfield at f5.com (Bruce Butterfield) Date: Thu, 24 Aug 2006 10:25:36 -0700 Subject: [rucksack-devel] SBCL Support for process-{lock,unlock} In-Reply-To: References: Message-ID: <44EDE110.8050806@f5.com> Arthur Lemmens wrote: > Geoff Cant wrote: > >> Hi all, here's a tiny patch for rucksack.lisp to get process-lock and >> process-unlock working on SBCL. > > Thanks, I committed your patch. > > Do the basic tests (TEST-BASICS) run correctly with your version of SBCL, > by the way? > > Arthur Lemmens > > _______________________________________________ > rucksack-devel mailing list > rucksack-devel at common-lisp.net > http://common-lisp.net/cgi-bin/mailman/listinfo/rucksack-devel Works for me with Geoff's patch: (running on CentOS release 3.6 (essentially redhat enterprise; it also works on Ubuntu 6.0.6) [bruce at bab rucksack]$ sbcl This is SBCL 0.9.15, an implementation of ANSI Common Lisp. More information about SBCL is available at . SBCL is free software, provided as is, with absolutely no warranty. It is mostly in the public domain; some portions are provided under BSD-style licenses. See the CREDITS and COPYING files in the distribution for more information. * (require :asdf) ("ASDF") * (require :rucksack) basic tests ok ("SERIALIZE") * From alemmens at xs4all.nl Tue Aug 29 12:00:28 2006 From: alemmens at xs4all.nl (Arthur Lemmens) Date: Tue, 29 Aug 2006 14:00:28 +0200 Subject: [rucksack-devel] SBCL Support for process-{lock,unlock} In-Reply-To: References: Message-ID: "R?diger Sonderfeld" wrote: > I get the following error message: > > Control stack exhausted (no more space for function call frames). > This is probably due to heavily nested or infinitely recursive > function calls, or a tail call that SBCL cannot or has not optimized > away. > [Condition of type SB-KERNEL::CONTROL-STACK-EXHAUSTED] My guess is that this is caused by some of the MOP related changes I made recently to get indexing and schema updates working correctly. (You can subscribe to the rucksack-cvs mailing list at http://common-lisp.net/cgi-bin/mailman/listinfo/rucksack-cvs to follow these changes, by the way.) I'm still working on schema updates and indexing, but I hope I can get a working version of this Real Soon Now (by the end of this week?). If the infinite recursion bug still occurs then with SBCL, I'll try to debug it (if you're still interested). Arthur