The GC Protocol

The collector and collectable objects must cooperate with each other by abiding to a simple protocol:

• All objects that are to be garbage collected must be derived from GCObject . The application programmer must also supply a ``tracing'' method. The purpose of this method is to identify all internal pointers to other GCObject 's. This method is not used by the application programmer directly but only used internally by the garbage collectors.
• The tracing method of each collectable must in turn call the tracing method in the class GC  with each pointer to a collectable object that the object owns:

     class GC {
     public:
        virtual GCObject * trace (GCObject *) = 0;
        inline  void trace (GCObject& obj);
     };

  Briefly, the rules are as follows:

  1. The tracing method of a collectable Foo has the following general form:

                  void Foo::trace(GC * gc)
                  {
                     ...
                  }

  2. If class Foo has a member that is a pointer p to a collectable object of type Bar, then add:

                    p = (Bar)gc->trace(p);

     to the body of Foo::trace.
  3. If class Foo has a member object x that is a subclass of GCObject, also add:

                    gc->trace(x);

     to the body of Foo::trace.
  4. If class Foo is derived from a class Bar that is a subclass of GCObject, add:

                    Bar::trace(gc);

     to the body of Foo::trace.
  Notice that these methods can be arranged in any order.

This protocol can be used by both copying and non-copying collectors. In addition, the class GCVerifier  also uses this protocol to walk the heap in order to verify the integrity of a garbage collected data structure.