Advise GC to cleanup object

[msedi]

Just an idea that came up lately. Does it make sense or is it even possible to advise the GC to cleanup object in the LOH? The idea arose from another question regarding the need for enforcing a LOH compaction.

My question is if you know that you need to cleanup an object, does it help to assist the GC to prioritize these objects?

[Xyncgas]

GC.Collect()

[danmoseley]

What value would it have to hint to the GC (if you could somehow)? It will collect garbage when it thinks it needs to in order to satisfy an allocation request.

[msedi]

@danmoseley. This for sure no common scenario. I was only thinking about my current scenario where I'm working with many GB/TB of data where I'm allocating a lot in the LOH. Almost 90% of the data are in the LOH. The amount of data I need to allocate during one run is dependent on the input data which range from 5GB to 120GB). During processing multiple intermediate datasets of the same size are allocated (50-100, so for the extreme case it could happend that I allocate 120TB during one run), not all at once but during the whole processing chain. Which means the required amount of memory goes way beyond what is available in the system memory (max. 256GB but it's able to scale) so I crceated some sort of memory mapped files without using them for many reasons:

1. Since the windows memory manager is running concurrently I don't know when to throttle my processing pipeline which leads to the problem that my processing pipeline is creating new memory while the windows memory manager is trying to page out the dirty and unused pages. The windows memory manager (or better the page disk) is slower than I create data. which brings the system to a condition where everything is at 100% (100% CPU, 100% RAM and 100% disk usage). Ultimately the system halts and I need to restart. Since there is not information from windows that the memory manager is currently paging I have no knowledge of when to throttle my pipeline.

2. Another thing is with memory mapped files that I do not know which page is dirty. Windows does not provide any method to get the information. QueryWorkingSetEx, VirtualQueryXX or QueryVirtualMemoryInformation do not return the full information of the page table entry) especially the dirty/modified bit, but a lot of information that doesn't help in my case. Additionally I cannot install a write watch that I is available when creating memory using VirtualAlloc. I could of course track it myself (which I do now) but then I need to work with additional info structures that track the dirty state which makes it necessary that some has to mark the page as dirty which is as additional overhead (and windows also does it, so I have to create such structures twice for no use).

3. The memory manager does not know about my access patterns which I know much better (many of them are sequentially, other are random), but here I at least have some possibilities with Virtualock, OfferVirtualMemory, DiscardVirtualMemory or PrefetchVirtualMemory.

Due to this problems I need to manage things myself and created my own memory mapped files (although I find this stupid and would prefer using memory mapped files - but as shown above a few links are missing, especially the dirty bit and the information when paging is running).

The reason why I'm asking if the GC can be given some additional information (in LOH only) if it would help to coordinate the cleanup for the LOH better. Still, of course the GC has to check for references to the data but if the GC would know better it could prioritize the memory that has been marked with this "special" advise method.

I also thought about having some sort of ArrayPool, but I don't know the size of the data in advance and there are many different ranges of data sizes (from 32x32 to 4096x4096) and additionally the ArrayPools need to cooperate and lose memory in favor of other pools that currently need memory pressure is higher than on others. Thats why I have some sort of master control unit that coordinates the memory among the pools .

Its not that I urgently need such an Advise method and of course its a very uniqe scenario, it's just a thought experiment if it could potentially improve GC performance in LOH cleanups.

Does that make sense?

[Xyncgas]

1. Did you know you can use async to yield processor clocks while waiting for your IO operations that's slower (including memory de/allocations)
2. GC detects memory pressure, so if your memory pressure is high .NET will look for unused objects and free them from the memory.

[danmoseley]

@mangod9 another GC q.

[msedi]

@Xyncgas: Thanks for the info. I'm not sure if I get the first point. How do I do that?

For the second point. All my objects are in use and I don't want to given them up top early. So what my memory is currently doing is:

1. look for objects I can quickly recover (e.g. either by calculating them or by reading them again) => Fast path
2. Looking for older objects that I have to write first => Slow path
3. After that I have to call a hard GC with compacting sometimes also call EmptyWorkingSet so that I know how much memory I can fully use to reallocate new objects.

I wouldn't need this if the GC could tell how much memory is free for me so that I can calculate how many objects can be allocated until the next cleanup needs to be done. I do have to experiment with GCMemoryInfo.TotalAvailableMemoryBytes.

The question is though will I always need to put this much pressure on the GC or would it help if I could tell him some more info about the cleanup. I I wouldn't interfere it currently a back and forth, I create, the GC destroys and if the GC is not fast enough the game is over and I get an OOM.

As said above its nothing that I really need (if it even helps at all and its just nonsense what I ask) its more to have some discussion about this.

[Xyncgas]

you can buy intel's optane and use NVME backed storage.
Meanwhile for example you can await memory operations by :

        await using var input = new MemoryStream(bytes);

[msedi]

See also: #7933

[sfiruch]

The idea is a good idea, but such a hint would not be actionable for the GC. In order to collect memory, the GC has to check whether the memory is reachable from anywhere. This means that it has to scan all the stacks, all pointers from there, all pointers from there, etc. until it has found all reachable objects. That's the expensive part of GC. Even if the GC got the hint to collect a single object, it would have to determine its reachability - and for that it has to scan the "world". Now that the GC scanned the world, it might have detected a lot of unreachable objects. It makes sense to collect all these objects in one swoop.

In short: Getting a hint for a single object doesn't improve the situation over GC.Collect.

[AustinWise]

Is GCSettings.LargeObjectHeapCompactionMode what you are looking for?