C# TimeSpan.FromTicks() inaccurate?

Question

I have been using C# for some time now to make a small game, and while testing said game on a different PC I came across some strange elapsed time issues.

I have everything set up in this game to be updated based on time passed since the last game loop, as one should in most cases, but on the second PC everything was way off.

I found out the issue was to do with creating a TimeSpan using the FromTicks() method. I made a little test using the following code:

class Program
{
    static void Main(string[] args)
    {
        System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
        sw.Start();
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1));
        sw.Stop();
        TimeSpan t = TimeSpan.FromTicks(sw.ElapsedTicks);
        Console.WriteLine(t.ToString());
        Console.WriteLine(sw.Elapsed.ToString());
        Console.ReadKey();
    }
}

On my main PC, I ran this program and got the following:

    00:00:00.3528353
    00:00:00.9856987

Something I didn't expect at all. I thought the second result was quite inaccurate, but the first was well off.

Then I ran the same program on the other PC and got this:

    00:03:20.6866734
    00:00:00.998287

I was quite astounded.

My question here is not how I can fix this issue, I have already decided to use the second method because it’s accurate enough... rather, I ask for enlightenment.

How can this be so? Why is the first result so inaccurate? Why does this vary hugely on a different machine?

I checked on msdn in case I was using the method wrong, but the examples there show that my results should be impossible...

Note:
I think the CMOS battery is dying/dead, is that a factor?

Answer 1

Summary: The Frequency of the stopwatch can be different on different hardware which means the ticks (whose interval is based on frequency) are of a different size (and of a different size to the tick in the timespan and datetime objects).

In short, use the Elapsed property directly instead:

    TimeSpan t = sw.Elapsed;

...or use the Ticks property of Elapsed, if you need to perform calculations:

    TimeSpan t = TimeSpan.FromTicks(2*sw.Elapsed.Ticks);

Long version with references:

http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.elapsedticks.aspx is the msdn page for your elapsed ticks. Of note is:

This property represents the number of elapsed ticks in the underlying timer mechanism. A tick is the smallest unit of time that the Stopwatch timer can measure. Use the Frequency field to convert the ElapsedTicks value into a number of seconds.

And from the page on the Frequency field:

The timer frequency indicates the timer precision and resolution. For example, a timer frequency of 2 million ticks per second equals a timer resolution of 500 nanoseconds per tick. In other words, because one second equals 1 billion nanoseconds, a timer frequency of 2 million ticks per second is equivalent to 2 million ticks per 1 billion nanoseconds, which can be further simplified to 1 tick per 500 nanoseconds.

The Frequency value depends on the resolution of the underlying timing mechanism. If the installed hardware and operating system support a high-resolution performance counter, then the Frequency value reflects the frequency of that counter. Otherwise, the Frequency value is based on the system timer frequency.

Because the Stopwatch frequency depends on the installed hardware and operating system, the Frequency value remains constant while the system is running.

So essentially the frequency of the stopwatch can be different on different hardware which means the ticks are of a different size (and of a different size to the tick in the timespan and datetime objects).

Interestingly you are already using the Elapsed property StopWatch which gives you a timespan. sw.Elapsed is a TimeSpan which is probably what you are after when you are trying to get the TimeSpan object. If you want to use ticks you can use the Ticks property of this TimeSpan instead.

Alternatively you can use ElapsedMilliseconds which returns a long.

Answer 2

Timespan's Ticks and Stopwatch's Ticks are different. To reconcile, use the Stopwatch Elapsed property instead, which converts correctly to a TimeSpan based on the ticks of the machine.

    System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); 
    sw.Start();         
    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1));         
    sw.Stop();         

    // don't load a TimeSpan with ElapsedTicks, these have diff frequency,
    // call Elapsed instead to get TimeSpan.
    TimeSpan t = sw.Elapsed;         
    Console.WriteLine(t.ToString());         
    Console.ReadKey(); 

Or, you can of course divide by the frequency, etc, yourself, but it's a lot more work. The main takeaway is you should not consider TimeSpan's Ticks the same as Stopwatch's Ticks.

Related Thread: What are timer ticks, the unit used by Stopwatch.ElapsedTicks