Administrace komentářů

Nějak divně tam inicializuješ ty časové proměnné. Když si normálně v běžném userspace naimplementuju CurrentTicks(), daří se mi to vyzkoušet takhle:

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

static const size_t BILLION = 1000000000;
static const size_t MILLION = 1000000;
static const uint32_t TIME_MASK = 0xffff;
static const uint32_t TIME_MAX = TIME_MASK + 1;
static const struct timespec PAUSE = {
  .tv_sec = 0,
  .tv_nsec = 500000000,
};

static uint32_t CurrentTick() {
  struct timespec ts;
  if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
    perror("clock error");
    exit(1);
  }
  const uint64_t ns = (uint64_t)ts.tv_sec * BILLION +
                      (uint64_t)ts.tv_nsec;
  return (uint32_t)(ns / MILLION) & TIME_MASK;
}

static void funkce1(int chTime) {
  if (chTime > 0) {
    uint32_t t0 = CurrentTick();
    do {

      /* Tady začíná časovaný kód. */
      printf("\tZbývá: %d ms, CurrentTick: %u ms\n", chTime, t0);
      struct timespec remaining;
      if (nanosleep(&PAUSE, &remaining))
        while (nanosleep(&remaining, &remaining));
      /* Tady končí časovaný kód. */

      const uint32_t t1 = CurrentTick();
      chTime -= t1 > t0 ? t1 - t0 : TIME_MAX - t0 + t1;
      t0 = t1;
    } while (chTime > 0);
  }
}

int main() {
  const int times_sec[] = {1, 2, 4, 8, 16, 32, 64, 65, 66, 99};
  for (size_t i = 0; i < sizeof(times_sec) / sizeof(int); ++i) {
    printf("Spouštím časovač na %d s.\n", times_sec[i]);
    funkce1(1000 * times_sec[i]);
  }
  return 0;
}

Tohle^^^ si můžeš rovnou spustit, sledovat, kdy čas přeteče, a zkoušet různé alternativy. Klíčové je, jak se v tom cyklu aktualizuje uplynulý čas.

Pokud by jedna iterace toho časovacího kódu trvala déle než 65536 milisekund, bude samozřejmě tohle řešení nepoužitelné a časování by se muselo řešit jinak.