blob: 52c86d3e812d498c5ca803c144909c3179b18249 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
#include "device_clock.hh"
#include "device_context.hh"
#include <vulkan/vulkan_core.h>
#include <cassert>
#include <time.h>
namespace low_latency {
DeviceClock::DeviceClock(const DeviceContext& context) : device(context) {
this->calibrate();
}
DeviceClock::~DeviceClock() {}
DeviceClock::time_point_t DeviceClock::now() {
auto ts = timespec{};
if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
throw errno;
}
return time_point_t{std::chrono::seconds{ts.tv_sec} +
std::chrono::nanoseconds{ts.tv_nsec}};
}
void DeviceClock::calibrate() {
const auto infos = std::vector<VkCalibratedTimestampInfoKHR>{
{VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, nullptr,
VK_TIME_DOMAIN_DEVICE_EXT},
{VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, nullptr,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT}};
struct CalibratedResult {
std::uint64_t device;
std::uint64_t host;
};
auto calibrated_result = CalibratedResult{};
THROW_NON_VKSUCCESS(device.vtable.GetCalibratedTimestampsKHR(
device.device, 2, std::data(infos), &calibrated_result.device,
&this->error_bound));
this->device_ticks = calibrated_result.device;
this->host_ns = calibrated_result.host;
}
DeviceClock::time_point_t
DeviceClock::ticks_to_time(const std::uint64_t& ticks) const {
const auto& pd = device.physical_device.properties;
const auto ns_tick = static_cast<double>(pd->limits.timestampPeriod);
const auto diff = [&]() -> auto {
auto a = this->device_ticks;
auto b = ticks;
const auto is_negative = a > b;
if (is_negative) {
std::swap(a, b);
}
const auto abs_diff = b - a;
assert(abs_diff <= std::numeric_limits<std::int64_t>::max());
const auto signed_abs_diff = static_cast<std::int64_t>(abs_diff);
return is_negative ? -signed_abs_diff : signed_abs_diff;
}();
const auto diff_nsec =
static_cast<std::int64_t>(static_cast<double>(diff) * ns_tick + 0.5);
const auto delta = std::chrono::nanoseconds(
this->host_ns + static_cast<std::uint64_t>(diff_nsec));
return time_point_t{delta};
}
} // namespace low_latency
|
