Home/ Questions/Q 503587
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-13T06:24:33+00:00

I’ve been profiling a method using the stopwatch class, which is sub-millisecond accurate. The

  • 0

I’ve been profiling a method using the stopwatch class, which is sub-millisecond accurate. The method runs thousands of times, on multiple threads.

I’ve discovered that most calls (90%+) take 0.1ms, which is acceptable. Occasionally, however, I find that the method takes several orders of magnitude longer, so that the average time for the call is actually more like 3-4ms.

What could be causing this?

The method itself is run from a delegate, and is essentially an event handler.

There are not many possible execution paths, and I’ve not yet discovered a path that would be conspicuously complicated.

I’m suspecting garbage collection, but I don’t know how to detect whether it has occurred.

Finally, I am also considering whether the logging method itself is causing the problem. (The logger is basically a call to a static class + event listener that writes to the console.)

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    As I commented, you really should at least describe what your method does, if you’re not willing to post some code (which would be best).

    That said, one way you can tell if garbage collection has occurred (from Windows):

    1. Run perfmon (Start->Run->perfmon)
    2. Right-click on the graph; select “Add Counters…”
    3. Under “Performance object”, select “.NET CLR Memory”
    4. From there you can select # Gen 0, 1, and 2 collections and click “Add”
    5. Now on the graph you will see a graph of all .NET CLR garbage collections
    6. Just keep this graph open while you run your application

    EDIT: If you want to know if a collection occurred during a specific execution, why not do this?

    int initialGen0Collections = GC.CollectionCount(0);
int initialGen1Collections = GC.CollectionCount(1);
int initialGen2Collections = GC.CollectionCount(2);

// run your method

if (GC.CollectionCount(0) > initialGen0Collections)
    // gen 0 collection occurred

if (GC.CollectionCount(1) > initialGen1Collections)
    // gen 1 collection occurred

if (GC.CollectionCount(2) > initialGen2Collections)
    // gen 2 collection occurred

    SECOND EDIT: A couple of points on how to reduce garbage collections within your method:

    1. You mentioned in a comment that your method adds the object passed in to “a big collection.” Depending on the type you use for said big collection, it may be possible to reduce garbage collections. For instance, if you use a List<T>, then there are two possibilities:

      a. If you know in advance how many objects you’ll be processing, you should set the list’s capacity upon construction:

      List<T> bigCollection = new List<T>(numObjects);

      b. If you don’t know how many objects you’ll be processing, consider using something like a LinkedList<T> instead of a List<T>. The reason for this is that a List<T> automatically resizes itself whenever a new item is added beyond its current capacity; this results in a leftover array that (eventually) will need to be garbage collected. A LinkedList<T> does not use an array internally (it uses LinkedListNode<T> objects), so it will not result in this garbage collection.

    2. If you are creating objects within your method (i.e., somewhere in your method you have one or more lines like Thing myThing = new Thing();), consider using a resource pool to eliminate the need for constantly constructing objects and thereby allocating more heap memory. If you need to know more about resource pooling, check out the Wikipedia article on Object Pools and the MSDN documentation on the ConcurrentBag<T> class, which includes a sample implementation of an ObjectPool<T>.

    • 0