include/ascii-chat/platform/init.h

Go to the documentation of this file.

#pragma once
 
#include "../platform/abstraction.h"
 
// ============================================================================
// Static Initialization Helpers
// ============================================================================
 
// Since Windows doesn't support static initialization of synchronization
// primitives the same way POSIX does, we need a different approach.
// We'll use a combination of static initialization and lazy initialization.
 
typedef struct {
  mutex_t mutex;
#if PLATFORM_WINDOWS
  volatile LONG initialized;
#else
  volatile int initialized;
#endif
} static_mutex_t;
 
typedef struct {
  rwlock_t lock;
#if PLATFORM_WINDOWS
  volatile LONG initialized;
#else
  volatile int initialized;
#endif
} static_rwlock_t;
 
typedef struct {
  cond_t cond;
#if PLATFORM_WINDOWS
  volatile LONG initialized;
#else
  volatile int initialized;
#endif
} static_cond_t;
 
// Initialization macros using designated initializers to avoid warnings
// clang-format off
#if PLATFORM_WINDOWS
#define STATIC_MUTEX_INIT {.mutex = {0}, .initialized = 0}
#define STATIC_RWLOCK_INIT {.lock = {0}, .initialized = 0}
#define STATIC_COND_INIT {.cond = {0}, .initialized = 0}
#else
#define STATIC_MUTEX_INIT {.mutex.impl = PTHREAD_MUTEX_INITIALIZER, .mutex.name = NULL, .initialized = 1}
#define STATIC_RWLOCK_INIT {.lock.impl = PTHREAD_RWLOCK_INITIALIZER, .lock.name = NULL, .initialized = 1}
#define STATIC_COND_INIT {.cond.impl = PTHREAD_COND_INITIALIZER, .cond.name = NULL, .initialized = 1}
#endif
// clang-format on
 
// Lazy initialization functions
static inline void static_mutex_lock(static_mutex_t *m) {
#if PLATFORM_WINDOWS
  // Use InterlockedCompareExchange for thread-safe lazy init with proper synchronization
  // Pattern: First thread sets flag to 1, initializes, then sets to 2
  // Other threads spin until flag is 2 (fully initialized)
  LONG prev = InterlockedCompareExchange(&m->initialized, 1, 0);
  if (prev == 0) {
    // We won the race - initialize the mutex
    mutex_init(&m->mutex, "static_mutex");
    // Memory barrier to ensure init is visible before flag update
    MemoryBarrier();
    InterlockedExchange(&m->initialized, 2);
  } else if (prev == 1) {
    // Another thread is initializing - spin until done
    while (InterlockedCompareExchange(&m->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
  // prev == 2 means already initialized, proceed directly
#else
  // POSIX: Handle fork() by checking initialized flag atomically
  // After fork(), child process must reinitialize the mutex
  // Use atomic operations for thread-safe detection
  if (__atomic_load_n(&m->initialized, __ATOMIC_ACQUIRE) == 0) {
    // Mutex needs initialization (either never initialized or reset after fork)
    mutex_init(&m->mutex, "static_mutex");
    __atomic_store_n(&m->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  mutex_lock(&m->mutex);
}
 
static inline void static_mutex_unlock(static_mutex_t *m) {
  mutex_unlock(&m->mutex);
}
 
static inline void static_rwlock_rdlock(static_rwlock_t *l) {
#if PLATFORM_WINDOWS
  LONG prev = InterlockedCompareExchange(&l->initialized, 1, 0);
  if (prev == 0) {
    rwlock_init(&l->lock, "static_rwlock");
    MemoryBarrier();
    InterlockedExchange(&l->initialized, 2);
  } else if (prev == 1) {
    while (InterlockedCompareExchange(&l->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
#else
  if (__atomic_load_n(&l->initialized, __ATOMIC_ACQUIRE) == 0) {
    rwlock_init(&l->lock, "static_rwlock");
    __atomic_store_n(&l->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  rwlock_rdlock(&l->lock);
}
 
static inline void static_rwlock_wrlock(static_rwlock_t *l) {
#if PLATFORM_WINDOWS
  LONG prev = InterlockedCompareExchange(&l->initialized, 1, 0);
  if (prev == 0) {
    rwlock_init(&l->lock, "static_rwlock");
    MemoryBarrier();
    InterlockedExchange(&l->initialized, 2);
  } else if (prev == 1) {
    while (InterlockedCompareExchange(&l->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
#else
  if (__atomic_load_n(&l->initialized, __ATOMIC_ACQUIRE) == 0) {
    rwlock_init(&l->lock, "static_rwlock");
    __atomic_store_n(&l->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  rwlock_wrlock(&l->lock);
}
 
static inline void static_cond_wait(static_cond_t *c, static_mutex_t *m) {
#if PLATFORM_WINDOWS
  LONG prev = InterlockedCompareExchange(&c->initialized, 1, 0);
  if (prev == 0) {
    cond_init(&c->cond, "static_cond");
    MemoryBarrier();
    InterlockedExchange(&c->initialized, 2);
  } else if (prev == 1) {
    while (InterlockedCompareExchange(&c->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
  if (InterlockedCompareExchange(&m->initialized, 1, 0) == 0) {
    mutex_init(&m->mutex, "static_mutex");
  }
#else
  if (__atomic_load_n(&c->initialized, __ATOMIC_ACQUIRE) == 0) {
    cond_init(&c->cond, "static_cond");
    __atomic_store_n(&c->initialized, 1, __ATOMIC_RELEASE);
  }
  if (__atomic_load_n(&m->initialized, __ATOMIC_ACQUIRE) == 0) {
    mutex_init(&m->mutex, "static_mutex");
    __atomic_store_n(&m->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  cond_wait(&c->cond, &m->mutex);
}
 
static inline void static_cond_timedwait(static_cond_t *c, static_mutex_t *m, int timeout_ms) {
#if PLATFORM_WINDOWS
  LONG prev = InterlockedCompareExchange(&c->initialized, 1, 0);
  if (prev == 0) {
    cond_init(&c->cond, "static_cond");
    MemoryBarrier();
    InterlockedExchange(&c->initialized, 2);
  } else if (prev == 1) {
    while (InterlockedCompareExchange(&c->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
  if (InterlockedCompareExchange(&m->initialized, 1, 0) == 0) {
    mutex_init(&m->mutex, "static_mutex");
  }
#else
  if (__atomic_load_n(&c->initialized, __ATOMIC_ACQUIRE) == 0) {
    cond_init(&c->cond, "static_cond");
    __atomic_store_n(&c->initialized, 1, __ATOMIC_RELEASE);
  }
  if (__atomic_load_n(&m->initialized, __ATOMIC_ACQUIRE) == 0) {
    mutex_init(&m->mutex, "static_mutex");
    __atomic_store_n(&m->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  cond_timedwait(&c->cond, &m->mutex, timeout_ms);
}
 
static inline void static_cond_signal(static_cond_t *c) {
#if PLATFORM_WINDOWS
  LONG prev = InterlockedCompareExchange(&c->initialized, 1, 0);
  if (prev == 0) {
    cond_init(&c->cond, "static_cond");
    MemoryBarrier();
    InterlockedExchange(&c->initialized, 2);
  } else if (prev == 1) {
    while (InterlockedCompareExchange(&c->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
#else
  if (__atomic_load_n(&c->initialized, __ATOMIC_ACQUIRE) == 0) {
    cond_init(&c->cond, "static_cond");
    __atomic_store_n(&c->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  cond_signal(&c->cond);
}
 
static inline void static_cond_broadcast(static_cond_t *c) {
#if PLATFORM_WINDOWS
  LONG prev = InterlockedCompareExchange(&c->initialized, 1, 0);
  if (prev == 0) {
    cond_init(&c->cond, "static_cond");
    MemoryBarrier();
    InterlockedExchange(&c->initialized, 2);
  } else if (prev == 1) {
    while (InterlockedCompareExchange(&c->initialized, 2, 2) != 2) {
      YieldProcessor();
    }
  }
#else
  if (__atomic_load_n(&c->initialized, __ATOMIC_ACQUIRE) == 0) {
    cond_init(&c->cond, "static_cond");
    __atomic_store_n(&c->initialized, 1, __ATOMIC_RELEASE);
  }
#endif
  cond_broadcast(&c->cond);
}
 
// ============================================================================
// Platform Initialization
// ============================================================================
 
// Call this once at program startup
asciichat_error_t platform_init(void);
 
// Call this at program exit
void platform_destroy(void);