[elephant-devel] Garbage collection problem
Ian Eslick
eslick at csail.mit.edu
Thu Sep 27 14:36:06 UTC 2007
On Sep 27, 2007, at 9:39 AM, Chris Laux wrote:
>> How about just giving us a profile of memory usage?
>
> The profile is at the bottom of this message, in sbcl's sb-sprof
> format.
> If you can't interpret the numbers let me know and I'll dig up the
> explanation from the web. I'm not really sure how to interpret the
> results, and it might be buggy, because asking the profiler to report
> causes the same (similar?) condition as garbage collection, that is
> the
> system hangs for minutes then works on as if nothing had happened
> (added
> later: or never recovers again...)
It looks like this comes from the initial run of your system, so
there is a bunch of space allocated there that should only be
allocated once so it's not representative of what is going on later.
(Just to be sure, it might be interesting to look at elephant-
memutil::*buffer-streams* and the sizes of all the buffer streams
therein (apply #'+ (map 'list #'elephant-memutil::buffer-stream-size
elephant-memutil::*buffer-streams*)) and see how many bytes are
allocated to the serializer buffers.)
Some suspects:
- If you are reading a ton of strings from BDB, then you'll be
allocated tons of space for each one as they have to go to/from
foreign space. If you are reading tons of instances you'll be
allocating space for the object header.
- If you are doing a significant amount of deserialization with lots
of threads than you should know that each deserialization requires a
call to (with-lock ...) to ensure that the shared pool of buffer
streams is thread safe (a problem with elephant < 0.9). This could
conceivably cause a lockup if there are lots of small
deserializations happening concurrently across threads mapping over
the same Btrees. Are you sure it's GC that's eating all the time,
or non-lisp CPU time in general?
My guess is that you are deserializing much more data than you need
during your join due to the map function reading the actual values of
the tree into memory as you walk them. If you have a large, common
word with little intersection in your final set then you'll spend
alot of time reading in and throwing away that data.
Although it breaks the abstraction barrier, using IDs will be a
definite gain. You'd just make that second BTree pairs of word-
freq / obj-oid. Then you use the OID and object type to grab the
object directly from elephant: (elephant::get-cached-instance oid
classname)
Now using and throwing away persistent objects also means that you
are filling a weak hash table (acting as cache) with objects that are
then being reclaimed and this may be more expensive under SBCL than
simple allocation. Your per-word btrees are likely to be reused
query-to-query, but your result strings much less so. Instead, you
may want to use your ID to directly grab the strings of interest and
then, if you need to annotate them with more information,
This kind of application (inverse document indexing) using join
queries is good fodder for making a contrib to elephant as I'm sure
others would want to do it. I'm not sure the elephant architecture,
as it stands, is the best way to do this though. You might be better
off, performance wise, doing this in a C full-text indexing system
and wrapping an interface to it. Then you only need to allocate
space when you read in the result strings.
A potential feature for which there are already hooks is maintaining
your own pool of lisp strings to deserialize into rather than relying
on the GC. If you did a query to a BTree and provided a hint
containing the string storage that might also relieve your memory
congestion. This wouldn't show up until we get around to releasing
the patches and features on the 0.9.1 tree and I can't predict when
that will be.
In summary, every read you make from elephant allocates memory for
the read value unless it is a persistent object and hits in the weak
hash table. Objects are not that big, but the MOP means quite a bit
of work goes on to allocate them and the memory is non-trival (i.e.
bigger than a cons). You want to engineer the system so you are only
reading the large objects you want, and are letting elephant do the
sorted lookups internally. Sadly, we don't have proper join support
due to the way we use the internal BDB Btree structure so there isn't
a high performance way to do it. However, using IDs should buy you
quite a bit.
Regards,
Ian
>
>> A likely candidate is the serializer, but I'm sure there could be
>> other
>> corner cases.
>
> It occurred to me that I should just describe what I'm doing, maybe
> there's an obvious stupidity on my side. I'm indexing short
> messages to
> be queries by a text search engine.
>
> A main BTree maps from words to (sub-)BTrees that in turn map from
> ranking (e.g. time, for recency) to (persistent) result object. To
> answer a query, I then look up the (sub-)BTrees for each word in the
> query and map over their elements until I have enough to fill a result
> page with the intersection of their results.
>
> This is probably a rather extreme use of the DB, for example
> creating so
> many persistent instances from the store might be the problem for the
> GC? Is there a "nicer" way of doing something like this? E.g. mapping
> only to id's, so as not to reconstruct an instance if all I'm going to
> do with is is "intersect" it's occurrance between lists of messages?
>
> Cheers,
>
> Chris
>
>
> [NB: the order of the two output tables is reversed for ease of use]
>
>
> Number of samples: 390
> Sample interval: 4 regions (approximately 32 kB)
> Total sampling amount: 1560 regions (approximately 12480 kB)
> Number of cycles: 0
>
>
> Self Total Cumul
> Nr Count % Count % Count % Function
> ----------------------------------------------------------------------
> --
> 1 81 20.8 81 20.8 81 20.8
> ELEPHANT-MEMUTIL::GRAB-BUFFER-STREAM
> 2 73 18.7 73 18.7 154 39.5 (SB-PCL::FAST-METHOD
> ELEPHANT-SERIALIZER2::DESERIALIZE-STRING (("#<...>" . "#<...>")
> "#<...>"
> . "#<...>"))
> 3 57 14.6 57 14.6 211 54.1
> ELEPHANT::DESERIALIZE-DATABASE-VERSION-VALUE
> 4 56 14.4 56 14.4 267 68.5
> ELEPHANT-MEMUTIL::RETURN-BUFFER-STREAM
> 5 50 12.8 50 12.8 317 81.3 FIND-PACKAGE
> 6 35 9.0 35 9.0 352 90.3
> ELEPHANT-SERIALIZER2::GET-CIRCULARITY-VECTOR
> 7 16 4.1 16 4.1 368 94.4
> ELEPHANT-SERIALIZER2::RELEASE-CIRCULARITY-VECTOR
> 8 12 3.1 12 3.1 380 97.4 ELEPHANT::GET-CACHED-
> INSTANCE
> 9 6 1.5 6 1.5 386 99.0 (LAMBDA (K V))
> 10 1 0.3 1 0.3 387 99.2 LIST
> 11 1 0.3 1 0.3 388 99.5
> ELEPHANT::MAKE-TRANSACTION-RECORD
> 12 1 0.3 1 0.3 389 99.7 (SB-PCL::FAST-METHOD
> MAKE-CURSOR (DB-BDB::BDB-BTREE))
> 13 1 0.3 1 0.3 390 100.0
> SB-KERNEL::%MAKE-INSTANCE-WITH-LAYOUT
> 14 0 0.0 244 62.6 390 100.0 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE)
> 15 0 0.0 307 78.7 390 100.0
> ELEPHANT-SERIALIZER2::DESERIALIZE
> 16 0 0.0 378 96.9 390 100.0 (SB-PCL::FAST-METHOD
> CURSOR-PREV (DB-BDB::BDB-CURSOR))
> 17 0 0.0 387 99.2 390 100.0 "Unknown component:
> #x100F827230"
> 18 0 0.0 387 99.2 390 100.0 (LAMBDA NIL)
> 19 0 0.0 390 100.0 390 100.0 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>"))
> 20 0 0.0 390 100.0 390 100.0 (SB-PCL::FAST-METHOD
> MAP-BTREE (T "#<...>" . "#<...>"))
> 21 0 0.0 390 100.0 390 100.0 GET-BTREE-SUBSEQ
> 22 0 0.0 390 100.0 390 100.0 (LAMBDA (&OPTIONAL
> ("#<...>"
> . "#<...>")))
> 23 0 0.0 390 100.0 390 100.0 (LAMBDA (&OPTIONAL
> ("#<...>"
> . "#<...>")))
> 24 0 0.0 390 100.0 390 100.0 (LAMBDA (&OPTIONAL
> ("#<...>"
> . "#<...>") "#<...>" . "#<...>"))
> 25 0 0.0 390 100.0 390 100.0 ANSWER-QUERY
> 26 0 0.0 390 100.0 390 100.0 PRODUCE-FEED
> 27 0 0.0 390 100.0 390 100.0 HUNCHENTOOT::PROCESS-
> REQUEST
> 28 0 0.0 390 100.0 390 100.0 HUNCHENTOOT::PROCESS-
> CONNECTION
> 29 0 0.0 390 100.0 390 100.0 "Unknown component:
> #x1000677630"
> 30 0 0.0 390 100.0 390 100.0 "foreign function
> call_into_lisp"
> 31 0 0.0 390 100.0 390 100.0 "foreign function
> new_thread_trampoline"
> 32 0 0.0 29 7.4 390 100.0 SB-INT:%FIND-PACKAGE-OR-
> LOSE
> 33 0 0.0 29 7.4 390 100.0
> SB-INT:FIND-UNDELETED-PACKAGE-OR-LOSE
> 34 0 0.0 29 7.4 390 100.0 INTERN
> 35 0 0.0 121 31.0 390 100.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION (DB-BDB::BDB-STORE-CONTROLLER))
> 36 0 0.0 121 31.0 390 100.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION :AROUND (T))
> 37 0 0.0 34 8.7 390 100.0 (FLET #:CLEANUP-FUN-279)
> 38 0 0.0 22 5.6 390 100.0 (FLET #:CLEANUP-FUN-1505)
> 39 0 0.0 21 5.4 390 100.0 TRANSLATE-AND-INTERN-
> SYMBOL
> 40 0 0.0 1 0.3 390 100.0 PACKAGE-NAME
> 41 0 0.0 2 0.5 390 100.0 (SB-PCL::FAST-METHOD
> CURSOR-LAST (DB-BDB::BDB-CURSOR))
> 42 0 0.0 1 0.3 390 100.0
> SB-ALIEN-INTERNALS:MAKE-ALIEN-VALUE
> ----------------------------------------------------------------------
> --
>
> Callers
> Total. Function
> Count % Count % Callees
> ----------------------------------------------------------------------
> --
> 30 7.7 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION (DB-BDB::BDB-STORE-CONTROLLER)) [35]
> 51 13.1 (SB-PCL::FAST-METHOD CURSOR-PREV
> (DB-BDB::BDB-CURSOR)) [16]
> 81 20.8 81 20.8 ELEPHANT-MEMUTIL::GRAB-BUFFER-STREAM [1]
> ----------------------------------------------------------------------
> --
> 73 18.7 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> 73 18.7 73 18.7 (SB-PCL::FAST-METHOD
> ELEPHANT-SERIALIZER2::DESERIALIZE-STRING (("#<...>" . "#<...>")
> "#<...>"
> . "#<...>")) [2]
> ----------------------------------------------------------------------
> --
> 57 14.6 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION (DB-BDB::BDB-STORE-CONTROLLER)) [35]
> 57 14.6 57 14.6 ELEPHANT::DESERIALIZE-DATABASE-VERSION-
> VALUE [3]
> ----------------------------------------------------------------------
> --
> 22 5.6 (FLET #:CLEANUP-FUN-1505) [38]
> 34 8.7 (FLET #:CLEANUP-FUN-279) [37]
> 56 14.4 56 14.4 ELEPHANT-MEMUTIL::RETURN-BUFFER-STREAM [4]
> ----------------------------------------------------------------------
> --
> 21 5.4 TRANSLATE-AND-INTERN-SYMBOL [39]
> 29 7.4 SB-INT:%FIND-PACKAGE-OR-LOSE [32]
> 50 12.8 50 12.8 FIND-PACKAGE [5]
> ----------------------------------------------------------------------
> --
> 35 9.0 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> 35 9.0 35 9.0 ELEPHANT-SERIALIZER2::GET-CIRCULARITY-
> VECTOR [6]
> ----------------------------------------------------------------------
> --
> 16 4.1 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> 16 4.1 16 4.1
> ELEPHANT-SERIALIZER2::RELEASE-CIRCULARITY-VECTOR [7]
> ----------------------------------------------------------------------
> --
> 12 3.1 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> 12 3.1 12 3.1 ELEPHANT::GET-CACHED-INSTANCE [8]
> ----------------------------------------------------------------------
> --
> 6 1.5 "Unknown component: #x100F827230" [17]
> 6 1.5 6 1.5 (LAMBDA (K V)) [9]
> ----------------------------------------------------------------------
> --
> 1 0.3 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>")) [19]
> 1 0.3 1 0.3 LIST [10]
> ----------------------------------------------------------------------
> --
> 1 0.3 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>")) [19]
> 1 0.3 1 0.3 ELEPHANT::MAKE-TRANSACTION-RECORD [11]
> ----------------------------------------------------------------------
> --
> 1 0.3 "Unknown component: #x100F827230" [17]
> 1 0.3 1 0.3 (SB-PCL::FAST-METHOD MAKE-CURSOR
> (DB-BDB::BDB-BTREE)) [12]
> ----------------------------------------------------------------------
> --
> 1 0.3 SB-ALIEN-INTERNALS:MAKE-ALIEN-VALUE
> [42]
> 1 0.3 1 0.3 SB-KERNEL::%MAKE-INSTANCE-WITH-LAYOUT [13]
> ----------------------------------------------------------------------
> --
> 244 62.6 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> 1 0.3 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> 0 0.0 244 62.6 (LABELS ELEPHANT-SERIALIZER2::%
> DESERIALIZE) [14]
> 21 5.4 TRANSLATE-AND-INTERN-SYMBOL [39]
> 121 31.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION :AROUND (T)) [36]
> 29 7.4 INTERN [34]
> 1 0.3 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> 73 18.7 (SB-PCL::FAST-METHOD
> ELEPHANT-SERIALIZER2::DESERIALIZE-STRING (("#<...>" . "#<...>")
> "#<...>"
> . "#<...>")) [2]
> ----------------------------------------------------------------------
> --
> 2 0.5 (SB-PCL::FAST-METHOD CURSOR-LAST
> (DB-BDB::BDB-CURSOR)) [41]
> 305 78.2 (SB-PCL::FAST-METHOD CURSOR-PREV
> (DB-BDB::BDB-CURSOR)) [16]
> 0 0.0 307 78.7 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> 16 4.1
> ELEPHANT-SERIALIZER2::RELEASE-CIRCULARITY-VECTOR [7]
> 12 3.1 ELEPHANT::GET-CACHED-INSTANCE [8]
> 35 9.0
> ELEPHANT-SERIALIZER2::GET-CIRCULARITY-VECTOR [6]
> 244 62.6 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> ----------------------------------------------------------------------
> --
> 378 96.9 "Unknown component: #x100F827230" [17]
> 0 0.0 378 96.9 (SB-PCL::FAST-METHOD CURSOR-PREV
> (DB-BDB::BDB-CURSOR)) [16]
> 22 5.6 (FLET #:CLEANUP-FUN-1505) [38]
> 51 13.1 ELEPHANT-MEMUTIL::GRAB-BUFFER-STREAM
> [1]
> 305 78.2 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> ----------------------------------------------------------------------
> --
> 387 99.2 (LAMBDA NIL) [18]
> 0 0.0 387 99.2 "Unknown component: #x100F827230" [17]
> 1 0.3 (SB-PCL::FAST-METHOD MAKE-CURSOR
> (DB-BDB::BDB-BTREE)) [12]
> 2 0.5 (SB-PCL::FAST-METHOD CURSOR-LAST
> (DB-BDB::BDB-CURSOR)) [41]
> 6 1.5 (LAMBDA (K V)) [9]
> 378 96.9 (SB-PCL::FAST-METHOD CURSOR-PREV
> (DB-BDB::BDB-CURSOR)) [16]
> ----------------------------------------------------------------------
> --
> 387 99.2 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>")) [19]
> 0 0.0 387 99.2 (LAMBDA NIL) [18]
> 387 99.2 "Unknown component: #x100F827230" [17]
> ----------------------------------------------------------------------
> --
> 390 100.0 (SB-PCL::FAST-METHOD MAP-BTREE (T
> "#<...>" . "#<...>")) [20]
> 0 0.0 390 100.0 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>")) [19]
> 1 0.3 SB-ALIEN-INTERNALS:MAKE-ALIEN-VALUE
> [42]
> 1 0.3 ELEPHANT::MAKE-TRANSACTION-RECORD [11]
> 1 0.3 LIST [10]
> 387 99.2 (LAMBDA NIL) [18]
> ----------------------------------------------------------------------
> --
> 390 100.0 GET-BTREE-SUBSEQ [21]
> 0 0.0 390 100.0 (SB-PCL::FAST-METHOD MAP-BTREE (T
> "#<...>" .
> "#<...>")) [20]
> 390 100.0 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>")) [19]
> ----------------------------------------------------------------------
> --
> 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>"))) [22]
> 0 0.0 390 100.0 GET-BTREE-SUBSEQ [21]
> 390 100.0 (SB-PCL::FAST-METHOD MAP-BTREE (T
> "#<...>" . "#<...>")) [20]
> ----------------------------------------------------------------------
> --
> 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>"))) [23]
> 0 0.0 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>"))) [22]
> 390 100.0 GET-BTREE-SUBSEQ [21]
> ----------------------------------------------------------------------
> --
> 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>")
> "#<...>" . "#<...>")) [24]
> 0 0.0 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>"))) [23]
> 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>"))) [22]
> ----------------------------------------------------------------------
> --
> 390 100.0 ANSWER-QUERY [25]
> 0 0.0 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" . "#<...>")
> "#<...>" . "#<...>")) [24]
> 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>"))) [23]
> ----------------------------------------------------------------------
> --
> 390 100.0 PRODUCE-FEED [26]
> 0 0.0 390 100.0 ANSWER-QUERY [25]
> 390 100.0 (LAMBDA (&OPTIONAL ("#<...>" .
> "#<...>")
> "#<...>" . "#<...>")) [24]
> ----------------------------------------------------------------------
> --
> 390 100.0 HUNCHENTOOT::PROCESS-REQUEST [27]
> 0 0.0 390 100.0 PRODUCE-FEED [26]
> 390 100.0 ANSWER-QUERY [25]
> ----------------------------------------------------------------------
> --
> 390 100.0 HUNCHENTOOT::PROCESS-CONNECTION [28]
> 0 0.0 390 100.0 HUNCHENTOOT::PROCESS-REQUEST [27]
> 390 100.0 PRODUCE-FEED [26]
> ----------------------------------------------------------------------
> --
> 390 100.0 "Unknown component: #x1000677630" [29]
> 0 0.0 390 100.0 HUNCHENTOOT::PROCESS-CONNECTION [28]
> 390 100.0 HUNCHENTOOT::PROCESS-REQUEST [27]
> ----------------------------------------------------------------------
> --
> 390 100.0 "foreign function call_into_lisp" [30]
> 0 0.0 390 100.0 "Unknown component: #x1000677630" [29]
> 390 100.0 HUNCHENTOOT::PROCESS-CONNECTION [28]
> ----------------------------------------------------------------------
> --
> 390 100.0 "foreign function
> new_thread_trampoline" [31]
> 0 0.0 390 100.0 "foreign function call_into_lisp" [30]
> 390 100.0 "Unknown component: #x1000677630" [29]
> ----------------------------------------------------------------------
> --
> 0 0.0 390 100.0 "foreign function
> new_thread_trampoline" [31]
> 390 100.0 "foreign function call_into_lisp" [30]
> ----------------------------------------------------------------------
> --
> 1 0.3 PACKAGE-NAME [40]
> 28 7.2 SB-INT:FIND-UNDELETED-PACKAGE-OR-
> LOSE [33]
> 0 0.0 29 7.4 SB-INT:%FIND-PACKAGE-OR-LOSE [32]
> 29 7.4 FIND-PACKAGE [5]
> ----------------------------------------------------------------------
> --
> 29 7.4 INTERN [34]
> 0 0.0 29 7.4 SB-INT:FIND-UNDELETED-PACKAGE-OR-LOSE [33]
> 1 0.3 PACKAGE-NAME [40]
> 28 7.2 SB-INT:%FIND-PACKAGE-OR-LOSE [32]
> ----------------------------------------------------------------------
> --
> 29 7.4 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> 0 0.0 29 7.4 INTERN [34]
> 29 7.4 SB-INT:FIND-UNDELETED-PACKAGE-OR-
> LOSE [33]
> ----------------------------------------------------------------------
> --
> 121 31.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION :AROUND (T)) [36]
> 0 0.0 121 31.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION (DB-BDB::BDB-STORE-CONTROLLER)) [35]
> 30 7.7 ELEPHANT-MEMUTIL::GRAB-BUFFER-STREAM
> [1]
> 34 8.7 (FLET #:CLEANUP-FUN-279) [37]
> 57 14.6
> ELEPHANT::DESERIALIZE-DATABASE-VERSION-VALUE [3]
> ----------------------------------------------------------------------
> --
> 121 31.0 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> 0 0.0 121 31.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION :AROUND (T)) [36]
> 121 31.0 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION (DB-BDB::BDB-STORE-CONTROLLER)) [35]
> ----------------------------------------------------------------------
> --
> 34 8.7 (SB-PCL::FAST-METHOD
> ELEPHANT::DATABASE-VERSION (DB-BDB::BDB-STORE-CONTROLLER)) [35]
> 0 0.0 34 8.7 (FLET #:CLEANUP-FUN-279) [37]
> 34 8.7 ELEPHANT-MEMUTIL::RETURN-BUFFER-
> STREAM [4]
> ----------------------------------------------------------------------
> --
> 22 5.6 (SB-PCL::FAST-METHOD CURSOR-PREV
> (DB-BDB::BDB-CURSOR)) [16]
> 0 0.0 22 5.6 (FLET #:CLEANUP-FUN-1505) [38]
> 22 5.6 ELEPHANT-MEMUTIL::RETURN-BUFFER-
> STREAM [4]
> ----------------------------------------------------------------------
> --
> 21 5.4 (LABELS
> ELEPHANT-SERIALIZER2::%DESERIALIZE) [14]
> 0 0.0 21 5.4 TRANSLATE-AND-INTERN-SYMBOL [39]
> 21 5.4 FIND-PACKAGE [5]
> ----------------------------------------------------------------------
> --
> 1 0.3 SB-INT:FIND-UNDELETED-PACKAGE-OR-
> LOSE [33]
> 0 0.0 1 0.3 PACKAGE-NAME [40]
> 1 0.3 SB-INT:%FIND-PACKAGE-OR-LOSE [32]
> ----------------------------------------------------------------------
> --
> 2 0.5 "Unknown component: #x100F827230" [17]
> 0 0.0 2 0.5 (SB-PCL::FAST-METHOD CURSOR-LAST
> (DB-BDB::BDB-CURSOR)) [41]
> 2 0.5 ELEPHANT-SERIALIZER2::DESERIALIZE [15]
> ----------------------------------------------------------------------
> --
> 1 0.3 (SB-PCL::FAST-METHOD
> ELEPHANT::EXECUTE-TRANSACTION (DB-BDB::BDB-STORE-CONTROLLER "#<...>" .
> "#<...>")) [19]
> 0 0.0 1 0.3 SB-ALIEN-INTERNALS:MAKE-ALIEN-VALUE [42]
> 1 0.3 SB-KERNEL::%MAKE-INSTANCE-WITH-
> LAYOUT [13]
> ----------------------------------------------------------------------
> --
> _______________________________________________
> elephant-devel site list
> elephant-devel at common-lisp.net
> http://common-lisp.net/mailman/listinfo/elephant-devel
More information about the elephant-devel
mailing list