Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c > #168120 > unrolled thread

what is the best way to get microseconds of time on Windows in C or C++ ?

Back to article view | Back to comp.lang.c

Contents

  what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-03 20:14 -0500
    Re: what is the best way to get microseconds of time on Windows in C or C++ ? DFS <nospam@dfs.com> - 2022-11-03 21:51 -0400
      Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 00:06 -0500
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Christian Gollwitzer <auriocus@gmx.de> - 2022-11-04 08:03 +0100
          Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 14:32 -0500
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2022-11-04 09:07 -0700
          Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 14:33 -0500
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Opus <ifonly@youknew.org> - 2022-11-06 20:53 +0100
    Re: what is the best way to get microseconds of time on Windows in C or C++ ? Juha Nieminen <nospam@thanks.invalid> - 2022-11-04 07:35 +0000
      Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 14:24 -0500
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2022-11-04 19:50 +0000
          Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 15:16 -0500
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2022-11-04 15:05 -0700
          Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 17:35 -0500
            Re: what is the best way to get microseconds of time on Windows in C or C++ ? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-11-04 15:56 -0700
            Re: what is the best way to get microseconds of time on Windows in C or C++ ? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2022-11-04 16:15 -0700
    Re: what is the best way to get microseconds of time on Windows in C or C++ ? scott@slp53.sl.home (Scott Lurndal) - 2022-11-04 13:44 +0000
      Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-04 14:34 -0500
      Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-14 16:58 -0600
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2022-11-14 17:36 -0800
          Re: what is the best way to get microseconds of time on Windows in C or C++ ? Lynn McGuire <lynnmcguire5@gmail.com> - 2022-11-15 17:26 -0600
            Re: what is the best way to get microseconds of time on Windows in C or C++ ? Andreas <nospam@gmx.de> - 2022-11-16 13:15 +0100
    Re: what is the best way to get microseconds of time on Windows in C or C++ ? Bonita Montero <Bonita.Montero@gmail.com> - 2022-11-04 20:49 +0100
      Re: what is the best way to get microseconds of time on Windows in C or C++ ? Bart <bc@freeuk.com> - 2022-11-04 22:31 +0000
        Re: what is the best way to get microseconds of time on Windows in C or C++ ? Bonita Montero <Bonita.Montero@gmail.com> - 2022-11-05 06:40 +0100
    Re: what is the best way to get microseconds of time on Windows in C or C++ ? Manu Raju <MR@invalid.invalid> - 2022-11-20 21:30 +0000

Page 1 of 2  [1] 2  Next page →

#168120 — what is the best way to get microseconds of time on Windows in C or C++ ?

What is the best way to get microseconds of time on Windows in C or C++ 
?  I am currently using the following code to get the current time:

	std::time_t t = std::time (0);   // get time now
	std::tm * now = std::localtime ( & t);
	integer iyear = now -> tm_year + 1900;
	integer imonth = now -> tm_mon + 1;
	integer iday = now -> tm_mday;
	integer ihour = now -> tm_hour;
	integer imin = now -> tm_min;
	integer isec = now -> tm_sec;
	integer ihund = 0;

Thanks,
Lynn

[toc] | [next] | [standalone]

#168121

On 11/3/2022 9:14 PM, Lynn McGuire wrote:
> What is the best way to get microseconds of time on Windows in C or C++ 
> ?  I am currently using the following code to get the current time:
> 
>      std::time_t t = std::time (0);   // get time now
>      std::tm * now = std::localtime ( & t);
>      integer iyear = now -> tm_year + 1900;
>      integer imonth = now -> tm_mon + 1;
>      integer iday = now -> tm_mday;
>      integer ihour = now -> tm_hour;
>      integer imin = now -> tm_min;
>      integer isec = now -> tm_sec;
>      integer ihund = 0;
> 
> Thanks,
> Lynn


https://learn.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps


I used it like this:
----------------------------------------------------------------
LARGE_INTEGER frequency,start,end;

//calc elapsed time
double elapsedtime(LARGE_INTEGER startingtimer)
{
   QueryPerformanceCounter(&end);
   return (end.QuadPart - startingtimer.QuadPart) / 
(double)frequency.QuadPart;
}


int main(void)
{	
	
     //turn on Windows program timing
     QueryPerformanceFrequency(&frequency);

     //start timing a piece of code
     QueryPerformanceCounter(&start);
     ...
     ...
     printf(" %.4fs to execute\n",elapsedtime(start));

}
----------------------------------------------------------------

[toc] | [prev] | [next] | [standalone]

#168122

On 11/3/2022 8:51 PM, DFS wrote:
> On 11/3/2022 9:14 PM, Lynn McGuire wrote:
>> What is the best way to get microseconds of time on Windows in C or 
>> C++ ?  I am currently using the following code to get the current time:
>>
>>      std::time_t t = std::time (0);   // get time now
>>      std::tm * now = std::localtime ( & t);
>>      integer iyear = now -> tm_year + 1900;
>>      integer imonth = now -> tm_mon + 1;
>>      integer iday = now -> tm_mday;
>>      integer ihour = now -> tm_hour;
>>      integer imin = now -> tm_min;
>>      integer isec = now -> tm_sec;
>>      integer ihund = 0;
>>
>> Thanks,
>> Lynn
> 
> 
> https://learn.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps
> 
> 
> I used it like this:
> ----------------------------------------------------------------
> LARGE_INTEGER frequency,start,end;
> 
> //calc elapsed time
> double elapsedtime(LARGE_INTEGER startingtimer)
> {
>    QueryPerformanceCounter(&end);
>    return (end.QuadPart - startingtimer.QuadPart) / 
> (double)frequency.QuadPart;
> }
> 
> 
> int main(void)
> {
> 
>      //turn on Windows program timing
>      QueryPerformanceFrequency(&frequency);
> 
>      //start timing a piece of code
>      QueryPerformanceCounter(&start);
>      ...
>      ...
>      printf(" %.4fs to execute\n",elapsedtime(start));
> 
> }
> ----------------------------------------------------------------

I forgot to add I would prefer a portable way if possible.  I suspect 
that is not possible though below the second resolution.

Thanks,
Lynn McGuire

[toc] | [prev] | [next] | [standalone]

#168123

HI Lynn,
Am 04.11.22 um 06:06 schrieb Lynn McGuire:
> On 11/3/2022 8:51 PM, DFS wrote:
>> On 11/3/2022 9:14 PM, Lynn McGuire wrote:
>>> What is the best way to get microseconds of time on Windows in C or 
>>> C++ ?  I am currently using the following code to get the current time:
>>>

>> ----------------------------------------------------------------
> 
> I forgot to add I would prefer a portable way if possible.  I suspect 
> that is not possible though below the second resolution.
> 

I fear it is not possible in a portable way. Here you can find some 
description about how Tcl has solved this issue especially for Windows:

https://core.tcl-lang.org/tips/doc/trunk/tip/7.md

The implementation is here:

https://github.com/tcltk/tcl/blob/main/win/tclWinTime.c

and here for Unix:

https://github.com/tcltk/tcl/blob/main/unix/tclUnixTime.c

(BSD licensed, in any case)

	Christian

[toc] | [prev] | [next] | [standalone]

#168128

On 11/4/2022 2:03 AM, Christian Gollwitzer wrote:
> HI Lynn,
> Am 04.11.22 um 06:06 schrieb Lynn McGuire:
>> On 11/3/2022 8:51 PM, DFS wrote:
>>> On 11/3/2022 9:14 PM, Lynn McGuire wrote:
>>>> What is the best way to get microseconds of time on Windows in C or 
>>>> C++ ?  I am currently using the following code to get the current time:
>>>>
> 
>>> ----------------------------------------------------------------
>>
>> I forgot to add I would prefer a portable way if possible.  I suspect 
>> that is not possible though below the second resolution.
>>
> 
> I fear it is not possible in a portable way. Here you can find some 
> description about how Tcl has solved this issue especially for Windows:
> 
> https://core.tcl-lang.org/tips/doc/trunk/tip/7.md
> 
> The implementation is here:
> 
> https://github.com/tcltk/tcl/blob/main/win/tclWinTime.c
> 
> and here for Unix:
> 
> https://github.com/tcltk/tcl/blob/main/unix/tclUnixTime.c
> 
> (BSD licensed, in any case)
> 
>      Christian

Thanks !

Lynn

[toc] | [prev] | [next] | [standalone]

#168126

Lynn McGuire <lynnmcguire5@gmail.com> writes:
> On 11/3/2022 8:51 PM, DFS wrote:
>> On 11/3/2022 9:14 PM, Lynn McGuire wrote:
>>> What is the best way to get microseconds of time on Windows in C or
>>> C++ ?  I am currently using the following code to get the current
>>> time:
>>>
>>>      std::time_t t = std::time (0);   // get time now
>>>      std::tm * now = std::localtime ( & t);
>>>      integer iyear = now -> tm_year + 1900;
>>>      integer imonth = now -> tm_mon + 1;
>>>      integer iday = now -> tm_mday;
>>>      integer ihour = now -> tm_hour;
>>>      integer imin = now -> tm_min;
>>>      integer isec = now -> tm_sec;
>>>      integer ihund = 0;
>>>
>>> Thanks,
>>> Lynn
>> 
>> https://learn.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps
>> 
>> I used it like this:
>> ----------------------------------------------------------------
>> LARGE_INTEGER frequency,start,end;
>> //calc elapsed time
>> double elapsedtime(LARGE_INTEGER startingtimer)
>> {
>>    QueryPerformanceCounter(&end);
>>    return (end.QuadPart - startingtimer.QuadPart) /
>> (double)frequency.QuadPart;
>> }
>> 
>> int main(void)
>> {
>>      //turn on Windows program timing
>>      QueryPerformanceFrequency(&frequency);
>>      //start timing a piece of code
>>      QueryPerformanceCounter(&start);
>>      ...
>>      ...
>>      printf(" %.4fs to execute\n",elapsedtime(start));
>> }
>> ----------------------------------------------------------------
>
> I forgot to add I would prefer a portable way if possible.  I suspect
> that is not possible though below the second resolution.

The resolution of the time() function is unspecified (not even
implementation-defined).  In practice, time_t is almost universally an
integer type representing seconds since some epoch, usually 1970-01-01
00:00:00 UTC, but it could even be floating-point.

C11 adds the type struct timespec and the function timespec_get() which
gives a result with a resolution of 1 nanosecond.  A footnote in the
standard says:

    Although a struct timespec object describes times with nanosecond
    resolution, the available resolution is system dependent and may
    even be greater than 1 second.

The standard says that struct timespec has the following members:

    time_t tv_sec; // whole seconds — ≥ 0
    long tv_nsec; // nanoseconds — [0, 999999999]

which strongly implies that the resulution of time_t is 1 second, but
the standard still doesn't say so.  Possibly an implementation could use
different encodings for the time_t value from time() and the time_t
value from timespec_get(), though that's unlikely in practice.

clock() returns a value of type clock_t, which is typically double, but
that's also unspecified -- and it measures processor time, not wall
clock time.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for XCOM Labs
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]

#168129

On 11/4/2022 11:07 AM, Keith Thompson wrote:
> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>> On 11/3/2022 8:51 PM, DFS wrote:
>>> On 11/3/2022 9:14 PM, Lynn McGuire wrote:
>>>> What is the best way to get microseconds of time on Windows in C or
>>>> C++ ?  I am currently using the following code to get the current
>>>> time:
>>>>
>>>>       std::time_t t = std::time (0);   // get time now
>>>>       std::tm * now = std::localtime ( & t);
>>>>       integer iyear = now -> tm_year + 1900;
>>>>       integer imonth = now -> tm_mon + 1;
>>>>       integer iday = now -> tm_mday;
>>>>       integer ihour = now -> tm_hour;
>>>>       integer imin = now -> tm_min;
>>>>       integer isec = now -> tm_sec;
>>>>       integer ihund = 0;
>>>>
>>>> Thanks,
>>>> Lynn
>>>
>>> https://learn.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps
>>>
>>> I used it like this:
>>> ----------------------------------------------------------------
>>> LARGE_INTEGER frequency,start,end;
>>> //calc elapsed time
>>> double elapsedtime(LARGE_INTEGER startingtimer)
>>> {
>>>     QueryPerformanceCounter(&end);
>>>     return (end.QuadPart - startingtimer.QuadPart) /
>>> (double)frequency.QuadPart;
>>> }
>>>
>>> int main(void)
>>> {
>>>       //turn on Windows program timing
>>>       QueryPerformanceFrequency(&frequency);
>>>       //start timing a piece of code
>>>       QueryPerformanceCounter(&start);
>>>       ...
>>>       ...
>>>       printf(" %.4fs to execute\n",elapsedtime(start));
>>> }
>>> ----------------------------------------------------------------
>>
>> I forgot to add I would prefer a portable way if possible.  I suspect
>> that is not possible though below the second resolution.
> 
> The resolution of the time() function is unspecified (not even
> implementation-defined).  In practice, time_t is almost universally an
> integer type representing seconds since some epoch, usually 1970-01-01
> 00:00:00 UTC, but it could even be floating-point.
> 
> C11 adds the type struct timespec and the function timespec_get() which
> gives a result with a resolution of 1 nanosecond.  A footnote in the
> standard says:
> 
>      Although a struct timespec object describes times with nanosecond
>      resolution, the available resolution is system dependent and may
>      even be greater than 1 second.
> 
> The standard says that struct timespec has the following members:
> 
>      time_t tv_sec; // whole seconds — ≥ 0
>      long tv_nsec; // nanoseconds — [0, 999999999]
> 
> which strongly implies that the resulution of time_t is 1 second, but
> the standard still doesn't say so.  Possibly an implementation could use
> different encodings for the time_t value from time() and the time_t
> value from timespec_get(), though that's unlikely in practice.
> 
> clock() returns a value of type clock_t, which is typically double, but
> that's also unspecified -- and it measures processor time, not wall
> clock time.

Thanks !

Lynn

[toc] | [prev] | [next] | [standalone]

#168143

Le 04/11/2022 à 06:06, Lynn McGuire a écrit :
> I forgot to add I would prefer a portable way if possible.  I suspect 
> that is not possible though below the second resolution.

You're asking specifically on Windows, and then you now want a portable 
solution. There isn't. But you could write your own compatibility layer, 
calling either Windows API functions or POSIX functions. This isn't 
rocket science. I've done that long ago and keep reusing it. There may 
of course be many third-party code/libraries doing just that if you 
don't want to do it yourself.

IME, using performance counters on Windows is the only sure way of 
getting proper resolution. Any third-party code will use them in one way 
or another. Why not do that yourself, it'll be only a few lines of code 
to write a compatibility layer.

[toc] | [prev] | [next] | [standalone]

#168124

In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
> What is the best way to get microseconds of time on Windows in C or C++ 

It's a bit unclear whether you mean "time in microseconds units" or "time
at the microseconds resolution".

Because the latter may not be even possible (portable or not). Just because
some time function returns time "in microseconds" that doesn't mean that it
uses microsecond resolution (in other words, the value it returns may well
change at longer intervals than every microsecond; probably *significantly*
longer intervals).

It is possible to get some kind of timing at the CPU clock cycle interval
(in most modern CPUs, at least), which is about as accurate as you can
possibly get, but I don't know if there are eg. some system functions that
will return elapsed clock cycles converted into the equivalent amount of
microseconds.

[toc] | [prev] | [next] | [standalone]

#168127

On 11/4/2022 2:35 AM, Juha Nieminen wrote:
> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>> What is the best way to get microseconds of time on Windows in C or C++
> 
> It's a bit unclear whether you mean "time in microseconds units" or "time
> at the microseconds resolution".
> 
> Because the latter may not be even possible (portable or not). Just because
> some time function returns time "in microseconds" that doesn't mean that it
> uses microsecond resolution (in other words, the value it returns may well
> change at longer intervals than every microsecond; probably *significantly*
> longer intervals).
> 
> It is possible to get some kind of timing at the CPU clock cycle interval
> (in most modern CPUs, at least), which is about as accurate as you can
> possibly get, but I don't know if there are eg. some system functions that
> will return elapsed clock cycles converted into the equivalent amount of
> microseconds.

Get time at the microseconds resolution.   My calculation engine creates 
a bunch of temporary files and I use the time to create unique names for 
those temporary files.  Seconds should be good enough for uniqueness but 
I like adding microseconds as a guarantee.  Something like
    uniquac1.out.009.20181972.20220912

Thanks,
Lynn

[toc] | [prev] | [next] | [standalone]

#168132

Lynn McGuire <lynnmcguire5@gmail.com> writes:

> On 11/4/2022 2:35 AM, Juha Nieminen wrote:
>> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>>> What is the best way to get microseconds of time on Windows in C or C++
>> It's a bit unclear whether you mean "time in microseconds units" or "time
>> at the microseconds resolution".
>> Because the latter may not be even possible (portable or not). Just because
>> some time function returns time "in microseconds" that doesn't mean that it
>> uses microsecond resolution (in other words, the value it returns may well
>> change at longer intervals than every microsecond; probably *significantly*
>> longer intervals).
>> It is possible to get some kind of timing at the CPU clock cycle interval
>> (in most modern CPUs, at least), which is about as accurate as you can
>> possibly get, but I don't know if there are eg. some system functions that
>> will return elapsed clock cycles converted into the equivalent amount of
>> microseconds.
>
> Get time at the microseconds resolution.  My calculation engine
> creates a bunch of temporary files and I use the time to create unique
> names for those temporary files.  Seconds should be good enough for
> uniqueness but I like adding microseconds as a guarantee.  Something
> like
>    uniquac1.out.009.20181972.20220912

Have you ruled out tmpnam and tmpfile?

-- 
Ben.

[toc] | [prev] | [next] | [standalone]

#168133

On 11/4/2022 2:50 PM, Ben Bacarisse wrote:
> Lynn McGuire <lynnmcguire5@gmail.com> writes:
> 
>> On 11/4/2022 2:35 AM, Juha Nieminen wrote:
>>> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>>>> What is the best way to get microseconds of time on Windows in C or C++
>>> It's a bit unclear whether you mean "time in microseconds units" or "time
>>> at the microseconds resolution".
>>> Because the latter may not be even possible (portable or not). Just because
>>> some time function returns time "in microseconds" that doesn't mean that it
>>> uses microsecond resolution (in other words, the value it returns may well
>>> change at longer intervals than every microsecond; probably *significantly*
>>> longer intervals).
>>> It is possible to get some kind of timing at the CPU clock cycle interval
>>> (in most modern CPUs, at least), which is about as accurate as you can
>>> possibly get, but I don't know if there are eg. some system functions that
>>> will return elapsed clock cycles converted into the equivalent amount of
>>> microseconds.
>>
>> Get time at the microseconds resolution.  My calculation engine
>> creates a bunch of temporary files and I use the time to create unique
>> names for those temporary files.  Seconds should be good enough for
>> uniqueness but I like adding microseconds as a guarantee.  Something
>> like
>>     uniquac1.out.009.20181972.20220912
> 
> Have you ruled out tmpnam and tmpfile?

I just ported this code from F77 to C++.  I totally forgot about tmpnam 
and tmpfile.

Thanks,
Lynn

[toc] | [prev] | [next] | [standalone]

#168134

Lynn McGuire <lynnmcguire5@gmail.com> writes:
> On 11/4/2022 2:35 AM, Juha Nieminen wrote:
>> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>>> What is the best way to get microseconds of time on Windows in C or C++
>> It's a bit unclear whether you mean "time in microseconds units" or
>> "time
>> at the microseconds resolution".
>> Because the latter may not be even possible (portable or not). Just
>> because
>> some time function returns time "in microseconds" that doesn't mean that it
>> uses microsecond resolution (in other words, the value it returns may well
>> change at longer intervals than every microsecond; probably *significantly*
>> longer intervals).
>> It is possible to get some kind of timing at the CPU clock cycle
>> interval
>> (in most modern CPUs, at least), which is about as accurate as you can
>> possibly get, but I don't know if there are eg. some system functions that
>> will return elapsed clock cycles converted into the equivalent amount of
>> microseconds.
>
> Get time at the microseconds resolution.   My calculation engine
> creates a bunch of temporary files and I use the time to create unique
> names for those temporary files.  Seconds should be good enough for
> uniqueness but I like adding microseconds as a guarantee.  Something
> like
>    uniquac1.out.009.20181972.20220912

An alternative is to keep a counter, incremented for each generated file
name, and append it to the file name, perhaps resetting to 0 when the
seconds count advances.  If your only requirement is uniqueness, that
should be good enough.

Digression: I remember an implementation of gettimeofday() that did
something like that (on SunOS, maybe?).  The system clock had a
resolution of 0.01 second, so the value of tv_usec on successive calls
might be:
    420000
    420001
    420002
    430000
    430001
    430002
    ...
I don't remember whether the implicit counter was per-process or
system-wide.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for XCOM Labs
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]

#168136

On 11/4/2022 5:05 PM, Keith Thompson wrote:
> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>> On 11/4/2022 2:35 AM, Juha Nieminen wrote:
>>> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>>>> What is the best way to get microseconds of time on Windows in C or C++
>>> It's a bit unclear whether you mean "time in microseconds units" or
>>> "time
>>> at the microseconds resolution".
>>> Because the latter may not be even possible (portable or not). Just
>>> because
>>> some time function returns time "in microseconds" that doesn't mean that it
>>> uses microsecond resolution (in other words, the value it returns may well
>>> change at longer intervals than every microsecond; probably *significantly*
>>> longer intervals).
>>> It is possible to get some kind of timing at the CPU clock cycle
>>> interval
>>> (in most modern CPUs, at least), which is about as accurate as you can
>>> possibly get, but I don't know if there are eg. some system functions that
>>> will return elapsed clock cycles converted into the equivalent amount of
>>> microseconds.
>>
>> Get time at the microseconds resolution.   My calculation engine
>> creates a bunch of temporary files and I use the time to create unique
>> names for those temporary files.  Seconds should be good enough for
>> uniqueness but I like adding microseconds as a guarantee.  Something
>> like
>>     uniquac1.out.009.20181972.20220912
> 
> An alternative is to keep a counter, incremented for each generated file
> name, and append it to the file name, perhaps resetting to 0 when the
> seconds count advances.  If your only requirement is uniqueness, that
> should be good enough.
> 
> Digression: I remember an implementation of gettimeofday() that did
> something like that (on SunOS, maybe?).  The system clock had a
> resolution of 0.01 second, so the value of tv_usec on successive calls
> might be:
>      420000
>      420001
>      420002
>      430000
>      430001
>      430002
>      ...
> I don't remember whether the implicit counter was per-process or
> system-wide.

The problem is multiple instances of the same program creating the same 
name files.

Lynn

[toc] | [prev] | [next] | [standalone]

#168137

On 11/4/2022 3:35 PM, Lynn McGuire wrote:
> On 11/4/2022 5:05 PM, Keith Thompson wrote:
>> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>>> On 11/4/2022 2:35 AM, Juha Nieminen wrote:
>>>> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>>>>> What is the best way to get microseconds of time on Windows in C or 
>>>>> C++
>>>> It's a bit unclear whether you mean "time in microseconds units" or
>>>> "time
>>>> at the microseconds resolution".
>>>> Because the latter may not be even possible (portable or not). Just
>>>> because
>>>> some time function returns time "in microseconds" that doesn't mean 
>>>> that it
>>>> uses microsecond resolution (in other words, the value it returns 
>>>> may well
>>>> change at longer intervals than every microsecond; probably 
>>>> *significantly*
>>>> longer intervals).
>>>> It is possible to get some kind of timing at the CPU clock cycle
>>>> interval
>>>> (in most modern CPUs, at least), which is about as accurate as you can
>>>> possibly get, but I don't know if there are eg. some system 
>>>> functions that
>>>> will return elapsed clock cycles converted into the equivalent 
>>>> amount of
>>>> microseconds.
>>>
>>> Get time at the microseconds resolution.   My calculation engine
>>> creates a bunch of temporary files and I use the time to create unique
>>> names for those temporary files.  Seconds should be good enough for
>>> uniqueness but I like adding microseconds as a guarantee.  Something
>>> like
>>>     uniquac1.out.009.20181972.20220912
>>
>> An alternative is to keep a counter, incremented for each generated file
>> name, and append it to the file name, perhaps resetting to 0 when the
>> seconds count advances.  If your only requirement is uniqueness, that
>> should be good enough.
>>
>> Digression: I remember an implementation of gettimeofday() that did
>> something like that (on SunOS, maybe?).  The system clock had a
>> resolution of 0.01 second, so the value of tv_usec on successive calls
>> might be:
>>      420000
>>      420001
>>      420002
>>      430000
>>      430001
>>      430002
>>      ...
>> I don't remember whether the implicit counter was per-process or
>> system-wide.
> 
> The problem is multiple instances of the same program creating the same 
> name files.

Prepend the file names with the PID? Something to make it unique. 
Perhaps a SHA2-HMAC or something.

[toc] | [prev] | [next] | [standalone]

#168138

Lynn McGuire <lynnmcguire5@gmail.com> writes:
> On 11/4/2022 5:05 PM, Keith Thompson wrote:
>> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>>> On 11/4/2022 2:35 AM, Juha Nieminen wrote:
>>>> In comp.lang.c++ Lynn McGuire <lynnmcguire5@gmail.com> wrote:
>>>>> What is the best way to get microseconds of time on Windows in C or C++
>>>> It's a bit unclear whether you mean "time in microseconds units" or
>>>> "time
>>>> at the microseconds resolution".
>>>> Because the latter may not be even possible (portable or not). Just
>>>> because
>>>> some time function returns time "in microseconds" that doesn't mean that it
>>>> uses microsecond resolution (in other words, the value it returns may well
>>>> change at longer intervals than every microsecond; probably *significantly*
>>>> longer intervals).
>>>> It is possible to get some kind of timing at the CPU clock cycle
>>>> interval
>>>> (in most modern CPUs, at least), which is about as accurate as you can
>>>> possibly get, but I don't know if there are eg. some system functions that
>>>> will return elapsed clock cycles converted into the equivalent amount of
>>>> microseconds.
>>>
>>> Get time at the microseconds resolution.   My calculation engine
>>> creates a bunch of temporary files and I use the time to create unique
>>> names for those temporary files.  Seconds should be good enough for
>>> uniqueness but I like adding microseconds as a guarantee.  Something
>>> like
>>>     uniquac1.out.009.20181972.20220912
>> An alternative is to keep a counter, incremented for each generated
>> file
>> name, and append it to the file name, perhaps resetting to 0 when the
>> seconds count advances.  If your only requirement is uniqueness, that
>> should be good enough.
>> Digression: I remember an implementation of gettimeofday() that did
>> something like that (on SunOS, maybe?).  The system clock had a
>> resolution of 0.01 second, so the value of tv_usec on successive calls
>> might be:
>>      420000
>>      420001
>>      420002
>>      430000
>>      430001
>>      430002
>>      ...
>> I don't remember whether the implicit counter was per-process or
>> system-wide.
>
> The problem is multiple instances of the same program creating the
> same name files.

You could incorporate the process id into the file name.

There's no truly portable way to do that, but one solution for POSIX and
another for Windows is likely to be good enough.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for XCOM Labs
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]

#168125

Lynn McGuire <lynnmcguire5@gmail.com> writes:
>What is the best way to get microseconds of time on Windows in C or C++ 
>?  I am currently using the following code to get the current time:
>
>	std::time_t t = std::time (0);   // get time now
>	std::tm * now = std::localtime ( & t);
>	integer iyear = now -> tm_year + 1900;
>	integer imonth = now -> tm_mon + 1;
>	integer iday = now -> tm_mday;
>	integer ihour = now -> tm_hour;
>	integer imin = now -> tm_min;
>	integer isec = now -> tm_sec;
>	integer ihund = 0;
>
>Thanks,
>Lynn

First answer here:

https://stackoverflow.com/questions/10905892/equivalent-of-gettimeday-for-windows

[toc] | [prev] | [next] | [standalone]

#168130

On 11/4/2022 8:44 AM, Scott Lurndal wrote:
> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>> What is the best way to get microseconds of time on Windows in C or C++
>> ?  I am currently using the following code to get the current time:
>>
>> 	std::time_t t = std::time (0);   // get time now
>> 	std::tm * now = std::localtime ( & t);
>> 	integer iyear = now -> tm_year + 1900;
>> 	integer imonth = now -> tm_mon + 1;
>> 	integer iday = now -> tm_mday;
>> 	integer ihour = now -> tm_hour;
>> 	integer imin = now -> tm_min;
>> 	integer isec = now -> tm_sec;
>> 	integer ihund = 0;
>>
>> Thanks,
>> Lynn
> 
> First answer here:
> 
> https://stackoverflow.com/questions/10905892/equivalent-of-gettimeday-for-windows

Thanks !

Lynn

[toc] | [prev] | [next] | [standalone]

#168191

On 11/4/2022 8:44 AM, Scott Lurndal wrote:
> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>> What is the best way to get microseconds of time on Windows in C or C++
>> ?  I am currently using the following code to get the current time:
>>
>> 	std::time_t t = std::time (0);   // get time now
>> 	std::tm * now = std::localtime ( & t);
>> 	integer iyear = now -> tm_year + 1900;
>> 	integer imonth = now -> tm_mon + 1;
>> 	integer iday = now -> tm_mday;
>> 	integer ihour = now -> tm_hour;
>> 	integer imin = now -> tm_min;
>> 	integer isec = now -> tm_sec;
>> 	integer ihund = 0;
>>
>> Thanks,
>> Lynn
> 
> First answer here:
> 
> https://stackoverflow.com/questions/10905892/equivalent-of-gettimeday-for-windows

"Nowadys I would use the following for gettimeofday() on Windows, which 
is using GetSystemTimePreciseAsFileTime() if compiled for Windows 8 or 
higher and GetSystemTimeAsFileTime() otherwise:"

I used the gettimeofday function.  Works well !

Thanks,
Lynn

[toc] | [prev] | [next] | [standalone]

#168192

Lynn McGuire <lynnmcguire5@gmail.com> writes:
> On 11/4/2022 8:44 AM, Scott Lurndal wrote:
>> Lynn McGuire <lynnmcguire5@gmail.com> writes:
>>> What is the best way to get microseconds of time on Windows in C or C++
>>> ?  I am currently using the following code to get the current time:
>>>
>>> 	std::time_t t = std::time (0);   // get time now
>>> 	std::tm * now = std::localtime ( & t);
>>> 	integer iyear = now -> tm_year + 1900;
>>> 	integer imonth = now -> tm_mon + 1;
>>> 	integer iday = now -> tm_mday;
>>> 	integer ihour = now -> tm_hour;
>>> 	integer imin = now -> tm_min;
>>> 	integer isec = now -> tm_sec;
>>> 	integer ihund = 0;
>>>
>>> Thanks,
>>> Lynn
>> First answer here:
>> https://stackoverflow.com/questions/10905892/equivalent-of-gettimeday-for-windows
>
> "Nowadys I would use the following for gettimeofday() on Windows,
> which is using GetSystemTimePreciseAsFileTime() if compiled for
> Windows 8 or higher and GetSystemTimeAsFileTime() otherwise:"
>
> I used the gettimeofday function.  Works well !

Be aware that POSIX says gettimeofday() is obsolescent, and recommends
clock_gettime() instead.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for XCOM Labs
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.lang.c

csiph-web