[comp.sw.components] garbage in object databases was Real-time Garbage Collection

scc@cl.cam.ac.uk (Stephen Crawley) (09/27/89)

Bill Wolfe writes:
> The model involves a database which stores objects which can be
> created, destroyed, read, and written by various users.  The users
> might be partitioned into different groups (e.g., those authorized
> to destroy vs. those who cannot).  Now from the perspective of a
> user who can read and write but not destroy, the object's lifetime
> is potentially infinite, depending upon the whims of those who have
> the power to destroy.  By revalidating the identification number,
> such users receive continued assurances that the object still exists.
>
> If the object is destroyed, the identification numbers will then all
> expire automatically, regardless of how widely they were distributed.

A user explicitly destroying objects is equivalent to an application 
explicitly deallocating heap nodes.  In both case, a dangling reference
is left that will cause trouble next time it is used.

Sensible object-oriented database designs don't allow users to delete 
objects.  Instead objects are removed from the database when they are 
no longer accessible.  Dangling references are impossible.

But even assuming a database design where users may delete objects
explicitly, what good does it do a user to check that an object nos
is still valid?  If it is valid now, there is no guarantee that it 
will still be in 5 seconds time.  If it isn't valid, there is nothing 
the user can do about it.  Sounds like a total waste of time to me ...

Bill writes:
>>> We are managing objects in this way because they present worst-case
>>> properties which do not permit us to use more efficient techniques.
>> 
>> What about garbage collection???  
>
> Won't work under the conditions I described (distributed environment).

Sorry Bill, you are just plain wrong there.

I have designed and am implementing an algorithm for garbage collection
of a distributed object system.  It works, and it is tolerably fast. 
(Garbage collection of N interlinked databases requires at most order 
N**2 messages)  This stuff will be written up for publication in due 
course.

-- Steve