b2bits::HRClock Struct Reference

High-resolution monotonic clock. More...

Detailed Description

High-resolution monotonic clock.

Provides high-resolution time measurements using platform-specific performance counters. The clock is monotonic (never goes backwards) and provides much higher precision than std::chrono::system_clock.

Key characteristics:

• Monotonic: Time never decreases, even if system clock is adjusted
• High-precision: Typically nanosecond or microsecond resolution
• Efficient: Direct access to hardware performance counters
• Platform-optimized: Uses best available timer on each platform

The clock stores time as raw counter ticks. Use duration_cast() to convert to standard time units (seconds, milliseconds, nanoseconds, etc.).

Example:

// Measure operation latency
auto start = HRClock::now();
perform_operation();
auto latency_ns = HRClock::elapsed<std::chrono::nanoseconds>(start);
std::cout << "Latency: " << latency_ns.count() << " ns\n";
 
// Convert between time units
auto now = HRClock::now();
auto later = now + 1000000;  // Add 1ms worth of ticks
auto diff = later - now;
auto ms = HRClock::duration_cast<std::chrono::milliseconds>(diff);

#include <core/src/HRClock.h>

Public Types
using	TimePoint = uint64_t
	Time point type (raw counter ticks as 64-bit unsigned integer).
using	Duration = int64_t
	Duration type (signed 64-bit for differences and negative values).

Static Public Member Functions
static TimePoint	now () noexcept
	Get current time point.
static uint64_t	frequency () noexcept
	Get clock frequency (ticks per second).
template<class D>
static D	duration_cast (Duration d) noexcept
	Convert clock duration to std::chrono duration.
template<class D>
static Duration	duration_cast (const D d) noexcept
	Convert std::chrono duration to clock duration.
template<class D>
static D	elapsed (TimePoint t) noexcept
	Calculate elapsed time since a time point.

Member Typedef Documentation

Duration

using b2bits::HRClock::Duration = int64_t

Duration type (signed 64-bit for differences and negative values).

TimePoint

using b2bits::HRClock::TimePoint = uint64_t

Time point type (raw counter ticks as 64-bit unsigned integer).

Member Function Documentation

duration_cast() [1/2]

template<class D>

Duration b2bits::HRClock::duration_cast ( const D d )

inlinestaticnoexcept

Convert std::chrono duration to clock duration.

Converts a standard C++ duration type to raw clock ticks. This is the inverse operation of duration_cast(Duration).

Template Parameters

D	std::chrono::duration type (e.g., std::chrono::milliseconds)

Parameters

d	Duration in chrono type

Returns

Duration in clock ticks

Note

Rounds to nearest integer tick value

Thread-safe

Example:

using namespace std::chrono_literals;
 
auto ticks_1ms = HRClock::duration_cast(1ms);
auto ticks_1us = HRClock::duration_cast(1us);
auto ticks_1s = HRClock::duration_cast(1s);

References frequency().

duration_cast() [2/2]

template<class D>

D b2bits::HRClock::duration_cast ( Duration d )

inlinestaticnoexcept

Convert clock duration to std::chrono duration.

Converts a raw tick duration to a standard C++ duration type (e.g., std::chrono::milliseconds, std::chrono::nanoseconds).

Uses the clock frequency to perform accurate conversion with rounding.

Template Parameters

D	std::chrono::duration type (e.g., std::chrono::nanoseconds)

Parameters

d	Duration in clock ticks

Returns

Duration converted to specified chrono type

Note

Rounds to nearest integer value

Thread-safe

Example:

Duration ticks = 1000000;
auto ns = HRClock::duration_cast<std::chrono::nanoseconds>(ticks);
auto us = HRClock::duration_cast<std::chrono::microseconds>(ticks);
auto ms = HRClock::duration_cast<std::chrono::milliseconds>(ticks);

References duration_cast(), and frequency().

Referenced by duration_cast(), and elapsed().

elapsed()

template<class D>

D b2bits::HRClock::elapsed ( TimePoint t )

inlinestaticnoexcept

Calculate elapsed time since a time point.

Computes the elapsed time from a previous time point to now, returning the result in the specified duration type.

Equivalent to: duration_cast<D>(now() - t)

Template Parameters

D	std::chrono::duration type for result

Parameters

t	Previous time point to measure from

Returns

Elapsed time in specified duration type

Note

Thread-safe

Result is always non-negative (monotonic clock)

Example:

auto start = HRClock::now();
process_data();
 
// Get elapsed time in different units
auto ns = HRClock::elapsed<std::chrono::nanoseconds>(start);
auto us = HRClock::elapsed<std::chrono::microseconds>(start);
auto ms = HRClock::elapsed<std::chrono::milliseconds>(start);
 
std::cout << "Processing took: " << us.count() << " microseconds\n";

References duration_cast(), and now().

frequency()

uint64_t b2bits::HRClock::frequency ( )

staticnoexcept

Get clock frequency (ticks per second).

Returns the number of clock ticks per second. This is used to convert raw tick counts to standard time units.

Returns

Clock frequency in ticks per second (Hz)

Note

The frequency is constant for a given platform/CPU

Thread-safe

Example:

// Calculate seconds from ticks
Duration ticks = 1000000;
double seconds = ticks / double(HRClock::frequency());

References frequency().

Referenced by duration_cast(), duration_cast(), and frequency().

now()

TimePoint b2bits::HRClock::now ( )

staticnoexcept

Get current time point.

Returns the current value of the high-resolution performance counter. The value is in platform-specific ticks (not directly in seconds or nanoseconds).

Returns

Current time point as raw counter ticks

Note

Thread-safe

Monotonic: Later calls always return equal or greater values

Use duration_cast() to convert to standard time units

See also

frequency() for converting ticks to time units

Referenced by elapsed().

---

The documentation for this struct was generated from the following file:

• core/src/HRClock.h