• Give More Feedback

Best way to get elapsed time in miliseconds. Returns the current time in milliseconds relative to some. Browse other questions tagged c++ windows or ask your. How do I get system up time since the start of the system? How do I get system up time in milliseconds in c++? Using GetTickCount64.

@kaufmed; Well this, DateTime.Now, does give the current date and time but date and time as stored in a date time type is the total time since Jan 1, 00001. So when you apply a Ticks method to it, it returns the total since Jan 1, 00001.

If you just want the total time in the current day then you need to get the time at 12:00 AM and subtract it from the current date time and then apply the Ticks method and then apply the TotalMilliseconds method to that which will return the total milliseconds just for today as can be seen from the code snippet. // This will give the total number of millseconds from Jan 1, 00001 double totalMill = (new TimeSpan(DateTime.Now.Ticks)).TotalMilliseconds; Console.WriteLine(totalMill.ToString); // This will give the total milliseconds in today double tickDiff = ((new TimeSpan(DateTime.Now.Ticks)) - (new TimeSpan(DateTime.Today.Ticks))).TotalMilliseconds; Console.WriteLine(tickDiff.ToString); Select all Fernando. This should cover three of the possibilities. Let us know the status of this question. // Total millseconds since midnight double sinceMidnight2 = (DateTime.Now - DateTime.Today).TotalMilliseconds; // Total milliseonds since Jan. 1, 1970 double sinceJanFirst1970 = (DateTime.Now - DateTime.Parse('1/1/1870 0:0:0')).TotalMilliseconds; // Total milliseconds since Jan. 0001 or the start of the DateTime value or DateTimeMinValue double sinceBeginingOfTime = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds; Select all.

I'm trying to do it using two FILETIMEs, casting them to ULONGLONGs, substracting the ULONGLONGs, and dividing the result by 10000. But it's pretty slow, and I want to know if there is a better way to do it.I use c with visual studio 2008 express edition. This is what I'm using: FILETIME filetime,filetime2; GetSystemTimeAsFileTime(&filetime); Sleep(100); GetSystemTimeAsFileTime(&filetime2); ULONGLONG time1,time2; time1 = (((ULONGLONG) filetime.dwHighDateTime). Generally timeGetTime is best for timing game logic - GetTickCount isn't quite high enough resolution, and QPC & RDTSC are a lot more trouble than they are worth for that purpose. For profiling on the other hand, either RDTSC or QPC can be quite worthwhile. I prefer RDTSC over QPC, though microsoft recommends QPC. The four common time functions I use on win32: GetTickCount returns the current time in milliseconds relative to some arbitrary zero (usually, though not always system boot time), as a 32 bit integer (so it wraps every 49 days or so).

It is usually the fastest method to measure a time. Unfortunately it is low resolution - typically it only updates 64 times per second. Contrary to popular rumor, calling timeBeginPeriod(1) will not increase its resolution on any system I've tested that on.

There is also a 64 bit variant if you're worried about it wrapping. TimeGetTime returns the current time in milliseconds relative to some arbitrary zero, as a 32 bit value (so it wraps after 49 days or so).

It's not as fast as GetTickCount, but still pretty reasonable. It can be accurate to a single millisecond, though that may require calling timeBeginPeriod(1) first. Using timeGetTime requires linking against winmm.lib and including Mmsystem.h. QueryPerformanceCounter returns the current time in arbitrary units as a 64 bit integer. You can figure out what the units are by calling QueryPerformanceFrequency, and the units will not change (absent a reboot).

The underlying implementation of this varies widely, and each implementation has its own quirks and bugs that may occur on some hardware, making this obnoxious to use in widely deployed applications. Some implementations are very slow, others are reasonable, though none are as fast as GetTickCount or even timeGetTime. Typically timing resolution is better than 1 microsecond, though not necessarily much better.

RDTSC is an x86 / x64 assembly language opcode that returns the current time in units of CPU cycles (ie as a 64 bit integer. On some compilers it can be accessed as an intrinsic (rdstc), on others you'll need inline asm. Its speed varies a bit between CPUs but is usually pretty reasonable - typically significantly faster than QueryPerformanceCounter but not as fast as GetTickCount. Unfortunately it has a few quirks - not as many as QueryPerformanceCounter, but still a lot more than the lower resolution time functions.

It can sometimes run backwards on multicore CPUs when you switch cores due to imperfect synchronization between cores, the units are difficult to figure out, and the units can change in mid-timing due to power management changing the rate of the CPU clock. Note that each of these four methods can drift relative to the other three - there is no clear authoritative flow of time. To answer your question: there is no 'best' solution to measure time. Every method has its own advantages/disadvantages. It all depends of your needs.

Here is several questions you should ask yourself before choosing one solution:. timer resolution. Do you really need a precise timer (.

While it's true that some timing methods have problems on SMP, these are always bugs in the HAL, BIOS, or other driver-related problems, and must be fixed at that level. It's rare that you can solve the problem by switching to a different timing method. For example I've seen QPC run backwards because of bad drivers, but GetTickCount would have too - the only reason it didn't was because the jump was 50µsec, so it didn't notice it at all. At best, your app can do a max call with the previously returned value. – user744 Apr 4 '12 at 14:37. As it is, QPC and equivalent functions on other OSs like POSIX clockgettime, are all specified to not run backwards even on SMP systems, and independent of current CPU frequency.

Give More Feedback

So it's bad advice to caution people away from them and towards worse timing functions, because any other timing functions would likely suffer the same problems if you could ever get them to work as precisely as you wanted from QPC in the first place. So yeah, there is a best solution: QPC, clockgettime, and machabsolutetime.

For game loop timing, there's no reason to use anything else if those are available. – user744 Apr 4 '12 at 14:40.