I've gotten underway hacking the GC to add precise heap scanning, but I thought of one really annoying corner case that really would make things an order of magnitude more complicated if it were handled properly: Structs and classes that have large static arrays embedded. For example:
class Foo { Foo next; void*[4 * 1024 * 1024] hugeArray; } The problem here is that scanning this precisely would require me to either generate a megabyte bitmask that explicitly says "scan every element of hugeArray" or to change my bitmask data structure from a flat array to something nested and an order of magnitude more complex to generate at compile time. Since this is such a rare case in practice, I'm tempted to just say that any object with size above some arbitrary limit, say 1 kb, just gets scanned conservatively and be done with it. For arrays, this would be a limit on the size of the element, i.e. for a T[], it would be a limit on T.sizeof, *not* T.sizeof * length. I'd like to get the community's input on this: Is this enough of a corner case that I have permission to cop out of solving it properly for the sake of simplicity?