Question regarding GC notification!

[CodingMadness]

Hey dude,

B4 I do begin asking, i am extremely astonished in what you have created with this library!! Very big congrats to you and wish ya all the best and luck with this project and life !

I had to say that b4 cause its litterally (next) in terms of what .net can offer .

To my question:
Is there a way to get notified by the GC, when actual memory compression happens, so for instance when you have
20 array elements of a Class "PlayerCharacter" and that class has 6 fields, and lets say that the GC moves at some point the array around in memory AND compresses it to reduce space, which would imply a change in from (itemX) to (itemX+1)
so for instance , b4 [2] were 32 bytes away from [3] and now he compacted it which makes it now only have 16 rather than 32 , as byte distance.

Is there any chance to get notified from the GC when:

1. he begins that
2. he finished that

Any idea on this much appreciated!

Cheers!

[sakno]

@Shpendicus , thanks for your feedback! GC actually compacts segments related to ephemeral generations (0 and 1). It can't compact the array. If it 20 elements long, it will stay the same during the lifetime of the array. GC can move the whole object in the memory. Additionally, there is no way to measure exact size of by-ref object (class) in the memory, because GC may add padding when object is moving from one generation to another.

P.S.: GC always apply compaction when moving objects from Gen0 to Gen1 and from Gen1 to Gen2. Gen2, by default, is not a subject of compaction, but it can be triggered explicitly from code.

[CodingMadness]

@sakno thx for ur reply!

My main point only is actually that he does not change the distance of the fields from Item0 to ItemX, like for isntance if you do:

nint distance = ref Unsafe.ByteOffset(ref first, ref other); //----------->what will this be AFTER he has moved the entire object somewhere and ahs maybe even compressed ir or whatever it does to it.

[sakno]

There is no way to predict how the objects referenced by the array elements are placed in the memory. So the distance can be any.

[sakno]

If you really care about data locality (due to performance reasons), convert PlayerCharacter to value type. In that case, all array elements will occupy contiguous memory block, instead of references (pointers) to the objects.

[CodingMadness]

If you really care about data locality (due to performance reasons), convert PlayerCharacter to value type. In that case, all array elements will occupy contiguous memory block, instead of references (pointers) to the objects.

Hmm, i cant do that cause i am building a datastructure as a wrapper for other datastructures/types so i kinda have to work on what I do get and i dont wanna constraint that, cause it should work (semtantically) for both.

And it is okay when the distance is any value, the main criteria only is that the distance does not change randomly at runtime!!

This I ask you, if that can happen, or is the layout fixed once he created the entire array?

[CodingMadness]

[CodingMadness]

If you really care about data locality (due to performance reasons), convert PlayerCharacter to value type. In that case, all array elements will occupy contiguous memory block, instead of references (pointers) to the objects.

Hmm, i cant do that cause i am building a datastructure as a wrapper for other datastructures/types so i kinda have to work on what I do get and i dont wanna constraint that, cause it should work (semtantically) for both.

And it is okay when the distance is any value, the main criteria only is that the distance does not change randomly at runtime!!

This I ask you, if that can happen, or is the layout fixed once he created the entire array?

Also it is OKAY if he compacts, but i would love to get notified for this!

So, either:

1. dont compact at all (maybe this you can force for certain objects?)
2. If you compact, notify me, so i can recompute the offsets!

[sakno]

Ok, I got it. But GC doesn't change the layout of array elements. Address of each array element is aligned in memory according to its size. For ref types (class), each element is always aligned to sizeof(nint), i.e. 4 bytes on 32-bit machine or 8 bytes on 64-bit machine. As a result, if address of array[0] is some X, then address of n-th element will be Offset = X+sizeof(nint)*n and Offset mod sizeof(nint) = 0

To detect heap compaction, you can do the following:

await GCNotification.HeapCompaction().WaitAsync();

[CodingMadness]

Ok, I got it. But GC doesn't change the layout of array elements. Address of each array element is aligned in memory according to its size. For ref types (class), each element is always aligned to sizeof(nint), i.e. 4 bytes on 32-bit machine or 8 bytes on 64-bit machine. As a result, if address of array[0] is some X, then address of n-th element will be X+sizeof(nint)*n.

To detect heap compaction, you can do the following:

await GCNotification.HeapCompaction().WaitAsync();

ahh thx mate good to know

[sakno]

With that, you will have a high fragmentation of managed memory heap. Pinned objects cannot be moved by GC. Even if you have two pinned strings placed in contiguous memory block, you can't read the contents of two strings using simple pointer arithmetic, because those strings are two different objects. .NET has Object Header, a few bytes at the beginning of each object with internal information about its type, synchronized block, etc. In other words, you will get a some portion of raw bytes unrelated to string contents.

Try to re-think the architecture for your buffer. For instance, place all strings in some rented buffer which is available in .NET and .NEXT both.

[CodingMadness]

Hmm, but does it not be costly to copy the strings into that buffer? i mean i do not have control of where the array comes from, i just know the content but not its src and such so i do not know if its a good idea to copy the entir array into a buffer?

[sakno]

We returning back to the question: what you trying to achieve? Do you want to copy N strings located randomly in memory as a contiguous buffer? If yes, you need to copy those strings in contiguous memory. Otherwise, you cannot achieve this. But copy overhead probably will be the same (or even larger) than just iterating over strings (and copy each string as a block of memory). The better way to check this is to provide benchmarks.

[CodingMadness]

I kinda followed your buffer advise, thank you!

[sakno]

I recommend to take a look at this page with information about buffers.