2020-09-17 23:02:40 +03:00
|
|
|
// Copyright (c) Vitaliy Filippov, 2019+
|
2021-02-06 01:26:07 +03:00
|
|
|
// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
|
2020-09-17 23:02:40 +03:00
|
|
|
|
2020-04-15 13:29:13 +03:00
|
|
|
#include <sys/timerfd.h>
|
|
|
|
#include <sys/poll.h>
|
2020-05-21 01:23:43 +03:00
|
|
|
#include <sys/epoll.h>
|
2020-04-15 13:29:13 +03:00
|
|
|
#include <unistd.h>
|
2020-05-21 01:23:43 +03:00
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
2020-10-06 02:35:11 +03:00
|
|
|
#include <string>
|
|
|
|
#include <stdexcept>
|
2020-04-15 13:29:13 +03:00
|
|
|
#include "timerfd_manager.h"
|
|
|
|
|
2020-06-23 20:18:04 +03:00
|
|
|
timerfd_manager_t::timerfd_manager_t(std::function<void(int, bool, std::function<void(int, int)>)> set_fd_handler)
|
2020-04-15 13:29:13 +03:00
|
|
|
{
|
2020-05-21 01:23:43 +03:00
|
|
|
this->set_fd_handler = set_fd_handler;
|
2020-04-15 13:29:13 +03:00
|
|
|
wait_state = 0;
|
|
|
|
timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
|
|
|
|
if (timerfd < 0)
|
|
|
|
{
|
|
|
|
throw std::runtime_error(std::string("timerfd_create: ") + strerror(errno));
|
|
|
|
}
|
2020-06-23 20:18:04 +03:00
|
|
|
set_fd_handler(timerfd, false, [this](int fd, int events)
|
2020-05-21 01:23:43 +03:00
|
|
|
{
|
|
|
|
handle_readable();
|
|
|
|
});
|
2020-04-15 13:29:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
timerfd_manager_t::~timerfd_manager_t()
|
|
|
|
{
|
2020-06-23 20:18:04 +03:00
|
|
|
set_fd_handler(timerfd, false, NULL);
|
2020-04-15 13:29:13 +03:00
|
|
|
close(timerfd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void timerfd_manager_t::inc_timer(timerfd_timer_t & t)
|
|
|
|
{
|
2021-03-28 22:06:43 +03:00
|
|
|
t.next.tv_sec += t.micros/1000000;
|
|
|
|
t.next.tv_nsec += (t.micros%1000000)*1000;
|
2020-04-15 13:29:13 +03:00
|
|
|
if (t.next.tv_nsec > 1000000000)
|
|
|
|
{
|
|
|
|
t.next.tv_sec++;
|
|
|
|
t.next.tv_nsec -= 1000000000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int timerfd_manager_t::set_timer(uint64_t millis, bool repeat, std::function<void(int)> callback)
|
2021-03-28 22:06:43 +03:00
|
|
|
{
|
|
|
|
return set_timer_us(millis*1000, repeat, callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
int timerfd_manager_t::set_timer_us(uint64_t micros, bool repeat, std::function<void(int)> callback)
|
2020-04-15 13:29:13 +03:00
|
|
|
{
|
2020-04-20 17:44:03 +03:00
|
|
|
int timer_id = id++;
|
2020-04-15 13:29:13 +03:00
|
|
|
timespec start;
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
|
|
timers.push_back({
|
2020-04-20 17:44:03 +03:00
|
|
|
.id = timer_id,
|
2021-03-28 22:06:43 +03:00
|
|
|
.micros = micros,
|
2020-04-15 13:29:13 +03:00
|
|
|
.start = start,
|
|
|
|
.next = start,
|
|
|
|
.repeat = repeat,
|
|
|
|
.callback = callback,
|
|
|
|
});
|
|
|
|
inc_timer(timers[timers.size()-1]);
|
|
|
|
set_nearest();
|
2020-04-20 17:44:03 +03:00
|
|
|
return timer_id;
|
2020-04-15 13:29:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void timerfd_manager_t::clear_timer(int timer_id)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < timers.size(); i++)
|
|
|
|
{
|
|
|
|
if (timers[i].id == timer_id)
|
|
|
|
{
|
|
|
|
timers.erase(timers.begin()+i, timers.begin()+i+1);
|
|
|
|
if (nearest == i)
|
|
|
|
{
|
|
|
|
nearest = -1;
|
|
|
|
wait_state = wait_state & ~1;
|
|
|
|
}
|
|
|
|
else if (nearest > i)
|
|
|
|
{
|
|
|
|
nearest--;
|
|
|
|
}
|
|
|
|
set_nearest();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void timerfd_manager_t::set_nearest()
|
|
|
|
{
|
2020-05-23 15:33:32 +03:00
|
|
|
again:
|
2020-04-15 13:29:13 +03:00
|
|
|
if (!timers.size())
|
|
|
|
{
|
|
|
|
nearest = -1;
|
2022-01-15 23:55:10 +03:00
|
|
|
itimerspec exp = {};
|
2020-04-15 13:29:13 +03:00
|
|
|
if (timerfd_settime(timerfd, 0, &exp, NULL))
|
|
|
|
{
|
|
|
|
throw std::runtime_error(std::string("timerfd_settime: ") + strerror(errno));
|
|
|
|
}
|
|
|
|
wait_state = wait_state & ~1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
nearest = 0;
|
|
|
|
for (int i = 1; i < timers.size(); i++)
|
|
|
|
{
|
|
|
|
if (timers[i].next.tv_sec < timers[nearest].next.tv_sec ||
|
|
|
|
timers[i].next.tv_sec == timers[nearest].next.tv_sec &&
|
|
|
|
timers[i].next.tv_nsec < timers[nearest].next.tv_nsec)
|
|
|
|
{
|
|
|
|
nearest = i;
|
|
|
|
}
|
|
|
|
}
|
2020-04-17 01:59:06 +03:00
|
|
|
timespec now;
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
2020-04-15 13:29:13 +03:00
|
|
|
itimerspec exp = {
|
|
|
|
.it_interval = { 0 },
|
|
|
|
.it_value = timers[nearest].next,
|
|
|
|
};
|
2020-04-17 01:59:06 +03:00
|
|
|
exp.it_value.tv_sec -= now.tv_sec;
|
|
|
|
exp.it_value.tv_nsec -= now.tv_nsec;
|
|
|
|
if (exp.it_value.tv_nsec < 0)
|
|
|
|
{
|
|
|
|
exp.it_value.tv_sec--;
|
|
|
|
exp.it_value.tv_nsec += 1000000000;
|
|
|
|
}
|
2021-04-06 01:57:23 +03:00
|
|
|
if (exp.it_value.tv_sec < 0 || exp.it_value.tv_sec == 0 && exp.it_value.tv_nsec <= 0)
|
2020-05-23 15:33:32 +03:00
|
|
|
{
|
|
|
|
// It already happened
|
2023-09-10 02:56:34 +03:00
|
|
|
// FIXME: Postpone to setImmediate/BH to avoid reenterability problems
|
2020-05-23 15:33:32 +03:00
|
|
|
trigger_nearest();
|
|
|
|
goto again;
|
|
|
|
}
|
2020-04-15 13:29:13 +03:00
|
|
|
if (timerfd_settime(timerfd, 0, &exp, NULL))
|
|
|
|
{
|
|
|
|
throw std::runtime_error(std::string("timerfd_settime: ") + strerror(errno));
|
|
|
|
}
|
|
|
|
wait_state = wait_state | 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-21 01:23:43 +03:00
|
|
|
void timerfd_manager_t::handle_readable()
|
2020-04-15 13:29:13 +03:00
|
|
|
{
|
2020-05-21 01:23:43 +03:00
|
|
|
uint64_t n;
|
|
|
|
size_t res = read(timerfd, &n, 8);
|
|
|
|
if (res == 8 && nearest >= 0)
|
2020-04-15 13:29:13 +03:00
|
|
|
{
|
2020-05-23 15:33:32 +03:00
|
|
|
trigger_nearest();
|
2020-04-15 13:29:13 +03:00
|
|
|
}
|
2020-05-21 01:23:43 +03:00
|
|
|
wait_state = 0;
|
|
|
|
set_nearest();
|
2020-04-15 13:29:13 +03:00
|
|
|
}
|
2020-05-23 15:33:32 +03:00
|
|
|
|
|
|
|
void timerfd_manager_t::trigger_nearest()
|
|
|
|
{
|
|
|
|
int nearest_id = timers[nearest].id;
|
|
|
|
auto cb = timers[nearest].callback;
|
|
|
|
if (timers[nearest].repeat)
|
|
|
|
{
|
|
|
|
inc_timer(timers[nearest]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
timers.erase(timers.begin()+nearest, timers.begin()+nearest+1);
|
|
|
|
}
|
|
|
|
nearest = -1;
|
2021-04-06 01:57:23 +03:00
|
|
|
cb(nearest_id);
|
2020-05-23 15:33:32 +03:00
|
|
|
}
|