Как лучше сделать низкоточные таймеры?

Eddy_Em

clock_nanosleep + TIMER_ABSTIME.

struct itimerval tval = {.it_value.tv_sec = 1};

А it_interval не пробовали настроить?

Да, я могу настроить чтобы иметь периоды и вручную не заводить таймер каждый раз, меня просто удручает ситуация что каждый раз сбрасывается signal handler и его нужно снова устанавливать. Мне кажется это неэффективным и нелогичным. Может есть с сигналами какое-то более адекватное решение?

Т.е. вы за варианты с тредами?

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/time.h>

void tmr(int sig){
  printf("Time!\n");
}

int main(){
  signal(SIGALRM, tmr);
  static struct itimerval tval = {.it_value.tv_sec = 1, .it_interval.tv_sec = 1};
  setitimer(ITIMER_REAL, &tval, NULL);
  
  for(int i=0; i<10; i++){
    usleep(10000000);
  }
}

Да вроде работает без переустановок

А можно и по методу конечного автомата:

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>

unsigned long get_time_ms(){
  struct timeval tv;
  unsigned long time_ms;
  gettimeofday(&tv,NULL);
  time_ms = tv.tv_usec/1000 + tv.tv_sec*1000;
  return time_ms;
}

void task_func(unsigned long cur_time, unsigned long interval){
  static unsigned long next_time = 0;
  if( cur_time >= next_time ){
    next_time = cur_time + interval;
    printf("Time!\n");
  }
}

int main(){
  for(int i=0; i<100; i++){
    usleep(100000);
    task_func( get_time_ms(), 1000 );
  }
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    struct timespec t, t_now;

    clock_gettime(CLOCK_MONOTONIC, &t);
    t.tv_sec += 1;
    t.tv_nsec = 0;

    for (int i = 0; i < 10; ++i) {
        while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &t, NULL) != 0) {
            if (errno == EINTR) continue;
            perror(NULL);
            return -1;
        }
        clock_gettime(CLOCK_MONOTONIC, &t_now);
        printf("%d %d.%09d\n", i, (int)t_now.tv_sec, (int)t_now.tv_nsec);
        t.tv_sec += 1;
    }

    return 0;
}

Если я правильно понял задачу.

Если у тебя хотя бы 2.6.25, то можно взять вот такую штуку:

https://man7.org/linux/man-pages/man2/timerfd_create.2.html

Самое сочное в ней то, что можно параллельно ждать таймер и делать что-то в фоне. И также асинхронно получить сразу несколько срабатываний таймера, если программа по каким-то причинам была занята.

PS: на самом деле я просто ненавижу сигналы, потому что это нагромождение костылей, которое помимо того, что сложное в использовании, так еще и обладает неизбежными ограничениями, которые еще больше усложняют использование. И в итоге от кодера требуется мастерство хождения на двух уровнях костылей.

Для сигналов, кстати, есть signalfd, чтобы их тоже в эвентлупе обрабатывать.

Поддерживаю timerfd.

Вот так, например:

    double t0 = dtime();
    while(dtime() - t0 < TTYTIMEOUT && l){
        ....
    }

В потоке обработки таймера:

повторять цикл:
    задача := задачник.найти_ближайшую_задачу()
    сейчас := получить_текущее_время()
    если задача не пустая:
        осталось_спать := задача.назначенное_время - сейчас
    иначе:
        осталось_спать := 1000

    если осталось_спать <= 0:
        задачник.выбросить(задача)
        задача.выполнить()
        перейти на начало цикла

    событие := канал.ожидать(сколько_ждать=осталось_спать)
    если событие.пора_заканчивать_работу?():
        выйти из цикла
поток.завершить()

задачник и канал должны быть доступны из других потоков. Добавление новой задачи будет примерно так:

задачник.добавить(новая_задача)
канал.послать(событие=уведомление_о_новой_задаче)

При завершении нужно послать уведомление о завершении:

канал.послать(событие=уведомление_о_завершении)

Задачник скорее всего будет деревом, обёрнутым в блокировку. Канал — pipe, socketpair или условная переменная. Зависит от того, что ещё будет ожидать поток для задач по таймеру. Если ты там уже какие-то файловые дескрипторы слушаешь, то имеет смысл использовать pipe или socketpair. Если потоков обработки задач несколько, то лучше подойдёт условная переменная. В этом случае ещё понадобится не просто искать следующую задачу, а ещё и выдёргивать перед ожиданием и перевставлять обратно в задачник, если дело не дошло до выполнения задачи.

Как правильно узнать что текущий промежуток уже закончился?

(псевдокодом): time_now-time_prev>=period+delta… нету другого/иного способа чем помнить прежний момент, отсекать нынешний и считать их разницу.. всё прочее - это просто попытки «подсобить системе» и считать указанное пореже, причем с возможностью отстрелить пятку.

clock_gettime() не бесплатен

А он не через vdso работает? Если через него, то там же просто чтение из памяти без сисколов.

clock_gettime() не бесплатен

А он не через vdso работает? Если через него, то там же просто чтение из памяти без сисколов

Через VDSO работает только COARSE_чотатам. Всё остальное лезет в ядро.

Какие еще есть варианты?

man crontab

Низкоточные таймеры - чума 21-го века!

clock_gettime() не бесплатен

Он явно дешевле создания и засыпания-пробуждения треда.

Как в играх делай.

Таки №3 – дебильного в этом ничего нет.

Ну то есть по сути это clock_gettime.

----

А зачем ты использовал число с плавающей запятой для этих целей?

Можешь подробнее рассказать что за COARSE? Загуглил vdso coarse и получил какой-то не очень читабельный результат.

Почему?

COKPOWEHEU
AlexVR
byko3y
anarquista
Eddy_Em
i-rinat
mashmed135
MKuznetsov
byko3y

Спасибо вам за помощь! У меня теперь есть ряд вариантов - буду их изучать и приму решение исходя из того какой лучше мне подходит.

Посылаю лучи любви!

Ну, может и нет.
Проблема в том, что:

1. Он выбрасывает из системных вызовов, и каждый раз нужно убеждаться что никто внутри не использует их либо правильно с ними работает
2. Нужно переустанавливать хендлер. Это странно.

А как в играх?

Насколько дешевле?

Нашел неплохую статью про таймеры с замерами точности и оверхеда:

https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux_for_re...

Можешь подробнее рассказать что за COARSE? Загуглил vdso coarse и получил какой-то не очень читабельный результат

clock_gettime же ж:

https://stackoverflow.com/questions/25211241/use-of-coarse-variants-in-clock-...

https://github.com/btorpey/clocks

ClockBench.cpp
                   Method       samples     min     max     avg  median   stdev
           CLOCK_REALTIME       1023      15.00 16182.00          33.35 8098.50  505.15
    CLOCK_REALTIME_COARSE       1023       0.00    0.00    0.00    0.00    0.00
          CLOCK_MONOTONIC       1023      16.00  244.00   19.19  130.00   12.26
      CLOCK_MONOTONIC_RAW       1023      15.00   18.00   16.70   16.50    0.58
   CLOCK_MONOTONIC_COARSE       1023       0.00    0.00    0.00    0.00    0.00
              cpuid+rdtsc       1023      81.00   91.00   86.30   86.00    1.33
                   rdtscp       1023      25.00   31.00   27.61   28.00    1.22
                    rdtsc       1023      15.00   21.00   19.06   18.00    1.04

оно чё, кэширует, что даже rdtsc соснул?

не, там разные единицы измерения между CLOCK и asm вариантами.

на вендовой msvcrt если кому интересно

GetTickCount();                           // 1111200
GetTickCount64();                         // 1333400
__builtin_ia32_rdtsc();                   // 5555600
__builtin_ia32_rdtscp(&rdt);              // 7555600
timeGetTime();                            // 8893000
QueryPerformanceCounter(&qpc);            //11333400
std::chrono::steady_clock::now();         //12889000
std::chrono::high_resolution_clock::now();//12893200
std::chrono::system_clock::now();         //17362400
timespec_get(&tms,TIME_UTC);              //25121300