CSpace Garbage Collector

A CSpace employs a "stop the world" mark and sweep tracing garbage collector (GC) to determine the lifetime of heap allocated objects that implement IObject.

The chief advantages of a GC are:

• Code simplification
• It is relatively easy for the programmer to avoid memory / hard-disk leaks
• Access violations caused by dereferencing dangling pointers are avoided
• Object deletion (during the sweep phase) can be performed in the background
• [perhaps] a number of authors (e.g. Paul Wilson) have stated that a tracing GC can out-perform reference counting - in terms of total CPU load
• Reference counting seems particularly inefficient for lifetime management of persistent objects.

A component architecture raises some challenging memory management problems if reference counting is used - particularly if it supports some form of orthogonal persistence. The issue is that changes to persistent reference counters represents a significant overhead if it means objects often need to be written back to disk just because their reference count has changed.

Object deletion is performed during the sweep phase without a lock on the CSpace.

Tracing GC is not easy to implement without compiler support. To keep things simple we make the following assumptions

• Only IObjects take part in GC
• IObjects must never be explicitly destroyed
• We use a simple mark and sweep stop the world GC
• Every derivation of IObject must implement the virtual function VisitObjects() to visit all outgoing IObject pointers

In the future it may be worthwhile looking into a generational garbage collector algorithm.

Objects in the CSpace must implement the VisitObjects() function to visit all outgoing pointers, to allow the GC trace to be performed.

Rate at which garbage collections are performed

A CSpace defines a rate at which garbage collections are performed, in terms of the period in milliseconds between garbage collections.

Refer to the methods GetMilliSecsPerGc() and SetMilliSecsPerGc() defined on CSpace.

gcroot

A gcroot<T*> represents a smart pointer that retains shared ownership of a heap allocated IObject of type T which is registered in a CSpace.

This provides a basis to visit objects referenced by variables on the frame (since this isn't done automatically by the C++ compiler).

Object eviction

---

$function+ void SetTouched(ptr<IObject> obj)

Calling thread needs shared read or exclusive lock on the CSpace When a weak referenced ptr is accessed by a thread during a shared read lock we set its last touched time. This serves two purposes:-

• Objects are evicted on an LRU basis
• Touched objects can't be deleted by the concurrently running GC.

---

$function+ void SetEvictableObjectSizeInBytes(ptr<const IObject> obj, ssize_t sizeInBytes)

Set the size of the given evictable object to be assumed to determine how many objects should be evicted.