mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 03:51:19 -10:00
78 lines
4.1 KiB
Plaintext
78 lines
4.1 KiB
Plaintext
While the Boehm GC is quite good, we need to move to a
|
|
precise, generational GC for better performance and smaller
|
|
memory usage (no false-positives memory retentions with big
|
|
allocations).
|
|
|
|
This is a large task, but it can be done in steps.
|
|
|
|
1) use the GCJ support to mark reference fields in objects, so
|
|
scanning the heap is faster. This is mostly done already, needs
|
|
checking that it is always used correctly (big objects, arrays).
|
|
There are also some data structures we use in the runtime that are
|
|
currently untyped that are allocated in the Gc heap and used to
|
|
keep references to GC objects. We need to make them typed as to
|
|
precisely track GC references or make them non-GC memory,
|
|
by using more the GC hnadle support code (MonoGHashTable, MonoDomain,
|
|
etc).
|
|
|
|
2) don't include in the static roots the .bss and .data segments
|
|
to save in scanning time and limit false-positives. This is mostly
|
|
done already.
|
|
|
|
3) keep track precisely of stack locations and registers in native
|
|
code generation. This basically requires the regalloc rewrite code
|
|
first, if we don't want to duplicate much of it. This is the hardest
|
|
task of all, since proving it's correctness is very hard. Some tricks,
|
|
like having a build that injects GC.Collect() after every few simple
|
|
operations may help. We also need to decide if we want to handle safe
|
|
points at calls and back jumps only or at every instruction. The latter
|
|
case is harder to implement and requires we keep around much more data
|
|
(it potentially makes for faster stop-the-world phases).
|
|
The first case requires us to be able to advance a thread until it
|
|
reaches the next safe point: this can be done with the same techniques
|
|
used by a debugger. We already need something like this to handle
|
|
safely aborts happening in the middle of a prolog in managed code,
|
|
for example, so this could be an additional sub-task that can be done
|
|
separately from the GC work.
|
|
Note that we can adapt the libgc code to use the info we collect
|
|
when scanning the stack in managed methods and still use the conservative
|
|
approach for the unmanaged stack, until we have our own collector,
|
|
which requires we define a proper icall interface to switch from managed
|
|
to unmanaged code (hwo to we handle object references in the icall
|
|
implementations, for example).
|
|
|
|
4) we could make use of the generational capabilities of the
|
|
Boehm GC, but not with the current method involving signals which
|
|
may create incompatibilities and is not supported on all platforms.
|
|
We need to start using write barriers: they will be required anyway
|
|
for the generational GC we'll use. When a field holding a reference
|
|
is changed in an object (or an item in an array), we mark the card
|
|
or page where the field is stored as dirty. Later, when a collection
|
|
is run, only objects in pages marked as dirty are scanned for
|
|
references instead of the whole heap. This could take a few days to
|
|
implement and probably much more time to debug if all the cases were
|
|
not catched:-)
|
|
|
|
5) actually write the new generational and precise collector. There are
|
|
several examples out there as open source projects, though the CLR
|
|
needs some specific semantics so the code needs to be written from
|
|
scratch anyway. Compared to item 3 this is relatively easer and it can
|
|
be tested outside of mono, too, until mono is ready to use it.
|
|
The important features needed:
|
|
*) precise, so there is no false positive memory retention
|
|
*) generational to reduce collection times
|
|
*) pointer-hopping allocation to reduce alloc time
|
|
*) possibly per-thread lock-free allocation
|
|
*) handle weakrefs and finalizers with the CLR semantics
|
|
|
|
Note: some GC engines use a single mmap area, because it makes
|
|
handling generations and the implementation much easier, but this also
|
|
limits the expension of the heap, so people may need to use a command-line
|
|
option to set the max heap size etc. It would be better to have a design
|
|
that allows mmapping a few megabytes chunks at a time.
|
|
|
|
The different tasks can be done in parallel. 1, 2 and 4 can be done in time
|
|
for the mono 1.2 release. Parts of 3 and 5 could be done as well.
|
|
The complete switch is supposed to happen with the mono 2.0 release.
|
|
|