#include <threadsafety.h>
#include <util/macros.h>
#include <condition_variable>
#include <mutex>
#include <string>
#include <thread>

Include dependency graph for sync.h:

Classes
class	AnnotatedMixin< PARENT >
	Template mixin that adds -Wthread-safety locking annotations and lock order checking to a subset of the mutex API. More...

class	GlobalMutex
	Different type to mark Mutex at global scope. More...

class	UniqueLock< Mutex, Base >
	Wrapper around std::unique_lock style lock for Mutex. More...

class	UniqueLock< Mutex, Base >::reverse_lock
	An RAII-style reverse lock. More...

class	CSemaphore

class	CSemaphoreGrant
	RAII-style semaphore lock. More...

Macros
#define	AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)

#define	AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)

#define	REVERSE_LOCK(g)

#define	LOCK(cs)

#define	LOCK2(cs1, cs2)

#define	TRY_LOCK(cs, name)

#define	WAIT_LOCK(cs, name) DebugLock<decltype(cs)> name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

#define	ENTER_CRITICAL_SECTION(cs)

#define	LEAVE_CRITICAL_SECTION(cs)

#define	WITH_LOCK(cs, code)
	Run code while locking a mutex. More...

Typedefs
using	RecursiveMutex = AnnotatedMixin< std::recursive_mutex >
	Wrapped mutex: supports recursive locking, but no waiting TODO: We should move away from using the recursive lock by default. More...

using	Mutex = AnnotatedMixin< std::mutex >
	Wrapped mutex: supports waiting but not recursive locking. More...

template<typename MutexArg >
using	DebugLock = UniqueLock< typename std::remove_reference< typename std::remove_pointer< MutexArg >::type >::type >

Functions
template<typename MutexType >
void	EnterCritical (const char pszName, const char pszFile, int nLine, MutexType *cs, bool fTry=false)

void	LeaveCritical ()

void	CheckLastCritical (void cs, std::string &lockname, const char guardname, const char *file, int line)

template<typename MutexType >
void	AssertLockHeldInternal (const char pszName, const char pszFile, int nLine, MutexType *cs) EXCLUSIVE_LOCKS_REQUIRED(cs)

template<typename MutexType >
void	AssertLockNotHeldInternal (const char pszName, const char pszFile, int nLine, MutexType *cs) LOCKS_EXCLUDED(cs)

void	DeleteLock (void *cs)

bool	LockStackEmpty ()

void	AssertLockNotHeldInline (const char name, const char file, int line, Mutex *cs) EXCLUSIVE_LOCKS_REQUIRED(!cs)

void	AssertLockNotHeldInline (const char name, const char file, int line, GlobalMutex *cs) LOCKS_EXCLUDED(cs)

Mutex &	MaybeCheckNotHeld (Mutex &cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs)

Mutex *	MaybeCheckNotHeld (Mutex *cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs)

GlobalMutex &	MaybeCheckNotHeld (GlobalMutex &cs) LOCKS_EXCLUDED(cs) LOCK_RETURNED(cs)

GlobalMutex *	MaybeCheckNotHeld (GlobalMutex *cs) LOCKS_EXCLUDED(cs) LOCK_RETURNED(cs)

Macro Definition Documentation

◆ AssertLockHeld

#define AssertLockHeld ( cs ) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)

Definition at line 146 of file sync.h.

◆ AssertLockNotHeld

#define AssertLockNotHeld ( cs ) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)

Definition at line 163 of file sync.h.

◆ ENTER_CRITICAL_SECTION

#define ENTER_CRITICAL_SECTION ( cs )

Value:

    {                                                                          \
        EnterCritical(#cs, __FILE__, __LINE__, &cs);                           \
        (cs).lock();                                                           \
    }

Definition at line 320 of file sync.h.

◆ LEAVE_CRITICAL_SECTION

#define LEAVE_CRITICAL_SECTION ( cs )

Value:

    {                                                                          \
        std::string lockname;                                                  \
        CheckLastCritical((void *)(&cs), lockname, #cs, __FILE__, __LINE__);   \
        (cs).unlock();                                                         \
        LeaveCritical();                                                       \
    }

Definition at line 326 of file sync.h.

◆ LOCK

#define LOCK ( cs )

Value:

DebugLock<decltype(cs)> UNIQUE_LOG_NAME(criticalblock)( \

MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

UniqueLock

Wrapper around std::unique_lock style lock for Mutex.

Definition: sync.h:168

UNIQUE_LOG_NAME

#define UNIQUE_LOG_NAME(name)

Definition: macros.h:11

Definition at line 306 of file sync.h.

◆ LOCK2

#define LOCK2	(	cs1,
		cs2
	)

Value:

    DebugLock<decltype(cs1)> criticalblock1(MaybeCheckNotHeld(cs1), #cs1,      \
                                            __FILE__, __LINE__);               \
    DebugLock<decltype(cs2)> criticalblock2(MaybeCheckNotHeld(cs2), #cs2,      \
                                            __FILE__, __LINE__);

Definition at line 309 of file sync.h.

◆ REVERSE_LOCK

#define REVERSE_LOCK ( g )

Value:

typename std::decay<decltype(g)>::type::reverse_lock UNIQUE_LOG_NAME( \

revlock)(g, #g, __FILE__, __LINE__)

Definition at line 265 of file sync.h.

◆ TRY_LOCK

#define TRY_LOCK	(	cs,
		name
	)

Value:

DebugLock<decltype(cs)> name(MaybeCheckNotHeld(cs), #cs, __FILE__, \

__LINE__, true)

name

const char * name

Definition: rest.cpp:47

Definition at line 314 of file sync.h.

◆ WAIT_LOCK

#define WAIT_LOCK	(	cs,
		name
	)	DebugLock<decltype(cs)> name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

Definition at line 317 of file sync.h.

◆ WITH_LOCK

#define WITH_LOCK	(	cs,
		code
	)

Value:

    (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) {                          \
        LOCK(cs);                                                              \
        code;                                                                  \
    }())

Run code while locking a mutex.

Examples:

WITH_LOCK(cs, shared_val = shared_val + 1);

int val = WITH_LOCK(cs, return shared_val);

Note:

Since the return type deduction follows that of decltype(auto), while the deduced type of:

WITH_LOCK(cs, return {int i = 1; return i;});

is int, the deduced type of:

WITH_LOCK(cs, return {int j = 1; return (j);});

is &int, a reference to a local variable

The above is detectable at compile-time with the -Wreturn-local-addr flag in gcc and the -Wreturn-stack-address flag in clang, both enabled by default.

Definition at line 357 of file sync.h.

Typedef Documentation

◆ DebugLock

template<typename MutexArg >

using DebugLock = UniqueLock<typename std::remove_reference< typename std::remove_pointer<MutexArg>::type>::type>

Definition at line 270 of file sync.h.

◆ Mutex

using Mutex = AnnotatedMixin<std::mutex>

Wrapped mutex: supports waiting but not recursive locking.

Definition at line 132 of file sync.h.

◆ RecursiveMutex

using RecursiveMutex = AnnotatedMixin<std::recursive_mutex>

Wrapped mutex: supports recursive locking, but no waiting TODO: We should move away from using the recursive lock by default.

Definition at line 129 of file sync.h.

Function Documentation

◆ AssertLockHeldInternal()

template<typename MutexType >

void AssertLockHeldInternal	(	const char *	pszName,
		const char *	pszFile,
		int	nLine,
		MutexType *	cs
	)

inline

Definition at line 87 of file sync.h.

◆ AssertLockNotHeldInline() [1/2]

void AssertLockNotHeldInline	(	const char *	name,
		const char *	file,
		int	line,
		GlobalMutex *	cs
	)

inline

Definition at line 158 of file sync.h.

Here is the call graph for this function:

◆ AssertLockNotHeldInline() [2/2]

void AssertLockNotHeldInline	(	const char *	name,
		const char *	file,
		int	line,
		Mutex *	cs
	)

inline

Definition at line 148 of file sync.h.

Here is the call graph for this function: