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

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));

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

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

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

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.

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

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 */

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

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

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

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

Am 04.11.2022 um 02:14 schrieb Lynn McGuire:
> 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

Use GetSystemTimeAsFileTime() and FileTimeToLocalFileTime() on
Windows or the time_t-capable Functions on Unix and this class:

Header:

#pragma once
#if defined(_MSC_VER)
#define NOMINMAX
#include <Windows.h>
#endif
#include <cstdint>
#include <compare>
#include <ctime>
#include <stdexcept>
#include <compare>
#include <memory>
#include <mutex>
#include <algorithm>
#include <vector>
#include <functional>
#include <atomic>

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable: 26812) // prefer enum class over enum
#pragma warning(disable: 26495) // members not intitialized
#endif

struct st_timestamp
{ constexpr st_timestamp() = default;
st_timestamp( st_timestamp const & ) = default;
constexpr st_timestamp( std::uint64_t timestamp ) noexcept;
constexpr operator std::uint64_t() const noexcept;
constexpr explicit operator std::int64_t() const noexcept;
constexpr explicit operator bool() const noexcept;
constexpr st_timestamp &operator =( st_timestamp const & ) = default;
constexpr st_timestamp &operator =( std::uint64_t timestamp ) noexcept;
private:
std::uint64_t m_timestamp;
};

struct system_time
{ std::uint16_t year;
std::uint8_t weekday, month, day;
std::uint8_t hour, minute, second;
std::uint32_t ns100;
enum reason_t : uint8_t
{
TIMESTAMP_BEYOND_63_BIT = 1,
YEAR_OUT_OF_RANGE,
MONTH_OUT_OF_RANGE,
DAY_OUT_OF_RANGE,
HOUR_OUT_OF_RANGE,
MINUTE_OUT_OF_RANGE,
SECOND_OUT_OF_RANGE,
NS100_OUT_OF_RANGE,
TIMESTAMP_BEFORE_TIME_T,
WRONG_LEAP_SECOND
};
struct leap_second_t
{
std::uint16_t year;
bool jun30, dec31;
};
struct date_error : public std::invalid_argument
{
reason_t reason();
date_error() = delete;
date_error( date_error const & ) = delete;
private:
friend struct system_time;
date_error( reason_t reason );
reason_t m_reason;
};
system_time() {}
system_time( system_time const & ) = default;
system_time( std::uint16_t year, std::uint8_t month, std::uint8_t day,
std::uint8_t hour, std::uint8_t minute, std::uint8_t second,
std::uint32_t ns100 );
explicit system_time( st_timestamp ts );
system_time( struct tm const &tm );
#if defined(_MSC_VER)
system_time( SYSTEMTIME const &st );
#endif
operator st_timestamp() const;
st_timestamp to_timestamp( reason_t *reason = nullptr ) const noexcept;
system_time &operator =( st_timestamp ts );
void from_timestamp( st_timestamp ts, reason_t *reason = nullptr )
noexcept;
system_time &operator =( system_time const & ) = default;
operator tm() const;
struct tm to_tm( reason_t *reason ) const noexcept;
system_time &operator =( struct tm const &tm );
bool from_tm( struct tm const &tm, reason_t *reason ) noexcept;
#if defined(_MSC_VER)
operator SYSTEMTIME() const;
SYSTEMTIME to_systemtime( reason_t *reason ) const noexcept;
system_time &operator =( SYSTEMTIME const &st );
bool from_systemtime( SYSTEMTIME const &st, reason_t *reason ) noexcept;
#endif
bool adjust_weekday( reason_t *reason = nullptr ) noexcept;
static std::uint8_t get_weekday( st_timestamp timestamp ) noexcept;
static_assert(sizeof(time_t) == 8, "time_t must be 64 bit");
static time_t timestamp_to_time_t( st_timestamp ts, reason_t *reason =
nullptr ) noexcept;
static st_timestamp time_t_to_timestamp( time_t time, reason_t *reason
= nullptr ) noexcept;
static void leap_seconds( std::function<leap_second_t ( bool )> const
&fn );
private:
friend struct st_timestamp;
static std::atomic<std::shared_ptr<std::vector<leap_second_t>>>
g_leapSeconds;
static constexpr std::uint64_t
MILLISECOND = 10'000,
SECOND = 1'000 * MILLISECOND,
MINUTE = 60 * SECOND,
HOUR = 60 * MINUTE,
DAY = 24 * HOUR,
WEEK = 7 * DAY,
NON_LEAP_YEAR = 365 * DAY,
LEAP_YEAR = 366 * DAY,
FOUR_YEARS_W_LJ = LEAP_YEAR + 3 * NON_LEAP_YEAR,
FOUR_YEARS_WO_LJ = 4 * NON_LEAP_YEAR,
FIRST_QUARTER_CENTURY = 25 * FOUR_YEARS_W_LJ,
REMAINING_QUARTER_CENUTRIES = 25 * FOUR_YEARS_W_LJ - DAY,
FOUR_HUNDRED_YEARS = FIRST_QUARTER_CENTURY + 3 *
REMAINING_QUARTER_CENUTRIES,
TIME_T_IN_TIMESTAMP_BEGIN = 0x19DB1DED53E800,
LAST_TIMESTAMP_IN_TIME_T = 0xD69433CCD5,
LEAP_SECOND_BIT = std::numeric_limits<int64_t>::min();
};

constexpr st_timestamp::st_timestamp( std::uint64_t timestamp ) noexcept :
m_timestamp( timestamp )
{ }

constexpr st_timestamp::operator std::uint64_t() const noexcept
{ return m_timestamp & ~system_time::LEAP_SECOND_BIT;
}

constexpr st_timestamp::operator std::int64_t() const noexcept
{ return m_timestamp;
}

constexpr st_timestamp::operator bool() const noexcept
{ return m_timestamp & system_time::LEAP_SECOND_BIT;
}

constexpr st_timestamp &st_timestamp::operator =( std::uint64_t
timestamp ) noexcept
{ m_timestamp = timestamp;
return *this;
}

// may throw invalid_argument

inline system_time::system_time( st_timestamp ts )
{ *this = ts;
}

// may throw invalid_argument

inline system_time &system_time::operator =( st_timestamp ts )
{ reason_t reason;
from_timestamp( ts, &reason );
if( reason ) [[likely]]
throw date_error( reason );
return *this;
}

inline system_time::system_time( struct tm const &tm )
{ *this = tm;
}

#if defined(_MSC_VER)
inline system_time::system_time( SYSTEMTIME const &st )
{ *this = st;
} #endif

inline typename system_time::reason_t system_time::date_error::reason()
{ return m_reason;
}

inline uint8_t system_time::get_weekday( st_timestamp ts ) noexcept
{ using namespace std;
return (uint32_t)(((uint64_t)ts - (uint64_t)ts / WEEK * WEEK) / DAY +
1) % 7;
}

// may throw date_error

inline std::strong_ordering operator <=>( system_time const &left,
system_time const &right )
{ return (std::uint64_t)(st_timestamp)left <=> (uint64_t)(st_timestamp)right;
}

// may throw date_error

inline std::strong_ordering operator <=>( system_time const &left,
st_timestamp right )
{ return (std::uint64_t)(st_timestamp)left <=> (std::uint64_t)right;
}

// may throw date_error

inline std::strong_ordering operator <=>( st_timestamp left, system_time
const &right )
{ return (std::uint64_t)left <=> (std::uint64_t)(st_timestamp)left;
}

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

// .cpp:

#include <stdexcept>
#include <cassert>
#include <limits>
#include <algorithm>
#include <array>
#include <system_error>
#include <functional>
#if defined(__cpp_lib_hardware_interference_size)
#include <new>
#endif
#include "system_time.h"

using namespace std;

#if defined(__cpp_lib_hardware_interference_size)
constexpr size_t CL_SIZE = std::hardware_destructive_interference_size;
#else
constexpr size_t CL_SIZE = 64;
#endif

constexpr bool SYSTEM_TIME_BINARY_SEARCH = false;

// may throw date_error

system_time::system_time( std::uint16_t year, std::uint8_t month,
std::uint8_t day, std::uint8_t hour, std::uint8_t minute, std::uint8_t
second, std::uint32_t ns100 )
{ this->year = year;
this->month = month;
this->day = day;
this->hour = hour;
this->minute = minute;
this->second = second;
this->ns100 = ns100;
this->weekday = get_weekday( (st_timestamp)*this );
}

// may throw date_error

void system_time::from_timestamp( st_timestamp ts, reason_t *reason )
noexcept
{ auto reasonableErr = [&]( reason_t retReason ) -> void
{
if( reason ) [[likely]]
*reason = retReason;
memset( this, 0, sizeof *this );
};
uint64_t tsCalc = (uint64_t)ts;
bool leapSecond = (bool)ts;
weekday = get_weekday( ts );
tsCalc += LEAP_YEAR; // 1601 - 1600 = leap year
uint16_t y400, y100, y4, y;
y400 = (uint16_t)(tsCalc / FOUR_HUNDRED_YEARS);
tsCalc -= y400 * FOUR_HUNDRED_YEARS;
bool isLeapYear;
auto leapQuad = [&]()
{
if( tsCalc >= LEAP_YEAR ) [[likely]]
// y >= 1
tsCalc -= LEAP_YEAR,
y = (uint16_t)(1 + tsCalc / NON_LEAP_YEAR), // 1 ... 3
tsCalc -= tsCalc / NON_LEAP_YEAR * NON_LEAP_YEAR,
isLeapYear = false;
else
// y == 0
y = 0,
isLeapYear = true;
};
if( tsCalc >= FIRST_QUARTER_CENTURY ) [[likely]]
{
// (y % 400) >= 100
y100 = (uint16_t)(1 + (tsCalc - FIRST_QUARTER_CENTURY) /
REMAINING_QUARTER_CENUTRIES); // 1 ... 3
tsCalc -= FIRST_QUARTER_CENTURY + (tsCalc - FIRST_QUARTER_CENTURY) /
REMAINING_QUARTER_CENUTRIES * REMAINING_QUARTER_CENUTRIES;
if( tsCalc >= FOUR_YEARS_WO_LJ ) [[likely]]
// (y % 400) >= 100 && (y % 100) >= 4
y4 = (uint16_t)(1 + (tsCalc - FOUR_YEARS_WO_LJ) / FOUR_YEARS_W_LJ),
// 1 ... 24
tsCalc -= FOUR_YEARS_WO_LJ + (tsCalc - FOUR_YEARS_WO_LJ) /
FOUR_YEARS_W_LJ * FOUR_YEARS_W_LJ,
leapQuad();
else
// (y % 400) >= 100 && (y % 100) < 4
y4 = 0,
y = (uint16_t)(tsCalc / NON_LEAP_YEAR),
tsCalc -= tsCalc / NON_LEAP_YEAR * NON_LEAP_YEAR,
isLeapYear = false;
}
else
// (y % 400) < 100
y100 = 0,
y4 = (uint16_t)(tsCalc / FOUR_YEARS_W_LJ),
tsCalc -= tsCalc / FOUR_YEARS_W_LJ * FOUR_YEARS_W_LJ,
leapQuad();
year = 1600 + 400 * y400 + 100 * y100 + 4 * y4 + y;
{
static uint64_t const monthOffsets[2][12 + 1] alignas(CL_SIZE) =
{
{ 0 * DAY, 31 * DAY, 59 * DAY, 90 * DAY, 120 * DAY, 151 * DAY, 181 *
DAY, 212 * DAY, 243 * DAY, 273 * DAY, 304 * DAY, 334 * DAY, 999 * DAY },
{ 0 * DAY, 31 * DAY, 60 * DAY, 91 * DAY, 121 * DAY, 152 * DAY, 182 *
DAY, 213 * DAY, 244 * DAY, 274 * DAY, 305 * DAY, 335 * DAY, 999 * DAY }
};
uint64_t const *pMonthOffsets = monthOffsets[isLeapYear];
size_t moHit;
if constexpr( !SYSTEM_TIME_BINARY_SEARCH )
for( moHit = 0; tsCalc >= pMonthOffsets[moHit + 1]; ++moHit );
else
{
size_t lower = 0, upper = 12, mid;
moHit = -1;
do
{
mid = (lower + upper) / 2;
if( pMonthOffsets[mid] <= tsCalc )
moHit = mid,
lower = mid + 1;
else
upper = mid;
} while( lower != upper );
assert( moHit != -1 );
}
uint64_t mo = pMonthOffsets[moHit];
uint8_t dy = (uint8_t)((tsCalc - mo) / DAY);
tsCalc -= mo + dy * DAY;
month = 1 + (uint8_t)moHit;
day = 1 + dy;
}
hour = (uint8_t)(tsCalc / HOUR);
tsCalc %= HOUR;
minute = (uint8_t)(tsCalc / MINUTE);
tsCalc %= MINUTE;
second = (uint8_t)(tsCalc / SECOND);
if( leapSecond ) [[unlikely]]
{
if( second != 59 || minute != 59 || hour != 23 || (month != 6 || day
!= 30) && (month != 12 || day != 31) ) [[unlikely]]
return reasonableErr( WRONG_LEAP_SECOND );
shared_ptr leapSeconds( g_leapSeconds.load( memory_order_relaxed ) );
size_t lower = 0, upper = leapSeconds->size();
for( ; ; )
{
size_t mid = (lower + upper) / 2;
leap_second_t const &ls = (*leapSeconds)[mid];
if( ls.year == year ) [[unlikely]]
if( month == 6 && ls.jun30 || month == 12 && ls.dec31 ) [[likely]]
{
++second;
break;
}
else
return reasonableErr( WRONG_LEAP_SECOND );
bool midIsLower = ls.year < year;
(midIsLower ? lower : upper) = mid + midIsLower;
if( lower == upper ) [[unlikely]]
return reasonableErr( WRONG_LEAP_SECOND );
}
}
tsCalc %= SECOND;
ns100 = (uint32_t)tsCalc;
}

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.

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

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 */

On 04/11/2022 19:49, Bonita Montero wrote:

> #pragma once
....

Did you write 800 lines of code just for this task?

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

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.

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 */

Am 04.11.2022 um 23:31 schrieb Bart:
> On 04/11/2022 19:49, Bonita Montero wrote:
>
>> #pragma once
> ...
>
>
> Did you write 800 lines of code just for this task?

Dou you think you could get that easier ?

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.

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

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 */

On 11/14/2022 7:36 PM, Keith Thompson wrote:
> 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.

This works fine for me:

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

struct timezone {
int tz_minuteswest;
int tz_dsttime;
};

int mygettimeofday (struct timeval *tv, struct timezone *tz)
{ if (tv) {
FILETIME filetime; /* 64-bit value representing the
number of 100-nanosecond intervals since January 1, 1601 00:00 UTC */
ULARGE_INTEGER x;
ULONGLONG usec;
static const ULONGLONG epoch_offset_us = 11644473600000000ULL; /*
microseconds betweeen Jan 1,1601 and Jan 1,1970 */

#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
GetSystemTimePreciseAsFileTime ( & filetime);
#else
GetSystemTimeAsFileTime ( & filetime);
#endif
x.LowPart = filetime.dwLowDateTime;
x.HighPart = filetime.dwHighDateTime;
usec = x.QuadPart / 10 - epoch_offset_us;
tv->tv_sec = (time_t) (usec / 1000000ULL);
tv->tv_usec = (long) (usec % 1000000ULL);
}
if (tz) {
TIME_ZONE_INFORMATION timezone;
GetTimeZoneInformation(&timezone);
tz->tz_minuteswest = timezone.Bias;
tz->tz_dsttime = 0;
}
return 0;
}

Thanks,
Lynn

Am 16.11.2022 um 00:26 schrieb Lynn McGuire:
> This works fine for me:
>
>     //  from:
>     //
> https://stackoverflow.com/questions/10905892/equivalent-of-gettimeday-for-windows
>
> struct timezone {
>     int tz_minuteswest;
>     int tz_dsttime;
> };
>
> int mygettimeofday (struct timeval *tv, struct timezone *tz)
> {
>     if (tv) {
>         FILETIME               filetime; /* 64-bit value representing
> the number of 100-nanosecond intervals since January 1, 1601 00:00 UTC */
>         ULARGE_INTEGER         x;
>         ULONGLONG              usec;
>         static const ULONGLONG epoch_offset_us = 11644473600000000ULL;
Wrong value. Correct value is 116444736000000000ULL (9 trailing zeros).

Rough estimation (1970-1601)*365*24*60*60 = 11'636'784'000 seconds
(ignoring Feb 29 in leap years). Additional 6 zeros to convert seconds
to microseconds.

> /* microseconds betweeen Jan 1,1601 and Jan 1,1970 */
>
> #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
>         GetSystemTimePreciseAsFileTime ( & filetime);
> #else
>         GetSystemTimeAsFileTime ( & filetime);
> #endif
>         x.LowPart =  filetime.dwLowDateTime;
>         x.HighPart = filetime.dwHighDateTime;
>         usec = x.QuadPart / 10  -  epoch_offset_us;
>         tv->tv_sec  = (time_t) (usec / 1000000ULL);
>         tv->tv_usec = (long) (usec % 1000000ULL);
>     }
>     if (tz) {
>         TIME_ZONE_INFORMATION timezone;
>         GetTimeZoneInformation(&timezone);
>         tz->tz_minuteswest = timezone.Bias;
>         tz->tz_dsttime = 0;
>     }
>     return 0;
> }
>
> Thanks,
> Lynn
>