back_ref.C

#include <string>
#include <iostream>

#include <archon/util/exception.H>
#include <archon/util/ref.H>

using namespace std;
using namespace Archon::Utilities;


/*

Garbage Collection:
-------------------

Using the smart pointer 'Ref' is an approach to garbage collection. It
solves a "local" problem of deallocating an object when there is no
more _imadiate_ references to it anymore. It leaves a global problem
though: To make sure that no cyclic reference chains are ever
introduced.

Even though we are able to cope with a restricted use of cyclic
references (by breaking the cycles forcefully), it still remains for
the user to ensure that the references are only used in that
restricted manner.

An alternative to using smart pointers, would be to use objects that
when "visited" knows how to recursivly visit all the objects that the
first object refers to. Proberbly via a virtual function 'visit'. Then
we have to maintain a set of root pointers and once in a while we
should visit all root pointers and mark all the objects that gets
visited. All objects that are not visited in this process may be
deleted. This is the way SpiderMonkey does it. This startegy does not
suffer from the cyclic renference problem and thus has a great
advantage there. It still leaves a global problem though, we have to
write a new correct 'visit' method for every new class. Also we have
to considder data protection between the garbage collection thread and
the other threads in action. This methos has two other disadvantages
it takes up CPU time to do the visiting, and it takes up more memory,
since objects are not deallocated as soon as possible, On the other
hand, copying references may be faster since we do not need to adjust
a reference count. A problem would also be that we cannot hold a
single pointer on the stack, cause there is no way to discover that.
The sollution is to root the pointer.

*/

/*

Considder an asyclic directed graph of objects with smart pointers to
other objects. This includes a set of root pointers held by one or
more outside parties. Such a graph will have the property that every
object in it will be deleted if all the root pointers are
deleted. This property af cource is important to prevent memory leak.

We also want every element to have a unique static reference to its
container. With is almoast the same as saying that the container must
always be available to its elements. This suggests the root the Server
will be deleted when every Context is deleted, which in
turn will happen when every node belonnging to that context is
deleted. In other words, the destruction will happen from leafs to the
root.

Imagine that some of these objects have the logical role of being a
container for some or all of the objects that it refers to.

Then it will often be desirable to add a reference from each of the
contained


There is a static link from an element to its container.

Elements may refer to other elements.
There is a root element.

The idea is that calling 'clear' on a ContainerRefObjectBase must
eventually lead to its destruction due to the death of all its
children.

*/

/*

A directed acyclic graph is similar to a tree directed from root to
leafs except that it may have several roots. Take this to be the
definition of the concept of leafs and roots in a directed acyclic
graph.

A forward reference is then a reference going in the direction from
the roots to the leafs, and a backward reference is a reference going
in the direction from the leafs to the roots.

*/

namespace
{
  struct Node;

  struct Route: RefObjectBase
  {
    const BackRef<Node> node;

    Route(BackRef<Node> node): node(node) {}

    ~Route() { cerr << "~Route\n"; }
  };

  struct Context;

  struct Node: BackRefObjectBase
  {
    const BackRef<Context> context;

    Ref<Route> route;

    Node(BackRef<Context> context): context(context) {}

    ~Node() { cerr << "~Node\n"; }

    void refForwardDestroy()
    {
      route.reset();
    }
  };

  struct Server;

  struct Context: BackRefObjectBase
  {
    const BackRef<Server> server;

    Ref<Node> node;

    Context(BackRef<Server> server): server(server) {}

    ~Context() { cerr << "~Context\n"; }

    void refForwardDestroy()
    {
      node.reset();
    }
  };

  struct Server: BackRefObjectBase
  {
    Ref<Context> context;

    ~Server() { cerr << "~Server\n"; }

    void refForwardDestroy()
    {
      context.reset();
    }
  };
}


int main()
{
  set_unexpected(Exception::terminal<exceptionCatchInfo>);
  set_terminate (Exception::terminal<exceptionCatchInfo>);

  Ref<Server> server = new Server;
  Ref<Context> context = new Context(server);
  Ref<Node> node = new Node(context);
  Ref<Route> route = new Route(node);

  node->route = route;
  context->node = node;
  server->context = context;

  return 0;
}

---