Практическое руководство. Отображение миллисекунд в значениях даты и времени How to: Display Milliseconds in Date and Time Values

Стандартные методы форматирования даты и времени, например DateTime.ToString(), поддерживают часы, минуты и секунды, но не миллисекунды. The default date and time formatting methods, such as DateTime.ToString(), include the hours, minutes, and seconds of a time value but exclude its milliseconds component. В этом разделе показано, как включить компонент миллисекунд даты и времени в форматированные строки даты и времени. This topic shows how to include a date and time’s millisecond component in formatted date and time strings.

Отображение компонента миллисекунд для значения DateTime To display the millisecond component of a DateTime value

Если вы работаете со строковым представлением даты, преобразуйте ее в значение типа DateTime или DateTimeOffset, используя статичный метод DateTime.Parse(String) или DateTimeOffset.Parse(String). If you are working with the string representation of a date, convert it to a DateTime or a DateTimeOffset value by using the static DateTime.Parse(String) or DateTimeOffset.Parse(String) method.

Чтобы извлечь строковое представление компонента миллисекунд, вызовите метод DateTime.ToString(String)или ToString для значения даты и времени, передав ему в параметре format шаблон пользовательского формата fff или FFF , отдельно или с другим описателем пользовательского формата. To extract the string representation of a time’s millisecond component, call the date and time value’s DateTime.ToString(String) or ToString method, and pass the fff or FFF custom format pattern either alone or with other custom format specifiers as the format parameter.

Пример Example

Этот пример выводит в консоль компонент миллисекунд DateTime и значение DateTimeOffset, как отдельно, так и в составе более длинной строки даты и времени. The example displays the millisecond component of a DateTime and a DateTimeOffset value to the console, both alone and included in a longer date and time string.

Шаблон формата fff содержит конечные нули в значении миллисекунд. The fff format pattern includes any trailing zeros in the millisecond value. Шаблон формата FFF запрещает их. The FFF format pattern suppresses them. Эта разница показана в следующем примере. The difference is illustrated in the following example.

Проблема с определением полного описателя пользовательского формата, содержащего компонент миллисекунд, состоит в том, что он жестко задает формат, который может не соответствовать взаимному расположению элементов времени в текущих региональных параметрах приложения. A problem with defining a complete custom format specifier that includes the millisecond component of a date and time is that it defines a hard-coded format that may not correspond to the arrangement of time elements in the application’s current culture. Вместо этого лучше всего извлечь один из шаблонов отображения даты и времени, определенных текущим объектом языка и региональных параметров DateTimeFormatInfo, а затем изменить его для поддержки миллисекунд. A better alternative is to retrieve one of the date and time display patterns defined by the current culture’s DateTimeFormatInfo object and modify it to include milliseconds. Этот подход также показан в примере. The example also illustrates this approach. Он извлекает шаблон полного отображения даты и времени для текущих языка и региональных параметров, обратившись к свойству DateTimeFormatInfo.FullDateTimePattern, а затем добавляет в него пользовательский шаблон .ffff после шаблона секунд. It retrieves the current culture’s full date and time pattern from the DateTimeFormatInfo.FullDateTimePattern property, and then inserts the custom pattern .ffff after its seconds pattern. Обратите внимание, что в примере используется регулярное выражение для выполнения этой операции в одном методе. Note that the example uses a regular expression to perform this operation in a single method call.

Описатель настраиваемого формата также используется для отображения дробной части секунд, отличной от миллисекунд. You can also use a custom format specifier to display a fractional part of seconds other than milliseconds. Например, описатель пользовательского формата f или F отображает десятые доли секунды, описатель ff или FF — сотые доли секунды, а описатель ffff или FFFF — десятитысячные доли секунды. For example, the f or F custom format specifier displays tenths of a second, the ff or FF custom format specifier displays hundredths of a second, and the ffff or FFFF custom format specifier displays ten thousandths of a second. Дробные части миллисекунд усекаются, а не округляются в возвращаемой строке. Fractional parts of a millisecond are truncated instead of rounded in the returned string. Эти описатели формата используются в следующем примере. These format specifiers are used in the following example.

Существует возможность отображать малые дробные части секунды, например десятитысячные или стотысячные доли секунды. It is possible to display very small fractional units of a second, such as ten thousandths of a second or hundred-thousandths of a second. Однако эти значения могут не иметь смысла. However, these values may not be meaningful. Точность значений даты и времени зависит от разрешения системных часов. The precision of date and time values depends on the resolution of the system clock. В операционной системе Windows NT 3.5 и более поздних версий, а также Windows Vista разрешение часов приблизительно соответствует 10–15 миллисекундам. On Windows NT 3.5 and later, and Windows Vista operating systems, the clock’s resolution is approximately 10-15 milliseconds.

Measure time, milliseconds or microseconds for Windows C++ [duplicate]

How do you measure the execution time in milliseconds or microseconds in Windows C++?

I found many method one calling time(NULL), but it measures time in seconds only and the seconds clock() (clock_t) measure CPU time, not the actual time.

I found the function gettimeofday(Calendar time) mentioned in this paper: dropbox.com/s/k0zv8pck7ydbakz/1_7-PDF_thesis_2.pdf

This function is for Linux (compute time in milli and microseconds) and not Windows.

I found an alternative to it for Windows: dropbox.com/s/ofo99b166l7e2gf/gettimeofday.txt

And this may be relevant: stackoverflow.com/questions/1861294/how-to-calculate-execution-time-of-a-code-snippet-in-c

3 Answers 3

You can use the standard C++ library:

One thing to keep in mind is that using enables type safe, generic timing code but to get that benefit you have use it a bit differently than you would use dumb, type-unsafe timing libraries that store durations and time points in types like int . Here’s an answer that explains some specific usage scenarios and the differences between using untyped libraries and best practices for using chrono: https://stackoverflow.com/a/15839862/365496

The maintainer of Visual Studio’s standard library implementation has indicated that the low resolution of high_resolution_clock has been fixed in VS2015 via the use of QueryPerformanceCounter() .

Time in milliseconds in C

Using the following code:

I get the following output:

Start and stop times are the same. Does it mean that the program hardly takes time to complete execution?

If 1. is false, then atleast the no.of digits beyond the (.) should differ, which does not happen here. Is my logic correct?

Note: I need to calculate the time taken for execution, and hence the above code.

8 Answers 8

Yes, this program has likely used less than a millsecond. Try using microsecond resolution with timeval .

You can then query the difference (in microseconds) between stop.tv_usec — start.tv_usec . Note that this will only work for subsecond times (as tv_usec will loop). For the general case use a combination of tv_sec and tv_usec .

Edit 2016-08-19

A more appropriate approach on system with clock_gettime support would be:

This code snippet can be used for displaying time in seconds,milliseconds and microseconds:

A couple of things might affect the results you’re seeing:

1. You’re treating clock_t as a floating-point type, I don’t think it is.
2. You might be expecting ( 1^4 ) to do something else than compute the bitwise XOR of 1 and 4., i.e. it’s 5.
3. Since the XOR is of constants, it’s probably folded by the compiler, meaning it doesn’t add a lot of work at runtime.
4. Since the output is buffered (it’s just formatting the string and writing it to memory), it completes very quickly indeed.

You’re not specifying how fast your machine is, but it’s not unreasonable for this to run very quickly on modern hardware, no.

If you have it, try adding a call to sleep() between the start/stop snapshots. Note that sleep() is POSIX though, not standard C.

You can use gettimeofday() together with the timedifference_msec() function below to calculate the number of milliseconds elapsed between two samples:

Note that, when using gettimeofday() , you need to take seconds into account even if you only care about microsecond differences because tv_usec will wrap back to zero every second and you have no way of knowing beforehand at which point within a second each sample is obtained.

Here is what I write to get the timestamp in millionseconds.

The clock() function returns an approximation of processor time used by the program.

So there is no indication you should treat it as milliseconds. Some standards require precise value of CLOCKS_PER_SEC , so you could rely on it, but I don’t think it is advisable. Second thing is that, as @unwind stated, it is not float/double. Man times suggests that will be an int. Also note that:

this function will return the same value approximately every 72 minutes

And if you are unlucky you might hit the moment it is just about to start counting from zero, thus getting negative or huge value (depending on whether you store the result as signed or unsigned value).

Will most probably print garbage as treating any int as float is really not defined behaviour (and I think this is where most of your problem comes). If you want to make sure you can always do:

Though I would rather go for printing it as long long int at first:

Get system time accurate to milliseconds in Windows cmd

I’m trying to get the system time accurate to milliseconds in Windows cmd. I know that it’s possible to get centisecond accuracy using:

I’ve found other questions that are asking the exact same thing but there is no answer that fully answers the question. Here is what I’ve found so far:

This solution is only good for centisecond accuracy (same as what I described above): Print time in a batch file (milliseconds)

This solution provides a timer solution but not a print current timestamp solution: Print Batch Time in Milliseconds

Any help would be much appreciated.

2 Answers 2

As Neil pointed out there is no native solution in cmd. For anyone who has the option of using PowerShell instead, you could use the following:

There may be a more succinct way of doing it but this worked for my purposes.

Since the question is tagged cmd the appropriate command line for calling this from cmd is:

might be a workable thing for you

If you have admin privs,
and if you’re running on a WINDOWS system
and if you have a networked machine configured as a time slave (to another machine),
and if want to only measure TIME DELTAS,
you can query the Windows «W32tm» utility.

It gives you the microseconds since the last Time Synchronization, via the call

(Lotsa stuff prints out)

then pluck out only the line with the last sync time

Then, from a BAT file, do like:

(what you want to measure goes here)

Little more work if you want to automate the subtraction, but it can be done

How can I get the Windows system time with millisecond resolution?

How can I get the Windows system time with millisecond resolution?

If the above is not possible, then how can I get the operating system start time? I would like to use this value together with timeGetTime() in order to compute a system time with millisecond resolution.

Thank you in advance.

10 Answers 10

GetTickCount will not get it done for you.

Look into QueryPerformanceFrequency / QueryPerformanceCounter . The only gotcha here is CPU scaling though, so do your research.

Try this article from MSDN Magazine. It’s actually quite complicated.

This is an elaboration of the above comments to explain the some of the whys.

First, the GetSystemTime* calls are the only Win32 APIs providing the system’s time. This time has a fairly coarse granularity, as most applications do not need the overhead required to maintain a higher resolution. Time is (likely) stored internally as a 64-bit count of milliseconds. Calling timeGetTime gets the low order 32 bits. Calling GetSystemTime, etc requests Windows to return this millisecond time, after converting into days, etc and including the system start time.

There are two time sources in a machine: the CPU’s clock and an on-board clock (e.g., real-time clock (RTC), Programmable Interval Timers (PIT), and High Precision Event Timer (HPET)). The first has a resolution of around

0.5ns (2GHz) and the second is generally programmable down to a period of 1ms (though newer chips (HPET) have higher resolution). Windows uses these periodic ticks to perform certain operations, including updating the system time.

Applications can change this period via timerBeginPeriod; however, this affects the entire system. The OS will check / update regular events at the requested frequency. Under low CPU loads / frequencies, there are idle periods for power savings. At high frequencies, there isn’t time to put the processor into low power states. See Timer Resolution for further details. Finally, each tick has some overhead and increasing the frequency consumes more CPU cycles.