system_timer.hpp

Go to the documentation of this file.

/*
    Copyright 2015 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
 
#ifndef STLAB_CONCURRENCY_SYSTEM_TIMER_HPP
#define STLAB_CONCURRENCY_SYSTEM_TIMER_HPP

 
#include <stlab/concurrency/task.hpp>
#include <stlab/execution/config.hpp>
#include <stlab/pre_exit.hpp> // IWYU pragma: export
 
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <limits>
#include <new>
#include <stdexcept>
#include <system_error>
#include <type_traits>
 
namespace stlab {
inline namespace v2 {

struct stlab_v2_timer_status {
    std::int32_t code;
    std::int32_t native_error;
};
 
static_assert(std::is_standard_layout_v<stlab_v2_timer_status>);
static_assert(sizeof(stlab_v2_timer_status) == 2 * sizeof(std::int32_t));
static_assert(offsetof(stlab_v2_timer_status, native_error) == sizeof(std::int32_t));

using stlab_v2_task_proc = void (*)(void*) noexcept;

extern "C" stlab_v2_timer_status stlab_v2_system_timer_submit(const unsigned char* task_abi_guard,
                                                              const stlab_v2_task_concept* vtable,
                                                              stlab_v2_task_proc invoke,
                                                              void* source,
                                                              std::int64_t delay_ns) noexcept;
 
} // namespace v2
 
STLAB_EXECUTION_VERSION_NAMESPACE_BEGIN()
 

 
namespace execution_detail {

inline auto timer_integral_nanoseconds(std::uintmax_t count,
                                       std::uintmax_t numerator,
                                       std::uintmax_t denominator,
                                       std::uintmax_t multiplier = 1) -> std::int64_t {
    constexpr auto limit = static_cast<std::uintmax_t>(std::numeric_limits<std::int64_t>::max());
    std::uintmax_t quotient = 0;
    std::uintmax_t remainder = 0;
    if (count <= std::numeric_limits<std::uintmax_t>::max() / numerator) {
        const auto product = count * numerator;
        quotient = product / denominator;
        remainder = product % denominator;
    } else {
        // Long division avoids overflowing the intermediate product for fractional periods.
        const auto whole = numerator / denominator;
        const auto fraction = numerator % denominator;
        for (int bit = std::numeric_limits<std::uintmax_t>::digits - 1; bit >= 0; --bit) {
            if (quotient > limit / 2)
                throw std::overflow_error("system_timer delay exceeds signed nanoseconds");
            quotient *= 2;
            remainder *= 2; // The ratio denominator is at most INTMAX_MAX.
            auto carry = remainder / denominator;
            remainder %= denominator;
            if ((count >> bit) & 1) {
                if (whole > limit - carry)
                    throw std::overflow_error("system_timer delay exceeds signed nanoseconds");
                carry += whole;
                remainder += fraction;
                carry += remainder / denominator;
                remainder %= denominator;
            }
            if (carry > limit - quotient)
                throw std::overflow_error("system_timer delay exceeds signed nanoseconds");
            quotient += carry;
        }
    }
    if (quotient > limit / multiplier)
        throw std::overflow_error("system_timer delay exceeds signed nanoseconds");
    quotient *= multiplier;
    const auto rounded_fraction =
        multiplier == 1 ? static_cast<std::uintmax_t>(remainder != 0) :
                          static_cast<std::uintmax_t>(
                              timer_integral_nanoseconds(remainder, multiplier, denominator));
    if (rounded_fraction > limit - quotient)
        throw std::overflow_error("system_timer delay exceeds signed nanoseconds");
    return static_cast<std::int64_t>(quotient + rounded_fraction);
}

template <typename Rep, typename Period>
auto timer_nanoseconds(std::chrono::duration<Rep, Period> duration) -> std::int64_t {
    if constexpr (std::is_floating_point_v<Rep>) {
        if (!std::isfinite(duration.count()))
            throw std::invalid_argument("system_timer delay must be finite");
    }
    if (duration.count() <= 0) return 0;
    if constexpr (std::is_integral_v<Rep>) {
        return timer_integral_nanoseconds(static_cast<std::uintmax_t>(duration.count()),
                                          Period::num, Period::den, 1000000000);
    } else {
        const auto value =
            std::ceil(static_cast<long double>(duration.count()) *
                      static_cast<long double>(Period::num) / Period::den * 1000000000);
        // 2^63 is exactly representable even when long double has only double precision.
        const auto bound = -static_cast<long double>(std::numeric_limits<std::int64_t>::min());
        if (!std::isfinite(value) || value >= bound)
            throw std::overflow_error("system_timer delay exceeds signed nanoseconds");
        return value < 1 ? 1 : static_cast<std::int64_t>(value);
    }
}

inline void submit_system_timer(std::int64_t delay_ns, task<void() noexcept>& f) {
    const auto result =
        stlab_v2_system_timer_submit(&current_task_storage_abi_guard::value, f.relocation_concept(),
                                     f.relocation_invoke(), f.relocation_source(), delay_ns);
    switch (result.code) {
        case 0:
            return;
        case 1:
            throw std::bad_alloc();
        case 2:
            throw std::system_error(result.native_error, std::generic_category());
        case 3:
            throw std::system_error(result.native_error, std::system_category());
        default:
            assert(false && "invalid timer ABI resource status");
            std::terminate();
    }
}

struct system_timer_type {
    using result_type = void;

    void operator()(std::chrono::steady_clock::time_point when, task<void() noexcept>&& f) const {
        const auto now = std::chrono::steady_clock::now();
        if (when <= now) {
            submit_system_timer(0, f);
            return;
        }
        using duration = std::chrono::steady_clock::duration;
        using unsigned_rep = std::make_unsigned_t<typename duration::rep>;
        const auto remaining = static_cast<unsigned_rep>(when.time_since_epoch().count()) -
                               static_cast<unsigned_rep>(now.time_since_epoch().count());
        submit_system_timer(
            timer_nanoseconds(
                std::chrono::duration<unsigned_rep, typename duration::period>(remaining)),
            f);
    }

    template <typename Rep, typename Period>
    void operator()(std::chrono::duration<Rep, Period> duration, task<void() noexcept>&& f) const {
        submit_system_timer(timer_nanoseconds(duration), f);
    }
};
 
} // namespace execution_detail

inline constexpr auto system_timer = execution_detail::system_timer_type{};

 
STLAB_EXECUTION_VERSION_NAMESPACE_END()
} // namespace stlab
 
#endif