time.c File Reference

⏱️ High-precision timing utilities implementation More...

Go to the source code of this file.

Macros
#define	SOKOL_TIME_IMPL

Functions
uint64_t	time_get_ns (void)
uint64_t	time_get_realtime_ns (void)
void	time_sleep_ns (uint64_t ns)
uint64_t	time_elapsed_ns (uint64_t start_ns, uint64_t end_ns)
uint64_t	time_timespec_to_ns (const struct timespec *ts)
void	time_ns_to_timespec (uint64_t ns, struct timespec *ts)
bool	timer_system_init (void)
void	timer_system_destroy (void)
bool	timer_start (const char *name)
double	timer_stop (const char *name)
bool	timer_is_initialized (void)
int	format_duration_ns (double nanoseconds, char *buffer, size_t buffer_size)
int	format_duration_ms (double milliseconds, char *buffer, size_t buffer_size)
int	format_duration_s (double seconds, char *buffer, size_t buffer_size)
int	format_uptime_hms (int hours, int minutes, int seconds, char *buffer, size_t buffer_size)
void	adaptive_sleep_init (adaptive_sleep_state_t *state, const adaptive_sleep_config_t *config)
uint64_t	adaptive_sleep_calculate (adaptive_sleep_state_t *state, size_t queue_depth, size_t target_depth)
void	adaptive_sleep_do (adaptive_sleep_state_t *state, size_t queue_depth, size_t target_depth)
bool	time_format_is_valid_strftime (const char *format_str)
int	time_format_now (const char *format_str, char *buf, size_t buf_size)
asciichat_error_t	time_format_safe (const char *format_str, char *buf, size_t buf_size)

Detailed Description

⏱️ High-precision timing utilities implementation

Definition in file util/time.c.

Macro Definition Documentation

SOKOL_TIME_IMPL

#define SOKOL_TIME_IMPL

Definition at line 11 of file util/time.c.

Function Documentation

adaptive_sleep_calculate()

uint64_t adaptive_sleep_calculate	(	adaptive_sleep_state_t *	state,
		size_t	queue_depth,
		size_t	target_depth
	)

Definition at line 408 of file util/time.c.

                                                                                                          {
  if (!state) {
    return 0;
  }
 
  const adaptive_sleep_config_t *cfg = &state->config;
 
  // Determine if we need to speed up or slow down
  double desired_multiplier;
 
  if (queue_depth > target_depth) {
    // Queue is building up - speed up processing
    // The more items in queue, the faster we should process
    size_t backlog = queue_depth - target_depth;
 
    // Calculate desired speed based on backlog
    // Each item above target increases speed proportionally
    // This ensures we drain the queue faster the more backed up we are
    double backlog_factor = 1.0 + ((double)backlog / (double)(target_depth + 1));
    desired_multiplier = cfg->min_speed_multiplier * backlog_factor;
 
    // Clamp to max speed
    if (desired_multiplier > cfg->max_speed_multiplier) {
      desired_multiplier = cfg->max_speed_multiplier;
    }
 
    // Ramp up gradually based on speedup_rate
    double delta = desired_multiplier - state->current_speed_multiplier;
    state->current_speed_multiplier += delta * cfg->speedup_rate;
 
  } else {
    // Queue is at or below target - slow down to baseline
    desired_multiplier = cfg->min_speed_multiplier;
 
    // Ramp down gradually based on slowdown_rate
    double delta = desired_multiplier - state->current_speed_multiplier;
    state->current_speed_multiplier += delta * cfg->slowdown_rate;
  }
 
  // Ensure we stay within configured bounds
  if (state->current_speed_multiplier < cfg->min_speed_multiplier) {
    state->current_speed_multiplier = cfg->min_speed_multiplier;
  }
  if (state->current_speed_multiplier > cfg->max_speed_multiplier) {
    state->current_speed_multiplier = cfg->max_speed_multiplier;
  }
 
  // Calculate actual sleep time: baseline / speed_multiplier
  // Higher multiplier = shorter sleep = faster processing
  uint64_t sleep_ns = (uint64_t)(cfg->baseline_sleep_ns / state->current_speed_multiplier);
 
  // Store for debugging
  state->last_sleep_ns = sleep_ns;
 
  return sleep_ns;
}

Referenced by adaptive_sleep_do().

adaptive_sleep_do()

void adaptive_sleep_do	(	adaptive_sleep_state_t *	state,
		size_t	queue_depth,
		size_t	target_depth
	)

Definition at line 465 of file util/time.c.

                                                                                               {
  uint64_t sleep_ns = adaptive_sleep_calculate(state, queue_depth, target_depth);
 
  if (sleep_ns > 0) {
    platform_sleep_ns(sleep_ns);
  }
}

References adaptive_sleep_calculate().

Referenced by client_audio_render_thread(), client_video_render_thread(), and session_capture_sleep_for_fps().

adaptive_sleep_init()

void adaptive_sleep_init	(	adaptive_sleep_state_t *	state,
		const adaptive_sleep_config_t *	config
	)

Definition at line 393 of file util/time.c.

                                                                                               {
  if (!state || !config) {
    return;
  }
 
  // Copy configuration
  state->config = *config;
 
  // Start at baseline speed (no speedup initially)
  state->current_speed_multiplier = config->min_speed_multiplier;
 
  // Initial sleep is the baseline
  state->last_sleep_ns = config->baseline_sleep_ns;
}

Referenced by client_audio_render_thread(), client_video_render_thread(), session_capture_create(), and session_network_capture_create().

format_duration_ms()

int format_duration_ms	(	double	milliseconds,
		char *	buffer,
		size_t	buffer_size
	)

Definition at line 357 of file util/time.c.

                                                                              {
  // Convert milliseconds to nanoseconds and use the nanosecond formatter
  double nanoseconds = milliseconds * NS_PER_MS;
  return format_duration_ns(nanoseconds, buffer, buffer_size);
}

References buffer_size, and format_duration_ns().

format_duration_ns()

int format_duration_ns	(	double	nanoseconds,
		char *	buffer,
		size_t	buffer_size
	)

Definition at line 275 of file util/time.c.

                                                                             {
  if (!buffer || buffer_size == 0) {
    return -1;
  }
 
  // Handle negative durations
  if (nanoseconds < 0) {
    nanoseconds = -nanoseconds;
  }
 
  int written = 0;
 
  // Nanoseconds (< 1µs)
  if (nanoseconds < NS_PER_US) {
    written = safe_snprintf(buffer, buffer_size, "%.0fns", nanoseconds);
  }
  // Microseconds (< 1ms)
  else if (nanoseconds < NS_PER_MS) {
    double us = nanoseconds / NS_PER_US;
    if (us < 10.0) {
      written = safe_snprintf(buffer, buffer_size, "%.1fµs", us);
    } else {
      written = safe_snprintf(buffer, buffer_size, "%.0fµs", us);
    }
  }
  // Milliseconds (< 1s)
  else if (nanoseconds < NS_PER_SEC) {
    double ms = nanoseconds / NS_PER_MS;
    if (ms < 10.0) {
      written = safe_snprintf(buffer, buffer_size, "%.1fms", ms);
    } else {
      written = safe_snprintf(buffer, buffer_size, "%.0fms", ms);
    }
  }
  // Seconds (< 1m)
  else if (nanoseconds < NS_PER_MIN) {
    double s = nanoseconds / NS_PER_SEC;
    if (s < 10.0) {
      written = safe_snprintf(buffer, buffer_size, "%.2fs", s);
    } else {
      written = safe_snprintf(buffer, buffer_size, "%.1fs", s);
    }
  }
  // Minutes (< 1h) - show minutes and seconds
  else if (nanoseconds < NS_PER_HOUR) {
    int minutes = (int)(nanoseconds / NS_PER_MIN);
    int seconds = (int)((nanoseconds - (minutes * NS_PER_MIN)) / NS_PER_SEC);
    written = safe_snprintf(buffer, buffer_size, "%dm%ds", minutes, seconds);
  }
  // Hours (< 1d) - show hours, minutes, and seconds
  else if (nanoseconds < NS_PER_DAY) {
    int hours = (int)(nanoseconds / NS_PER_HOUR);
    double remaining_ns = nanoseconds - ((double)hours * NS_PER_HOUR);
    int minutes = (int)(remaining_ns / NS_PER_MIN);
    double remaining_after_min = remaining_ns - ((double)minutes * NS_PER_MIN);
    int seconds = (int)(remaining_after_min / NS_PER_SEC);
    written = safe_snprintf(buffer, buffer_size, "%dh%dm%ds", hours, minutes, seconds);
  }
  // Days (< 1y) - show days, hours, minutes, and seconds
  else if (nanoseconds < NS_PER_YEAR) {
    int days = (int)(nanoseconds / NS_PER_DAY);
    double remaining_ns = nanoseconds - ((double)days * NS_PER_DAY);
    int hours = (int)(remaining_ns / NS_PER_HOUR);
    remaining_ns = remaining_ns - ((double)hours * NS_PER_HOUR);
    int minutes = (int)(remaining_ns / NS_PER_MIN);
    double remaining_after_min = remaining_ns - ((double)minutes * NS_PER_MIN);
    int seconds = (int)(remaining_after_min / NS_PER_SEC);
    written = safe_snprintf(buffer, buffer_size, "%dd%dh%dm%ds", days, hours, minutes, seconds);
  }
  // Years - show years with one decimal
  else {
    double years = nanoseconds / NS_PER_YEAR;
    written = safe_snprintf(buffer, buffer_size, "%.1fy", years);
  }
 
  if (written < 0 || (size_t)written >= buffer_size) {
    return -1;
  }
 
  return written;
}

References buffer_size, and safe_snprintf().

Referenced by acip_server_receive_and_dispatch(), asciichat_instr_log_line(), broadcast_server_state_to_all_clients(), client_video_render_thread(), create_mixed_ascii_frame_for_client(), format_duration_ms(), format_duration_s(), session_render_loop(), and timer_stop().

format_duration_s()

int format_duration_s	(	double	seconds,
		char *	buffer,
		size_t	buffer_size
	)

Definition at line 363 of file util/time.c.

                                                                        {
  // Convert seconds to nanoseconds and use the nanosecond formatter
  double nanoseconds = seconds * NS_PER_SEC;
  return format_duration_ns(nanoseconds, buffer, buffer_size);
}

References buffer_size, and format_duration_ns().

Referenced by crypto_init(), and crypto_rekey_init().

format_uptime_hms()

int format_uptime_hms	(	int	hours,
		int	minutes,
		int	seconds,
		char *	buffer,
		size_t	buffer_size
	)

Definition at line 369 of file util/time.c.

                                                                                             {
  if (!buffer || buffer_size == 0) {
    return -1;
  }
 
  // Validate components
  if (hours < 0 || minutes < 0 || minutes >= 60 || seconds < 0 || seconds >= 60) {
    return -1;
  }
 
  // Format as HH:MM:SS with zero-padding
  int written = safe_snprintf(buffer, buffer_size, "%02d:%02d:%02d", hours, minutes, seconds);
 
  if (written < 0 || (size_t)written >= buffer_size) {
    return -1;
  }
 
  return written;
}

References buffer_size, and safe_snprintf().

Referenced by discovery_status_display().

time_elapsed_ns()

uint64_t time_elapsed_ns	(	uint64_t	start_ns,
		uint64_t	end_ns
	)

Definition at line 90 of file util/time.c.

                                                             {
  // Handle wraparound (defensive - uint64_t won't wrap in practice at nanosecond resolution)
  // but this is safe and handles any theoretical edge cases
  if (end_ns >= start_ns) {
    return end_ns - start_ns;
  }
  // Wraparound case (extremely unlikely)
  return (UINT64_MAX - start_ns) + end_ns + 1;
}

Referenced by ascii_convert_with_capabilities(), asciichat_instr_log_line(), audio_analysis_print_report(), broadcast_server_state_to_all_clients(), client_send_thread_func(), fps_frame_ns(), media_source_read_video(), media_source_seek(), mixer_process_excluding_source(), session_capture_get_current_fps(), session_capture_read_frame(), and session_render_loop().

time_format_is_valid_strftime()

bool time_format_is_valid_strftime

(

const char *

format_str

)

Definition at line 483 of file util/time.c.

                                                           {
  if (!format_str) {
    return false;
  }
 
  for (const char *p = format_str; *p; p++) {
    if (*p == '%') {
      p++;
      if (!*p) {
        /* Unterminated % at end of string */
        log_error("Invalid time format: unterminated %% at end");
        return false;
      }
 
      if (*p == '%') {
        /* Escaped %% - this is valid, just skip it */
        continue;
      }
 
      /* Optional: flag characters (-, 0, +, space) */
      if (*p == '-' || *p == '0' || *p == '+' || *p == ' ') {
        p++;
        if (!*p) {
          log_error("Invalid time format: flag character without specifier");
          return false;
        }
      }
 
      /* Optional: width specifier (digits or *) */
      if (*p == '*' || isdigit((unsigned char)*p)) {
        while (*p && (isdigit((unsigned char)*p) || *p == '*')) {
          p++;
        }
        if (!*p) {
          log_error("Invalid time format: width specifier without specifier character");
          return false;
        }
      }
 
      /* Optional: precision specifier (.digits or .*) */
      if (*p == '.') {
        p++;
        if (!*p) {
          log_error("Invalid time format: precision specifier incomplete");
          return false;
        }
        while (*p && (isdigit((unsigned char)*p) || *p == '*')) {
          p++;
        }
        if (!*p) {
          log_error("Invalid time format: precision specifier without specifier character");
          return false;
        }
      }
 
      /* Optional: modifier characters (E for %Ex, O for %Ox) */
      if (*p == 'E' || *p == 'O') {
        p++;
        if (!*p) {
          log_error("Invalid time format: modifier character without specifier");
          return false;
        }
      }
 
      /* Validate that the final character is a supported specifier */
      if (!strchr(SUPPORTED_SPECIFIERS, *p)) {
        log_error("Invalid time format: unsupported specifier %%%c (at position %ld)", *p, (p - format_str));
        return false;
      }
    }
  }
 
  return true;
}

Referenced by time_format_safe().

time_format_now()

int time_format_now	(	const char *	format_str,
		char *	buf,
		size_t	buf_size
	)

Definition at line 558 of file util/time.c.

                                                                        {
  if (!format_str || !buf || buf_size < 2) {
    SET_ERRNO(ERROR_INVALID_PARAM, "time_format_now: invalid arguments - format_str=%p, buf=%p, buf_size=%zu",
              format_str, buf, buf_size);
    return 0;
  }
 
  /* Get current wall-clock time in nanoseconds */
  uint64_t ts_ns = time_get_realtime_ns();
 
  /* Extract seconds and nanoseconds */
  time_t seconds = (time_t)(ts_ns / NS_PER_SEC_INT);
  long nanoseconds = (long)(ts_ns % NS_PER_SEC_INT);
 
  /* Convert seconds to struct tm */
  struct tm tm_info;
  platform_localtime(&seconds, &tm_info);
 
  /* Format using strftime */
  size_t len = strftime(buf, buf_size, format_str, &tm_info);
 
  /* Check for strftime errors or buffer overflow */
  if (len == 0) {
    /* strftime returned 0 - either error or exact buffer fill */
    log_debug("strftime returned 0 for format: %s", format_str);
    return 0;
  }
 
  if (len >= buf_size - 1) {
    /* Buffer would overflow - strftime filled entire buffer or hit exact size */
    log_error("time_format_now: buffer too small (need %zu, have %zu)", len + 1, buf_size);
    return 0;
  }
 
  return (int)len;
}

References platform_localtime(), and time_get_realtime_ns().

Referenced by log_template_apply(), and time_format_safe().

time_format_safe()

asciichat_error_t time_format_safe	(	const char *	format_str,
		char *	buf,
		size_t	buf_size
	)

Definition at line 595 of file util/time.c.

                                                                                       {
  /* Check NULL pointers */
  if (!format_str) {
    return SET_ERRNO(ERROR_INVALID_STATE, "time_format_safe: format_str is NULL");
  }
 
  if (!buf) {
    return SET_ERRNO(ERROR_INVALID_STATE, "time_format_safe: buf is NULL");
  }
 
  /* Check minimum buffer size */
  if (buf_size < 64) {
    return SET_ERRNO(ERROR_INVALID_STATE, "time_format_safe: buffer too small (minimum 64 bytes, got %zu)", buf_size);
  }
 
  /* Validate format string */
  if (!time_format_is_valid_strftime(format_str)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "time_format_safe: invalid time format: %s", format_str);
  }
 
  /* Format the time */
  int result = time_format_now(format_str, buf, buf_size);
  if (result <= 0) {
    return SET_ERRNO(ERROR_INVALID_STATE, "time_format_safe: strftime formatting failed");
  }
 
  return ASCIICHAT_OK;
}

References time_format_is_valid_strftime(), and time_format_now().

time_get_ns()

uint64_t time_get_ns

(

void

)

Definition at line 48 of file util/time.c.

                           {
  // sokol_time provides monotonic clock that never goes backwards
  // stm_ns() converts ticks to nanoseconds
  // Ensure sokol_time is initialized before use (defensive programming)
  if (!g_sokol_time_initialized) {
    stm_setup();
    g_sokol_time_initialized = true;
  }
  return (uint64_t)stm_ns(stm_now());
}

Referenced by acip_server_receive_and_dispatch(), ascii_convert_with_capabilities(), asciichat_instr_log_line(), audio_analysis_init(), audio_analysis_print_report(), audio_analysis_track_received_packet(), audio_analysis_track_sent_packet(), benchmark_simd_color_conversion(), benchmark_simd_color_conversion_with_source(), benchmark_simd_conversion(), benchmark_simd_conversion_with_source(), broadcast_server_state_to_all_clients(), buffer_pool_free(), buffer_pool_shrink(), client_audio_render_thread(), client_dispatch_thread(), client_send_thread_func(), client_video_render_thread(), consensus_coordinator_create(), consensus_coordinator_on_collection_start(), consensus_coordinator_process(), consensus_coordinator_time_until_next_round(), create_mixed_ascii_frame_for_client(), discovery_mdns_query(), get_utf8_palette_cache(), media_source_read_video(), media_source_seek(), mixer_process_excluding_source(), nat_measure_bandwidth(), session_capture_create(), session_capture_get_current_fps(), session_capture_read_frame(), session_display_convert_to_ascii(), session_display_create(), session_network_capture_create(), session_render_loop(), simple_frame_swap_update(), and websocket_server_run().

time_get_realtime_ns()

uint64_t time_get_realtime_ns

(

void

)

Definition at line 59 of file util/time.c.

                                    {
#ifdef _WIN32
  // Windows: Use GetSystemTimePreciseAsFileTime (Win8+) for high-precision wall clock
  // FILETIME is 100-nanosecond intervals since January 1, 1601
  FILETIME ft;
  GetSystemTimePreciseAsFileTime(&ft);
  // Convert FILETIME to nanoseconds
  uint64_t filetime = ((uint64_t)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
  // Convert 100-nanosecond intervals to nanoseconds
  return filetime * 100;
#else
  // Get wall-clock (real-time) timestamp
  struct timespec ts;
  if (clock_gettime(CLOCK_REALTIME, &ts) != 0) {
    // Fallback on error (unlikely)
    return 0;
  }
  return time_timespec_to_ns(&ts);
#endif
}

References time_timespec_to_ns().

Referenced by acds_validate_timestamp(), asciichat_error_stats_record(), asciichat_instr_log_line(), asciichat_set_errno(), connection_attempt_tcp(), connection_attempt_websocket(), connection_check_timeout(), connection_context_init(), consensus_metrics_measure(), consensus_state_compute_election(), database_session_is_migration_ready(), database_session_start_migration(), get_current_time_formatted(), log_json_async_safe(), log_msg(), log_plain_msg(), log_terminal_msg(), and time_format_now().

time_ns_to_timespec()

void time_ns_to_timespec	(	uint64_t	ns,
		struct timespec *	ts
	)

Definition at line 112 of file util/time.c.

                                                           {
  if (!ts) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null ts");
    return;
  }
  ts->tv_sec = (time_t)(ns / NS_PER_SEC_INT);
  ts->tv_nsec = (long)(ns % NS_PER_SEC_INT);
}

time_sleep_ns()

void time_sleep_ns

(

uint64_t

ns

)

Definition at line 80 of file util/time.c.

                                {
  // Use platform abstraction for cross-platform sleep
  // Convert nanoseconds to microseconds (1 us = 1000 ns)
  unsigned int usec = (unsigned int)(ns / 1000);
  if (usec == 0 && ns > 0) {
    usec = 1; // Minimum 1 microsecond
  }
  platform_sleep_us(usec);
}

References platform_sleep_us().

time_timespec_to_ns()

uint64_t time_timespec_to_ns

(

const struct timespec *

ts

)

Definition at line 104 of file util/time.c.

                                                        {
  if (!ts) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null ts");
    return 0;
  }
  return (uint64_t)ts->tv_sec * NS_PER_SEC_INT + (uint64_t)ts->tv_nsec;
}

Referenced by time_get_realtime_ns().

timer_is_initialized()

bool timer_is_initialized

(

void

)

Definition at line 267 of file util/time.c.

                                {
  return g_timer_manager.initialized;
}

timer_start()

bool timer_start

(

const char *

name

)

Definition at line 172 of file util/time.c.

                                   {
  if (!g_timer_manager.initialized) {
    SET_ERRNO(ERROR_INVALID_STATE, "Timer system not initialized");
    return false;
  }
 
  if (!name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Timer name is NULL");
    return false;
  }
 
  rwlock_wrlock(&g_timer_manager.rwlock);
 
  // Check if timer already exists - this is an error, timers must be unique
  timer_record_t *existing = NULL;
  HASH_FIND_STR(g_timer_manager.timers, name, existing);
 
  if (existing) {
    rwlock_wrunlock(&g_timer_manager.rwlock);
    SET_ERRNO(ERROR_INVALID_STATE, "Timer '%s' already exists - timers must have unique names", name);
    return false;
  }
 
  // Create new timer record
  timer_record_t *timer = SAFE_MALLOC(sizeof(timer_record_t), timer_record_t *);
  if (!timer) {
    rwlock_wrunlock(&g_timer_manager.rwlock);
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate timer record");
    return false;
  }
 
  // Use platform-safe string duplication
  size_t name_len = strlen(name) + 1;
  timer->name = SAFE_MALLOC(name_len, char *);
  if (!timer->name) {
    SAFE_FREE(timer);
    rwlock_wrunlock(&g_timer_manager.rwlock);
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate timer name");
    return false;
  }
  SAFE_STRNCPY(timer->name, name, name_len);
 
  timer->start_ticks = stm_now();
 
  // Add to hashtable
  HASH_ADD_KEYPTR(hh, g_timer_manager.timers, timer->name, strlen(timer->name), timer);
 
  rwlock_wrunlock(&g_timer_manager.rwlock);
  return true;
}

timer_stop()

double timer_stop

(

const char *

name

)

Definition at line 223 of file util/time.c.

                                    {
  if (!g_timer_manager.initialized) {
    SET_ERRNO(ERROR_INVALID_STATE, "Timer system not initialized");
    return -1.0;
  }
 
  if (!name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Timer name is NULL");
    return -1.0;
  }
 
  rwlock_wrlock(&g_timer_manager.rwlock);
 
  // Find timer
  timer_record_t *timer = NULL;
  HASH_FIND_STR(g_timer_manager.timers, name, timer);
 
  if (!timer) {
    rwlock_wrunlock(&g_timer_manager.rwlock);
    log_warn("Timer '%s' not found", name);
    return -1.0;
  }
 
  // Calculate elapsed time in nanoseconds for maximum precision
  uint64_t end_ticks = stm_now();
  uint64_t elapsed_ticks = stm_diff(end_ticks, timer->start_ticks);
  double elapsed_ns = stm_ns(elapsed_ticks);
 
  // Format duration for human-readable logging
  char duration_str[32];
  format_duration_ns(elapsed_ns, duration_str, sizeof(duration_str));
 
  // Log the result (dev level - only shown with --verbose)
  log_dev("Timer '%s': %s", name, duration_str);
 
  // Remove from hashtable
  HASH_DEL(g_timer_manager.timers, timer);
  SAFE_FREE(timer->name);
  SAFE_FREE(timer);
 
  rwlock_wrunlock(&g_timer_manager.rwlock);
  return elapsed_ns; // Return nanoseconds
}

References format_duration_ns().

timer_system_destroy()

void timer_system_destroy

(

void

)

Definition at line 146 of file util/time.c.

                                {
  if (!g_timer_manager.initialized) {
    return;
  }
 
  rwlock_wrlock(&g_timer_manager.rwlock);
 
  // Free all timer records
  int timer_count = 0;
  timer_record_t *current, *tmp;
  HASH_ITER(hh, g_timer_manager.timers, current, tmp) {
    HASH_DEL(g_timer_manager.timers, current);
    SAFE_FREE(current->name);
    SAFE_FREE(current);
    timer_count++;
  }
 
  g_timer_manager.timers = NULL;
  g_timer_manager.initialized = false;
 
  rwlock_wrunlock(&g_timer_manager.rwlock);
  rwlock_destroy(&g_timer_manager.rwlock);
 
  log_debug("Timer system cleaned up (freed %d timers)", timer_count);
}

Referenced by asciichat_shared_destroy().

timer_system_init()

bool timer_system_init

(

void

)

Definition at line 125 of file util/time.c.

                             {
  if (g_timer_manager.initialized) {
    return true;
  }
 
  // Initialize sokol_time
  stm_setup();
 
  // Initialize rwlock (uthash requires external locking for writes, rwlock allows concurrent reads)
  if (rwlock_init(&g_timer_manager.rwlock) != 0) {
    SET_ERRNO(ERROR_PLATFORM_INIT, "Failed to initialize timer rwlock");
    return false;
  }
 
  g_timer_manager.timers = NULL;
  g_timer_manager.initialized = true;
 
  log_dev("Timer system initialized");
  return true;
}

References rwlock_init().

Referenced by asciichat_shared_init().

Variable Documentation

initialized

bool initialized

Initialization state.

Definition at line 33 of file util/time.c.

rwlock

rwlock_t rwlock

Read-write lock for thread-safe access (uthash requires external locking)

Definition at line 32 of file util/time.c.

Referenced by debug_rwlock_rdlock(), debug_rwlock_rdunlock(), debug_rwlock_wrlock(), debug_rwlock_wrunlock(), rwlock_init(), rwlock_rdlock_impl(), rwlock_rdunlock_impl(), rwlock_wrlock_impl(), and rwlock_wrunlock_impl().

timers

timer_record_t* timers

Hash table of active timers (uthash head pointer)

Definition at line 31 of file util/time.c.