ascii-chat/rwlock_8h_source.html

#pragma once


#include <stdbool.h>

#include <stdint.h>

#include <ascii-chat/atomic.h>


#ifdef _WIN32

#include "windows_compat.h"

typedef struct {

    SRWLOCK impl;

    const char *name;

#ifndef NDEBUG

    uint64_t last_rdlock_time_ns;

    uint64_t last_wrlock_time_ns;

    uint64_t last_unlock_time_ns;

    uintptr_t write_held_by_key;

    atomic_t read_lock_count;

    uint64_t rdlock_count;

    uint64_t wrlock_count;

    uint64_t unlock_count;

#endif

} rwlock_t;

#else

#include <pthread.h>


typedef struct {

    pthread_rwlock_t impl;

    const char *name;

#ifndef NDEBUG

    uint64_t last_rdlock_time_ns;

    uint64_t last_wrlock_time_ns;

    uint64_t last_unlock_time_ns;

    uintptr_t write_held_by_key;

    atomic_t read_lock_count;

    uint64_t rdlock_count;

    uint64_t wrlock_count;

    uint64_t unlock_count;

#endif

} rwlock_t;


#endif


// Forward declarations for lock debugging

// Note: Full lock_debug.h cannot be included here due to circular dependencies

// Files that use both rwlock and lock_debug must include lock_debug.h separately

#ifndef NDEBUG

#ifdef __cplusplus

extern "C" {

#endif


bool debug_sync_is_initialized(void);

int debug_sync_rwlock_rdlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name);

int debug_sync_rwlock_wrlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name);

int debug_sync_rwlock_rdunlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name);

int debug_sync_rwlock_wrunlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name);


#ifdef __cplusplus

}

#endif

#endif


#ifdef __cplusplus

extern "C" {

#endif


// ============================================================================

// Read-Write Lock Functions

// ============================================================================


int rwlock_init(rwlock_t *lock, const char *name);


int rwlock_destroy(rwlock_t *lock);


#ifndef NDEBUG

void rwlock_on_rdlock(rwlock_t *rwlock);

#else

#define rwlock_on_rdlock(rwlock) ((void)0)

#endif


#ifndef NDEBUG

void rwlock_on_wrlock(rwlock_t *rwlock);

#else

#define rwlock_on_wrlock(rwlock) ((void)0)

#endif


#ifndef NDEBUG

void rwlock_on_unlock(rwlock_t *rwlock);

#else

#define rwlock_on_unlock(rwlock) ((void)0)

#endif


#ifndef NDEBUG

void rwlock_log_state(const rwlock_t *rwlock, const char *file, int line, const char *func);

#define LOG_RWLOCK_STATE(rwlock) rwlock_log_state(rwlock, __FILE__, __LINE__, __func__)

#else

#define LOG_RWLOCK_STATE(rwlock) ((void)0)

#endif


int rwlock_init_impl(rwlock_t *lock);


int rwlock_destroy_impl(rwlock_t *lock);


int rwlock_rdlock_impl(rwlock_t *lock);


int rwlock_wrlock_impl(rwlock_t *lock);


int rwlock_rdunlock_impl(rwlock_t *lock);


int rwlock_wrunlock_impl(rwlock_t *lock);


#ifdef NDEBUG

#define rwlock_rdlock(lock) rwlock_rdlock_impl(lock)

#else


#define rwlock_rdlock(lock)                                                                                            \

  (debug_sync_is_initialized() ? debug_sync_rwlock_rdlock(lock, __FILE__, __LINE__, __func__) : rwlock_rdlock_impl(lock))


#endif


#ifdef NDEBUG

#define rwlock_wrlock(lock) rwlock_wrlock_impl(lock)

#else


#define rwlock_wrlock(lock)                                                                                            \

  (debug_sync_is_initialized() ? debug_sync_rwlock_wrlock(lock, __FILE__, __LINE__, __func__) : rwlock_wrlock_impl(lock))


#endif


#ifdef NDEBUG

#define rwlock_rdunlock(lock) rwlock_rdunlock_impl(lock)

#else


#define rwlock_rdunlock(lock)                                                                                          \

  (debug_sync_is_initialized() ? debug_sync_rwlock_rdunlock(lock, __FILE__, __LINE__, __func__) : rwlock_rdunlock_impl(lock))


#endif


#ifdef NDEBUG

#define rwlock_wrunlock(lock) rwlock_wrunlock_impl(lock)

#else


#define rwlock_wrunlock(lock)                                                                                          \

  (debug_sync_is_initialized() ? debug_sync_rwlock_wrunlock(lock, __FILE__, __LINE__, __func__) : rwlock_wrunlock_impl(lock))


#endif


#ifdef __cplusplus

}

#endif


atomic.h
⚛️ Atomic operations abstraction layer with debug tracking

uint64_t
unsigned long long uint64_t
Definition common.h:59

debug_sync_rwlock_rdunlock
int debug_sync_rwlock_rdunlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name)
Definition sync.c:765

rwlock_t::wrlock_count
uint64_t wrlock_count
Total write lock acquisitions.
Definition rwlock.h:71

rwlock_t::name
const char * name
Human-readable name for named registry (all builds)
Definition rwlock.h:63

rwlock_rdunlock_impl
int rwlock_rdunlock_impl(rwlock_t *lock)
Release a read lock (implementation function)
Definition threading.c:78

debug_sync_rwlock_wrunlock
int debug_sync_rwlock_wrunlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name)
Definition sync.c:779

rwlock_init
int rwlock_init(rwlock_t *lock, const char *name)
Initialize a read-write lock with a name.
Definition threading.c:65

rwlock_destroy
int rwlock_destroy(rwlock_t *lock)
Destroy a read-write lock.

rwlock_log_state
void rwlock_log_state(const rwlock_t *rwlock, const char *file, int line, const char *func)
Log the state of a read-write lock.
Definition rwlock.c:150

rwlock_on_unlock
void rwlock_on_unlock(rwlock_t *rwlock)
Hook called when an rwlock is unlocked (read or write)
Definition rwlock.c:64

debug_sync_rwlock_wrlock
int debug_sync_rwlock_wrlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name)
Definition sync.c:772

rwlock_t::write_held_by_key
uintptr_t write_held_by_key
Registry key of thread holding write lock (0 if not held)
Definition rwlock.h:68

rwlock_rdlock_impl
int rwlock_rdlock_impl(rwlock_t *lock)
Acquire a read lock (implementation function)
Definition threading.c:70

rwlock_t::impl
pthread_rwlock_t impl
Underlying POSIX rwlock.
Definition rwlock.h:62

rwlock_t::last_unlock_time_ns
uint64_t last_unlock_time_ns
Timestamp of last unlock (nanoseconds)
Definition rwlock.h:67

rwlock_wrunlock_impl
int rwlock_wrunlock_impl(rwlock_t *lock)
Release a write lock (implementation function)
Definition threading.c:82

rwlock_wrlock_impl
int rwlock_wrlock_impl(rwlock_t *lock)
Acquire a write lock (implementation function)
Definition threading.c:74

rwlock_on_rdlock
void rwlock_on_rdlock(rwlock_t *rwlock)
Hook called when a read lock is successfully acquired.
Definition rwlock.c:29

rwlock_destroy_impl
int rwlock_destroy_impl(rwlock_t *lock)
Destroy a read-write lock (implementation function)

debug_sync_is_initialized
bool debug_sync_is_initialized(void)
Definition sync.c:820

debug_sync_rwlock_rdlock
int debug_sync_rwlock_rdlock(rwlock_t *rwlock, const char *file_name, int line_number, const char *function_name)
Definition sync.c:758

rwlock_t::unlock_count
uint64_t unlock_count
Total unlocks.
Definition rwlock.h:72

rwlock_t::last_wrlock_time_ns
uint64_t last_wrlock_time_ns
Timestamp of last write lock acquisition (nanoseconds)
Definition rwlock.h:66

rwlock_on_wrlock
void rwlock_on_wrlock(rwlock_t *rwlock)
Hook called when a write lock is successfully acquired.
Definition rwlock.c:46

rwlock_t::last_rdlock_time_ns
uint64_t last_rdlock_time_ns
Timestamp of last read lock acquisition (nanoseconds)
Definition rwlock.h:65

rwlock_init_impl
int rwlock_init_impl(rwlock_t *lock)
Initialize a read-write lock (implementation function)

rwlock_t::rdlock_count
uint64_t rdlock_count
Total read lock acquisitions.
Definition rwlock.h:70

rwlock_t::read_lock_count
atomic_t read_lock_count
Number of threads holding read locks (thread-safe atomic)
Definition rwlock.h:69

stdbool.h
ClangTool/LibTooling compatibility shim for stdbool.h.

atomic_t
Atomic value wrapper for integral/boolean types.
Definition atomic.h:76

rwlock_t
Read-write lock type (POSIX: pthread_rwlock_t with debug tracking)
Definition rwlock.h:61

rwlock
rwlock_t rwlock
Read-write lock for thread-safe access (uthash requires external locking)
Definition util/time.c:34

windows_compat.h
Wrapper for windows.h with C23 alignment compatibility.