knizhnik/cppgc

Mark&sweep garbage collector for C++

cppgc's Issues

Two issues

According to mark_n_sweep_gc.txt, these two are the disadvantages of reference counting. But I could not find the solution to them in mark-and-sweep GC.

1. Noticeable performance penalty. Each manipulation with pointers requires update of counter.
   In case of multithreaded application we have to use atomic operations or synchronization primitives to avoid race conditions.

Atomic operations are only required if one thread allocates an object and passes the reference to another. However, I noticed that the mark-and-sweep MemoryAllocator is thread local, which cannot handle the shared references. If one thread A allocates an object O and passes the reference to another thread B, there are possibility that A does not hold the reference from root to O and deallocate it, while B still holds the reference. In order to handle this, all involed threads must be blocked before GC, and it brings performance penalty. Therefore, high performance GC in multi-thread context is not an easy thing.

4. Deleting last reference to huge tree of objects can cause large number of cascade (recursive) deletes which can cause stack overflow.

However, in mark-and-sweep collector, marking last reference to huge tree of objects can cause large number of cascade (recursive) marks which can cause stack overflow. This is easy to solve through manual implemented stack.

Have a question

Does it overload new/malloc?
If not, Can I use this project in a legacy code base with fewer code changes?