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

From: Philippe A. Bouchard (philippeb_at_[hidden])
Date: 2003-10-06 12:34:46

Philippe A. Bouchard wrote:
> Philippe A. Bouchard wrote:
>
> [...]
>
>> Would you like me to rename shifted_ptr to gc_ptr since "shifted" was
>> used
>> as a warning but not needed anymore since make_gc_ptr is going to be
>> used & os_collector will be discarded?
>
> I was reading this "tutorial" (thanks to MS):
> http://www.csharphelp.com/archives2/archive297.html
>
> C# is using some mark / compact collector.  It looks like garbage
> collectors are using a lot of memory and the destructors are not even
> called in C# (?!?).
>
> What I am going to do:
> - I am going the keep collector_traits<>, but move it in some hidden
> namespace (detail::shifted_ptr::...) because:
>     - it is not safe to start playing with (as mentionned by Doug as
> for forward declarations);
>     - I am going to keep os_collector;
>     - I am going to add a pure gc collector tag (no reference count,
> pure garbage collector can take place);
>     - I need partial specializations if we are not going to use
> macros.
> - The rgc_collector I am going to use is the one I was thinking about
> this summer:
>     - mark heap "entities" with another reference count;
>     - the sizeof(shifted_ptr<T, rgc_collector>) is going to be
> sizeof(void *)
> * 2;
>     - optimized for single thread algorithms (will need help for
> multi-threaded version).
> - Pure garbage collector is not going to be implemented because is it
> too much complex.
>
> 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.
>
> collector_traits<> will look like:
>
> namespace detail
> {
>
> namespace shifted_ptr
> {
>
> struct gc_collector {};  // pure garbage collector, no reference count
> struct rc_collector {};  // regular reference count
> struct os_collector {};  // still ownership
> struct rgc_collector {};  // referenced garbage collector
>
> template <typename T>
>     struct collector_traits
>     {
>         typedef rgc_collector type;  // default one
>     };
>
> ...
>
> }
>
> }
>
> So in fact the referenced garbage collector is going to be the
> default one and destructors will not be postponed.  I am going to
> keep the ownership alternative because it fits perfectly for
> containers or other internal
> usages IMO.

I'll skip those abreviations and use the following:

struct gc_collector {};  // pure garbage collector, no reference count
struct rc_collector {};  // regular reference count
struct root_collector {};  // reference counted entity (group of objects on
the heap having a root on the stack)
struct ownership_collector {};  // still ownership

Casts between those different types will need to copy its target to a newly
allocated block.  But this will not be really a problem.

Again, root_collector will be the default one but sizeof(shifted_ptr<T,
root_collector>) == sizeof(void *) * 2 (== sizeof(shared_ptr<T> BTW) and
cyclic pointers will be immediately destructed.  I will need some help for
pure garbage collectors if you feel shifted_ptr<T, root_collector> is not
fast enough.

Philippe