mutex.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cx/cx.h>
#include <cx/meta/block.h>
#include <cx/time/time.h>
#include <cx/utils/macros.h>
#include "aspin.h"
#include "futex.h"
 
#ifdef CX_LOCK_DEBUG
#include <cx/log/log.h>
#endif
 
CX_C_BEGIN
 
enum MUTEX_Flags {
    MUTEX_NoSpin = 1,   
};
 
typedef struct Mutex {
    Futex ftx;            
    AdaptiveSpin aspin;   
} Mutex;
 
void _mutexInit(_Out_ Mutex* m, uint32 flags);
 
#define mutexInit(m, ...) _mutexInit(m, opt_flags(__VA_ARGS__))
 
_When_(return == true, _Acquires_nonreentrant_lock_(*m)) _When_(timeout == timeForever, _Acquires_nonreentrant_lock_(*m)) _When_(timeout != timeForever, _Must_inspect_result_) bool mutexTryAcquireTimeout(_Inout_ Mutex* m, int64 timeout);
 
_Releases_nonreentrant_lock_(*m) bool mutexRelease(_Inout_ Mutex* m);
 
_When_(return == true, _Acquires_nonreentrant_lock_(*m)) _Must_inspect_result_ _meta_inline bool mutexTryAcquire(_Inout_ Mutex* m)
{
    int32 curstate = atomicLoad(int32, &m->ftx.val, Relaxed);
    if (curstate == 0 &&
        atomicCompareExchange(int32, strong, &m->ftx.val, &curstate, 1, Acquire, Relaxed)) {
        aspinRecordUncontended(&m->aspin);
        return true;
    }
    return false;
}
 
_Acquires_nonreentrant_lock_(*m) _meta_inline void mutexAcquire(_Inout_ Mutex* m)
{
    mutexTryAcquireTimeout(m, timeForever);
}
 
#define withMutex(m) blkWrap (mutexAcquire(m), mutexRelease(m))
 
#ifdef CX_LOCK_DEBUG
// The indirection is what expands CX_LOCK_DEBUG to a level name before it is pasted. It used to
// build the argument array here as well, which could not work: braces do not protect commas from
// the preprocessor, so every argument past the first split the call.
#define _logFmtMutexArgComp(level, fmt, ...) \
    _logFmtArgs(level, LogDefault, LOG_SiteAlways, 0, fmt, __VA_ARGS__)
_Acquires_nonreentrant_lock_(*m) static bool mutexLogAndAcquire(_Inout_ Mutex* m,
                                                                 const char* name,
                                                                 const char* filename, int line)
{
    _logFmtMutexArgComp(CX_LOCK_DEBUG,
                        _S"Locking mutex ${string} at ${string}:${int}",
                        stvar(string, (string)name),
                        stvar(string, (string)filename),
                        stvar(int32, line));
    mutexAcquire(m);
    return true;
}
 
#define mutexAcquire(m) mutexLogAndAcquire(m, #m, __FILE__, __LINE__)
#endif
 
#ifdef CX_LOCK_DEBUG
_Releases_nonreentrant_lock_(*m) static bool mutexLogAndRelease(_Inout_ Mutex* m,
                                                                 const char* name,
                                                                 const char* filename, int line)
{
    _logFmtMutexArgComp(CX_LOCK_DEBUG,
                        _S"Releasing mutex ${string} at ${string}:${int}",
                        stvar(string, (string)name),
                        stvar(string, (string)filename),
                        stvar(int32, line));
    return mutexRelease(m);
}
 
#define mutexRelease(m) mutexLogAndRelease(m, #m, __FILE__, __LINE__)
#endif
 
void mutexDestroy(_Pre_valid_ _Post_invalid_ Mutex* m);
 
CX_C_END
 
// end of thread_mutex group