Have Geek Brain

What affects GC timing?

I know it is impossible to know when a GC occurs, but there are factors that will tell you how often / when it can happen. What are these factors? First, how many objects have been created, etc.

+2


a source to share


3 answers


The short answer is that the following events trigger the collection cycle:

Allocation exceeds Gen0 threshold

Collection for a specific generation occurs when the memory threshold for that generation is hit. In the .NET version 1.0 implementation, the initial thresholds for generations 0, 1, and 2 are 256 kilobytes (KB), 2 megabytes (MB), and 10 MB, respectively. Note that the GC can dynamically adjust these thresholds based on application distribution patterns. Objects larger than 85 KB are automatically placed on the LOB heap.

System.GC.Collect()

called



Allocation occurs only in Gen0. After every GC Gen0 is empty. New allocations will fill Gen0 and the next GC will happen, and so on. The problem with calling GC.Collect () manually is that you may end up calling it more often than you predicted (due to the CLR calling it as well) and performance degrades because you run GC loops before their schedule.

The system is in a low memory situation

It is affected by other processes in the system, which means that you really have no control over it, other than that you clean up resources in your processes and components properly.

+4


a source


Garbage collection occurs when one of the following conditions is true:

The system has low physical memory.



The memory used by allocated objects in the managed heap has exceeded the allowed threshold. This means that the memory usage threshold has been exceeded on the managed heap. This threshold is continuously adjusted as the process starts.

The GC.Collect method is called. In almost all cases, you do not need to call this method because the garbage collector runs continuously. This method is mainly used for unique situations and testing.

+1


a source


For the desktop version of C #, there are several factors:

  • Memory allocation size (every time 1MB is allocated, GC level 1 starts)
  • System memory pressure (if the amount of physical memory gets low, the GC can be started)
  • Virtual memory commits (if the system wants to commit memory pages then GC can be started before starting work)
  • Programmatic launch from code.
  • Other heuristics can be used by the GC to trigger collections.

If you're wondering when tier 3 collections are collected in the .NET Framework 3.0 and up, there are GC notifications you can subscribe to to get notifications before they happen: RegisterForFullGCNotification

0


a source






More articles:


All Articles