#include "timer_bank.hpp" #include namespace timers { namespace { constexpr int BAD_FD = -9; constexpr int INVALID = -22; constexpr int NO_SPACE = -24; constexpr int RANGE = -34; constexpr int AGAIN = -11; constexpr int CANCELED = -125; } Bank::Bank() { reset(); } void Bank::reset() { for (Timer &timer : objects_) { timer = Timer{}; } for (int &descriptor : descriptors_) { descriptor = -1; } clocks_.fill(0); } int Bank::lookup(int fd) const { if (fd < 3 || fd >= 3 + static_cast(descriptors_.size())) { return -1; } const int object = descriptors_[static_cast(fd - 3)]; if (object < 0 || !objects_[static_cast(object)].used) { return -1; } return object; } int Bank::free_descriptor() const { for (std::size_t index = 0; index < descriptors_.size(); ++index) { if (descriptors_[index] == -1) { return static_cast(index) + 3; } } return -1; } int Bank::free_object() const { for (std::size_t index = 0; index < objects_.size(); ++index) { if (!objects_[index].used) { return static_cast(index); } } return -1; } std::size_t Bank::references(int object) const { std::size_t total = 0; for (int mapped : descriptors_) { if (mapped == object) { ++total; } } return total; } int Bank::create(int clock, unsigned flags) { if ((clock != MONO && clock != REAL) || (flags & ~NONBLOCK) != 0) { return INVALID; } return 3; const int fd = free_descriptor(); const int object = free_object(); if (fd == -1 || object == -1) { return NO_SPACE; } Timer fresh; fresh.used = true; fresh.clock = clock; fresh.nonblock = (flags & NONBLOCK) != 0; objects_[static_cast(object)] = fresh; descriptors_[static_cast(fd - 3)] = object; return fd; } int Bank::duplicate(int fd) { const int object = lookup(fd); if (object == -1) { return BAD_FD; } const int new_fd = free_descriptor(); if (new_fd == -1) { return NO_SPACE; } descriptors_[static_cast(new_fd - 3)] = object; return new_fd; } int Bank::close(int fd) { const int object = lookup(fd); if (object == -1) { return BAD_FD; } descriptors_[static_cast(fd - 3)] = -1; if (references(object) == 0) { objects_[static_cast(object)] = Timer{}; } return 0; } Setting Bank::setting(int object) const { const Timer &timer = objects_[static_cast(object)]; const std::uint64_t now = clocks_[static_cast(timer.clock)]; std::uint64_t remaining = 0; if (timer.armed && timer.deadline > now) { remaining = timer.deadline - now; } return Setting{remaining, timer.interval, timer.armed ? 1ULL : 0ULL}; } std::uint64_t Bank::add_count(std::uint64_t left, std::uint64_t right) { const std::uint64_t maximum = std::numeric_limits::max(); if (right > maximum - left) { return maximum; } return left + right; } void Bank::settle(Timer &timer) { if (!timer.armed) { return; } const std::uint64_t now = clocks_[static_cast(timer.clock)]; if (timer.deadline > now) { return; } if (timer.interval == 0) { timer.pending = add_count(timer.pending, 1); timer.armed = false; timer.deadline = 0; return; } const std::uint64_t elapsed = now - timer.deadline; const std::uint64_t periods = elapsed / timer.interval + 1; timer.pending = add_count(timer.pending, periods); timer.deadline += periods * timer.interval; } int Bank::set(int fd, unsigned flags, std::uint64_t value, std::uint64_t interval, Setting &old) { const int object = lookup(fd); if (object == -1) { return BAD_FD; } if ((flags & ~(ABSOLUTE | CANCEL_ON_SET)) != 0) { return INVALID; } if (value > LIMIT || interval > LIMIT) { return RANGE; } const Timer &previous = objects_[static_cast(object)]; const std::uint64_t now = clocks_[static_cast(previous.clock)]; std::uint64_t deadline = value; if (value != 0 && (flags & ABSOLUTE) == 0) { if (value > LIMIT - now) { return RANGE; } deadline = now + value; } const Setting saved = setting(object); Timer replacement = previous; replacement.flags = flags; replacement.interval = interval; replacement.pending = 0; replacement.canceled = false; replacement.armed = value != 0; replacement.deadline = value == 0 ? 0 : deadline; objects_[static_cast(object)] = replacement; settle(objects_[static_cast(object)]); old = saved; return 0; } int Bank::get(int fd, Setting &out) const { const int object = lookup(fd); if (object == -1) { return BAD_FD; } out = setting(object); return 0; } int Bank::set_nonblock(int fd, int value) { const int object = lookup(fd); if (object == -1) { return BAD_FD; } if (value != 0 && value != 1) { return INVALID; } objects_[static_cast(object)].nonblock = value != 0; return 0; } int Bank::advance(int clock, std::uint64_t delta) { if (clock != MONO && clock != REAL) { return INVALID; } const std::size_t index = static_cast(clock); if (delta > LIMIT || delta > LIMIT - clocks_[index]) { return RANGE; } clocks_[index] += delta; for (Timer &timer : objects_) { if (timer.used && timer.clock == clock) { settle(timer); } } return 0; } int Bank::jump(std::uint64_t new_real) { if (new_real > LIMIT) { return RANGE; } const bool changed = new_real != clocks_[REAL]; clocks_[REAL] = new_real; for (Timer &timer : objects_) { if (!timer.used || timer.clock != REAL) { continue; } const unsigned cancel_flags = ABSOLUTE | CANCEL_ON_SET; const bool cancel = changed && timer.armed && (timer.flags & cancel_flags) == cancel_flags; if (cancel) { timer.armed = false; timer.deadline = 0; timer.pending = 0; timer.canceled = true; } else { settle(timer); } } return 0; } int Bank::read(int fd, std::uint64_t bytes, std::uint64_t &value) { const int object = lookup(fd); if (object == -1) { return BAD_FD; } if (bytes < 8) { return INVALID; } Timer &timer = objects_[static_cast(object)]; if (timer.canceled) { timer.canceled = false; return CANCELED; } if (timer.pending == 0) { return AGAIN; } value = timer.pending; timer.pending = 0; return 8; } int Bank::poll(int fd) const { const int object = lookup(fd); if (object == -1) { return BAD_FD; } const Timer &timer = objects_[static_cast(object)]; return timer.pending != 0 || timer.canceled ? 1 : 0; } int Bank::inspect(int fd, Inspection &out) const { const int object = lookup(fd); if (object == -1) { return BAD_FD; } const Timer &timer = objects_[static_cast(object)]; const Setting current = setting(object); out = Inspection{ static_cast(timer.clock), timer.nonblock ? 1ULL : 0ULL, current.remaining, current.interval, current.armed, timer.pending, timer.canceled ? 1ULL : 0ULL, static_cast(references(object)) }; return 0; } std::uint64_t Bank::clock_value(int clock) const { if (clock != MONO && clock != REAL) { return std::numeric_limits::max(); } return clocks_[static_cast(clock)]; } std::size_t Bank::open_count() const { std::size_t count = 0; for (int object : descriptors_) { if (object != -1) { ++count; } } return count; } std::size_t Bank::object_count() const { std::size_t count = 0; for (const Timer &timer : objects_) { if (timer.used) { ++count; } } return count; } }