common/sync.h

Go to the documentation of this file.

#pragma once

 
#include <libplatform/compiler.h>
#include <libplatform/system.h>
#include <libplatform/mutex.h>
#include <libplatform/rwlock.h>
#include <libplatform/cond.h>
#include "../debug/named.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_named(static_mutex_t *m, const char *name) {
#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, name);
    // 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
  // Register a statically initialized native mutex once, without reinitializing it.
  int state = __atomic_load_n(&m->initialized, __ATOMIC_ACQUIRE);
  if (state != 2) {
    int expected = state;
    if (state >= 0 &&
        __atomic_compare_exchange_n(&m->initialized, &expected, -1, false, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE)) {
      if (state == 0)
        mutex_init(&m->mutex, name);
      else
        m->mutex.name = NAMED_REGISTER_MUTEX(&m->mutex, name, NULL);
      __atomic_store_n(&m->initialized, 2, __ATOMIC_RELEASE);
    } else {
      while (__atomic_load_n(&m->initialized, __ATOMIC_ACQUIRE) != 2) {
      }
    }
  }
#endif
  mutex_lock(&m->mutex);
}
 
static inline void static_mutex_lock(static_mutex_t *m) {
  static_mutex_lock_named(m, "static_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
// ============================================================================