Forwarding Pointers with Sanity Checks (Preparation for Incremental GC)

[luc-blaeser]

Note: Not for merging. This PR is only a sub-component for the future incremental GC.

Forwarding Pointers (Preparation for Incremental GC)

Support for forwarding pointers (Brooks pointer) to enable incremental moving (evacuating compacting) GC.

Each object stores a forwarding pointer with the following properties:

• Self-reference: If the object resides at a valid location (i.e. not been relocated to another address), the forwarding pointer stores a reference to the object itself.
• Single-level redirection: If an object has been moved, the original object stores a pointer to the new object location. This implies that the data at the original object location is no longer valid.

Indirection is at most one level, i.e. the relocation target cannot forward again to another location. The GC would need to update all incoming pointers before moving an object again in the next GC run.

Invariant: object.forward().get_ptr() == object.get_ptr() || object.forward().forward().get_ptr() == object.forward().get_ptr().

Changes

Changes made to the compiler and runtime system:

• Header extension: Additional object header space has been inserted for the forwarding pointer. Allocated objects forward to themselves.
• Access indirection: Every load, store, and object comparison effects an additional indirection through the forwarding pointer.

Sanity Checks

Extra sanity checks for forwarding pointers are enabled by the --sanity-checks compiler flag:

• Indirection check: Every derefencing of a forwarding pointer is checked whether the pointer is valid, and the invariant above holds.
• Memory scan: At GC time points, in regular intervals, the entire memory is scanned and all objects and pointers are verifying to be valid (valid forwarding pointer and plausible object tag).
• Artificial forwarding: For every created object, an artificial dummy object is returned that forwards to the real object. The dummy object stores zeroed content and has an invalid tag. This helps to verify that all heap accesses are correctly forwarded. Artificial forwarding disables the existing garbage collectors (due to the dummy objects not handled by the GCs) and performs memory scans at a defined frequency instead.

Runtime Costs

Measuring the performance overhead of forwarding pointers in the GC benchmark using release mode (no sanity checks).

Total number of mutator instructions, average across all benchmark cases:

Configuration	Avg. mutator instructions
No forwarding (*)	1.48e10
With forwarding	1.65e10

Runtime overhead of 11% on average.

Costs vary between 0 and 21% depending on the GC benchmark case (highest cost for linked-list and buffer).

(*) Also using the latest compiler optimization regarding faster array initialization.

Memory Costs

Final heap size, average accross all GC benchmark cases, same for both the compacting and the copying GCs:

Configuration	Avg. final heap size
No forwarding	163 MB
With forwarding	168 MB

Memory overhead of 3.1% on average.

Testing

Running the tests in test/run and test/run-drun with the abovementioned sanity checks:

export EXTRA_MOC_ARGS="--sanity-checks --force-gc"
make

Note: The following test cases had to be adjusted to cope with the sanity checks:

• rts-stats, rts-stats2, free-callbacks: The runtime performance numbers differ because of the artificial forwarding sanity checks.
• ser-many-nat, ser-many-int: Downscaled because of the expensive sanity checks (take otherwise too long).
• data-params, distributor, query-footprint-overflow: ic-ref disabled as it otherwise times out the build system.

Later, in the incremental GC, the artificial forwarding check will be removed, and the tests can again be performed as usual.

[github-actions]

Comparing from cfa900b to e733892:
In terms of gas, 4 tests regressed and the mean change is +5.1%.
In terms of size, 4 tests regressed and the mean change is +4.6%.