Question

If you want to receive GC notifications (for example, to transfer load between nodes during collection), then you can use the trio of methods, GC.RegisterForFullGCNotification, GC.WaitForFullGCApproach and GC.WaitForFullGCComplete – however, the parameters passed to GC.RegisterForFullGCNotification seem largely to be meaningless, and no real world guidance is given on how to choose suitable values. There are vague notes, like from here:

Use the following guidelines for specifying the maxGenerationThreshold
and largeObjectHeapThreshold parameters:

The larger the threshold value, the further away in time the
collection will likely occur and the sooner the notification will be
raised.

A larger threshold value provides more opportunities for the runtime
to check for an approaching collection. This increases the likelihood
that you will be notified. However, you should not set the threshold
too high because that results in a longer wait before the runtime
induces the next collection.

When you induce a collection yourself upon notification using a high
threshold value, more objects are reclaimed than would be reclaimed by
the runtime’s next collection.

The smaller the threshold value, the greater the likelihood that a
collection will occur sooner and the notification will be raised
later.

or from here

maxGenerationThreshold A number between 1 and 99 that specifies when
the notification should be raised based on the objects promoted in
generation 2.

largeObjectHeapThreshold A number between 1 and 99 that
specifies when the notification should be raised based on the objects
that are allocated in the large object heap.

If you specify a value
that is too high, there is a high probability that you will receive a
notification, but it could be too long a period to wait before the
runtime causes a collection. If you induce a collection yourself, you
may reclaim more objects than would be reclaimed if the runtime causes
the collection.

If you specify a value that is too low, the runtime may cause the
collection before you have had sufficient time to be notified.

However, that doesn’t really help me choose sensible / correct numbers, except “not too high, not too low”.

Currently, I’m just using one of the few provided examples, i.e.

// these are magic numbers; nobody really knows what they mean...
GC.RegisterForFullGCNotification(10, 10);

but… it is very unclear whether 10,10 is a correct choice, an arbitrary choice, or how I should change this to reflect any particular usage scenario.

So: is there any correct way of choosing these numbers? Or is it just trial-and-error, based on whether I’m getting the events too early/late?

Answer 1

The best answer I could find on picking these parameters can be found in http://assets.red-gate.com/community/books/assets/Under_the_Hood_of_.NET_Management.pdf

You may be wondering about the magic constants in the call to
RegisterForFullGC Notification. This method takes two parameters,
maxGenerationThreshold and largeObjectHeapThreshold. Both parameters
can be integers between 1 and 99. Larger values for these parameters
will cause the notification to be raised earlier, and smaller values
will cause the notification to be raised closer to when the event
actually takes place.

The first parameter allows you to specify that
you want to be notified based on the number of objects that have
survived to Generation 2, and the second parameter specifies that you
want to be notified based on the size of the Large Object Heap.
However, neither parameter specifies an absolute value, so passing in
30 for the maxGenerationThreshold does not imply triggering a
Notification when there are 30 objects in Generation 2; it simply
means that you want to be notified earlier than if you had passed in a
value of 10. Unless you are specifically more interested in one
trigger over the other, you may want to pass in the same value for
each parameter, as this will help ensure that you are notified at the
same stage, regardless of the trigger.

A larger value will give you
more time to deal with memory pressure, but you just need to be
careful not to set it too high. The higher you set the thresholds, the
quicker you get notified but the longer you have to wait on the GC.
Play with these parameters in your application to see what works best
for your load and the types of objects consuming your memory.

So in answer, based on the above, it largely is trial and error however the two values you use for each parameter are likely to be the same.