Question

I wrote some code which monitors the output of Stopwatch using a tight loop. This loop tracks the number of ticks which have elapsed since the last iteration. I’m observing jumps of 500 microseconds 20 times a second, while most other iterations take <1µs.

Can someone explain why I’m seeing these jumps?

I’ve tried:

1. Setting processor affinity (no effect)
2. Changing thread priority (Highest/AboveNormal makes things worse)
3. Running outside of the debugger
4. Release build with optimizations

My code is below:

        Stopwatch sw = new Stopwatch();
        int crossThresholdCount = 0;
        long lastElapsedTicks = 0;
        long lastPrintTicks = 0;
        Console.WriteLine("IsHighResolution: " + Stopwatch.IsHighResolution);
        Console.WriteLine("Frequency: " + Stopwatch.Frequency);

        sw.Start();

        long thresholdTicks = 5000;  // 10000 ticks per ms
        while (true)
        {
            long tempElapsed = sw.ElapsedTicks;
            long sincePrev = tempElapsed - lastElapsedTicks;
            lastElapsedTicks = tempElapsed;

            if (sincePrev > thresholdTicks)
                crossThresholdCount++;

            // print output 
            if (crossThresholdCount > 0 && tempElapsed - lastPrintTicks > TimeSpan.TicksPerSecond)
            {
                lastPrintTicks = tempElapsed;
                Console.WriteLine("crossed " + crossThresholdCount + " times");
                crossThresholdCount = 0;
            }
        }

Answer 1

Most likely you are seeing preemptive task switching. This is when the operating system suspends your program, and goes off to execute other programs. This is how things have been since Windows 95 (Win 3.1 and earlier had cooperative multitasking, whereby you could hold the CPU for as long as you want).

By the way, there is a better way to time your execution accurately: QueryThreadCycleTime, which counts CPU cycles only when your code is executing, and so excludes such pauses.