timing.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_BASE_ARCH_TIMING_H
#define PXR_BASE_ARCH_TIMING_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/arch/api.h"
#include "pxr/base/arch/defines.h"
#include "pxr/base/arch/inttypes.h"
 
 
// See if we should use the x86 TSC register for timing.
#if defined(PXR_ARCH_PREFER_TSC_TIMING) &&                              \
    defined(ARCH_OS_LINUX) &&                                           \
    defined(ARCH_CPU_INTEL) &&                                          \
    (defined(ARCH_COMPILER_CLANG) || defined(ARCH_COMPILER_GCC))
#define ARCH_USE_TSC_TIMING 1
#else
#define ARCH_USE_TSC_TIMING 0
#endif
 
#if ARCH_USE_TSC_TIMING
#include <x86intrin.h>
#endif
 
#include <atomic>
#include <chrono>
#include <cmath>
 
// XXX: None of <algorithm>, <iterator>, nor <numeric> are used by the timing
// routines, but the includes have been here forever and removing them causes
// other code that is not including all the headers it needs to fail to compile.
// These should be deprecated and removed.
#include <algorithm>
#include <iterator>
#include <numeric>
 
PXR_NAMESPACE_OPEN_SCOPE
 
// Use a std::chrono clock if we're not using the Intel RDTSC instruction
#if !ARCH_USE_TSC_TIMING
using Arch_TimingClock = std::chrono::steady_clock;
#endif
 
inline uint64_t
ArchGetTickTime()
{
#if ARCH_USE_TSC_TIMING
    return __rdtsc();
#else
    return Arch_TimingClock::now().time_since_epoch().count();
#endif
}
 
 
inline uint64_t
ArchGetStartTickTime()
{
    uint64_t t;
 
#if ARCH_USE_TSC_TIMING
 
    // Prevent reorders by the compiler.
    std::atomic_signal_fence(std::memory_order_seq_cst);
    asm volatile(
        "lfence\n\t"
        "rdtsc\n\t"
        "shl $32, %%rdx\n\t"
        "or %%rdx, %0\n\t"
        "lfence"
        : "=a"(t)
        :
        // rdtsc writes rdx
        // shl modifies cc flags
        : "rdx", "cc");
 
#else
 
    std::atomic_signal_fence(std::memory_order_seq_cst);
    t = ArchGetTickTime();
    std::atomic_signal_fence(std::memory_order_seq_cst);
 
#endif
 
    return t;
}
 
inline uint64_t
ArchGetStopTickTime()
{
    uint64_t t;
 
#if ARCH_USE_TSC_TIMING
 
    // Prevent reorders by the compiler.
    std::atomic_signal_fence(std::memory_order_seq_cst);
    asm volatile(
        "rdtscp\n\t"
        "shl $32, %%rdx\n\t"
        "or %%rdx, %0\n\t"
        "lfence"
        : "=a"(t)
        :
        // rdtscp writes rcx & rdx
        // shl modifies cc flags
        : "rcx", "rdx", "cc");
 
#else
 
    std::atomic_signal_fence(std::memory_order_seq_cst);
    t = ArchGetTickTime();
    std::atomic_signal_fence(std::memory_order_seq_cst);
 
#endif
 
    return t;
}
 
struct ArchIntervalTimer
{
    explicit ArchIntervalTimer(bool start=true)
        : _started(start) {
        if (_started) {
            _startTicks = ArchGetStartTickTime();
        }
    }
 
    void Start() {
        _started = true;
        _startTicks = ArchGetStartTickTime();
    }
 
    bool IsStarted() const {
        return _started;
    }
 
    uint64_t GetStartTicks() const {
        return _startTicks;
    }
 
    uint64_t GetCurrentTicks() {
        return ArchGetStopTickTime();
    }
 
    uint64_t GetElapsedTicks() {
        if (!_started) {
            return 0;
        }
        return ArchGetStopTickTime() - _startTicks;
    }
private:
    bool _started = false;
    uint64_t _startTicks;
};
 
ARCH_API
uint64_t ArchGetTickQuantum();
 
ARCH_API
uint64_t ArchGetIntervalTimerTickOverhead();
 
    
#if defined(doxygen) || ARCH_USE_TSC_TIMING
ARCH_API
double ArchGetNanosecondsPerTick();
#else
inline double ArchGetNanosecondsPerTick()
{
    return 1e+9 * Arch_TimingClock::period::num / Arch_TimingClock::period::den;
}
#endif
#if defined(doxygen) || ARCH_USE_TSC_TIMING
ARCH_API
int64_t ArchTicksToNanoseconds(uint64_t nTicks);
#else
inline int64_t ArchTicksToNanoseconds(uint64_t nTicks)
{
    return static_cast<int64_t>(
        std::llround(nTicks * ArchGetNanosecondsPerTick()));
}
#endif
 
#if defined(doxygen) || ARCH_USE_TSC_TIMING
ARCH_API
double ArchTicksToSeconds(uint64_t nTicks);
#else
inline double ArchTicksToSeconds(uint64_t nTicks)
{
    return nTicks * ArchGetNanosecondsPerTick() / 1e+9;
}
#endif
 
#if defined(doxygen) || ARCH_USE_TSC_TIMING
ARCH_API
uint64_t ArchSecondsToTicks(double seconds);
#else
inline uint64_t ArchSecondsToTicks(double seconds)
{
    return seconds * 1e+9 / ArchGetNanosecondsPerTick();
}
#endif
 
ARCH_API
uint64_t
Arch_MeasureExecutionTime(uint64_t maxTicks, bool *reachedConsensus,
                          void const *m, uint64_t (*callM)(void const *, int));
 
template <class Fn>
uint64_t
ArchMeasureExecutionTime(
    Fn const &fn,
    uint64_t maxTicks = 1e7,
    bool *reachedConsensus = nullptr)
{
    auto measureN = [&fn](int nTimes) -> uint64_t {
        ArchIntervalTimer iTimer;
        for (int i = nTimes; i--; ) {
            std::atomic_signal_fence(std::memory_order_seq_cst);
            (void)fn();
            std::atomic_signal_fence(std::memory_order_seq_cst);
        }
        return iTimer.GetElapsedTicks();
    };
 
    using MeasureNType = decltype(measureN);
    
    return Arch_MeasureExecutionTime(
        maxTicks, reachedConsensus,
        static_cast<void const *>(&measureN),
        [](void const *mN, int nTimes) {
            return (*static_cast<MeasureNType const *>(mN))(nTimes);
        });
}
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_ARCH_TIMING_H