platform/mutex.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#ifdef _WIN32
#include "windows_compat.h"
typedef struct {
    CRITICAL_SECTION impl;   
    const char *name;        
#ifndef NDEBUG
    uint64_t last_lock_time_ns;   
    uint64_t last_unlock_time_ns; 
    uintptr_t currently_held_by_key; 
    uint64_t lock_count;            
    uint64_t unlock_count;          
    uint64_t trylock_count;         
    uint64_t trylock_success_count; 
#endif
} mutex_t;
#else
#include <pthread.h>
typedef struct {
    pthread_mutex_t impl;    
    const char *name;        
#ifndef NDEBUG
    uint64_t last_lock_time_ns;   
    uint64_t last_unlock_time_ns; 
    uintptr_t currently_held_by_key; 
    uint64_t lock_count;            
    uint64_t unlock_count;          
    uint64_t trylock_count;         
    uint64_t trylock_success_count; 
#endif
} mutex_t;
#endif
 
// Forward declare debug_mutex functions (full declarations in debug/lock.h)
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef NDEBUG
// Only declare these when not in release mode
// The actual implementations are in lib/debug/lock.c when DEBUG_LOCKS is enabled
int debug_sync_mutex_lock(mutex_t *mutex, const char *file_name, int line_number, const char *function_name);
int debug_sync_mutex_trylock(mutex_t *mutex, const char *file_name, int line_number, const char *function_name);
int debug_sync_mutex_unlock(mutex_t *mutex, const char *file_name, int line_number, const char *function_name);
bool debug_sync_is_initialized(void);
#endif
 
// ============================================================================
// Mutex Functions
// ============================================================================
 
int mutex_init(mutex_t *mutex, const char *name);
 
int mutex_destroy(mutex_t *mutex);
 
#ifndef NDEBUG
void mutex_on_lock(mutex_t *mutex);
#else
#define mutex_on_lock(mutex) ((void)0)
#endif
 
#ifndef NDEBUG
void mutex_on_unlock(mutex_t *mutex);
#else
#define mutex_on_unlock(mutex) ((void)0)
#endif
 
#ifndef NDEBUG
void mutex_on_trylock(mutex_t *mutex, bool success);
#else
#define mutex_on_trylock(mutex, success) ((void)0)
#endif
 
#ifndef NDEBUG
void mutex_log_state(const mutex_t *mutex, const char *file, int line, const char *func);
#define LOG_MUTEX_STATE(mutex) mutex_log_state(mutex, __FILE__, __LINE__, __func__)
#else
#define LOG_MUTEX_STATE(mutex) ((void)0)
#endif
 
int mutex_lock_impl(mutex_t *mutex);
 
int mutex_trylock_impl(mutex_t *mutex);
 
int mutex_unlock_impl(mutex_t *mutex);
 
#ifdef NDEBUG
#define mutex_lock(mutex) mutex_lock_impl(mutex)
#else
#define mutex_lock(mutex)                                                                                              \
  (debug_sync_is_initialized() ? debug_sync_mutex_lock(mutex, __FILE__, __LINE__, __func__) : mutex_lock_impl(mutex))
#endif
 
#ifdef NDEBUG
#define mutex_trylock(mutex) mutex_trylock_impl(mutex)
#else
#define mutex_trylock(mutex)                                                                                           \
  (debug_sync_is_initialized() ? debug_sync_mutex_trylock(mutex, __FILE__, __LINE__, __func__) : mutex_trylock_impl(mutex))
#endif
 
#ifdef NDEBUG
#define mutex_unlock(mutex) mutex_unlock_impl(mutex)
#else
#define mutex_unlock(mutex)                                                                                            \
  (debug_sync_is_initialized() ? debug_sync_mutex_unlock(mutex, __FILE__, __LINE__, __func__) : mutex_unlock_impl(mutex))
#endif
 
 
#ifdef __cplusplus
}
#endif