[boost] Re: Garbage Collection, Reference Count or Ownership?

From: Philippe A. Bouchard (philippeb_at_[hidden])
Date: 2003-10-06 15:32:17

cppljevans_at_[hidden] wrote:

[...]

> I've just uploaded
>
http://groups.yahoo.com/group/boost/files/shared_cyclic_ptr/compare_mem.zip.
> I was hoping you could provide a similar analysis of memory used for
> this gc_collector.  In particular, sizeof(shared_ptr<T>) is the same
> as
> the above (as noted by Greg Colvin's post:
> http://article.gmane.org/gmane.comp.lib.boost.devel/25877 ).  This is
> the size/smart_ptr, but I'm wondering how shifted_ptr compares
> with shared_ptr w.r.t. each pointee.  (see the compare_mem.zip
> (anal.mem.share_ptr.html) under the Vertices item).
>
>> So in fact: by using the default alternative the smart pointer is
>> going to be resonably fast and destructors are going to be properly
>> called even for cyclic references.  This is perfect.
> Give us a hint as to how cyclic reference are handled.

That is a great document, really interesting.  If we are talking about the
root_collector I was talking about; then given:

Group: group of pointees on the heap refering to themselves.
Root: a smart pointer on the stack refering to a group.
Indicator: a counter indicating the number of times a group is refered to by
a smart pointer on the stack (let's call it this way).

template <T>
    class shifted_ptr<T, root_collector>
    {
        ...

        T * m_ptr;
        long * m_ind;
    };

- Every time a shifted_ptr<> on the stack or static data (! heap) is
handling a new pointee, it will create a new "indicator".
- Every shifted_ptr<> is refering to an "indicator" so that it can be passed
on to new pointees.
- If a new pointer on the stack is now refering to a new group, the
indicator is incremented.
- If a pointer on the stack that was refering to a group on the heap gets
destructed, the indicator is decremented.
- If a pointer on the stack is the last one that was refering to a group,
the group will get destructed (cyclisism).

There is no graph scanning, everything works instantaneously, reasonnably
fast and:

- sizeof("indicator") == sizeof(long)
- sizeof(shifted_ptr<T, root_collector>) == sizeof(void *) * 2
- only 1 indicator will be created everytime a smart pointer on the stack
(or data segment) is handling a new pointee on the heap.
- the destructors will always be called on time.

As for determining where the object lives in (heap, stack, data), they are
many alternatives.

Philippe