#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< MutexType >
	Wrapper around std::unique_lock style lock for MutexType. More...

class	UniqueLock< MutexType >::reverse_lock
	An RAII-style reverse lock. More...

class	CSemaphore
	An implementation of a semaphore. More...

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) typename std::decay<decltype(g)>::type::reverse_lock UNIQUE_NAME(revlock)(g, #g, __FILE__, __LINE__)

#define	LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

#define	LOCK2(cs1, cs2)

#define	TRY_LOCK(cs, name) UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__, true)

#define	WAIT_LOCK(cs, name) UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

#define	ENTER_CRITICAL_SECTION(cs)

#define	LEAVE_CRITICAL_SECTION(cs)

#define	WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { 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...

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)

template<typename MutexType >
MutexType &	MaybeCheckNotHeld (MutexType &m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m)

template<typename MutexType >
MutexType *	MaybeCheckNotHeld (MutexType *m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m)

Macro Definition Documentation

◆ AssertLockHeld

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

Definition at line 142 of file sync.h.

◆ AssertLockNotHeld

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

Definition at line 147 of file sync.h.

◆ ENTER_CRITICAL_SECTION

#define ENTER_CRITICAL_SECTION ( cs )

Value:

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

Definition at line 264 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 270 of file sync.h.

◆ LOCK

#define LOCK ( cs ) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

Definition at line 257 of file sync.h.

◆ LOCK2

#define LOCK2	(	cs1,
		cs2
	)

Value:

UniqueLock criticalblock1(MaybeCheckNotHeld(cs1), #cs1, __FILE__, __LINE__); \

UniqueLock criticalblock2(MaybeCheckNotHeld(cs2), #cs2, __FILE__, __LINE__)

UniqueLock

Wrapper around std::unique_lock style lock for MutexType.

Definition: sync.h:152

MaybeCheckNotHeld

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

Definition: sync.h:247

Definition at line 258 of file sync.h.

◆ REVERSE_LOCK

#define REVERSE_LOCK ( g ) typename std::decay<decltype(g)>::type::reverse_lock UNIQUE_NAME(revlock)(g, #g, __FILE__, __LINE__)

Definition at line 243 of file sync.h.

◆ TRY_LOCK

#define TRY_LOCK	(	cs,
		name
	)	UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__, true)

Definition at line 261 of file sync.h.

◆ WAIT_LOCK

#define WAIT_LOCK	(	cs,
		name
	)	UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)

Definition at line 262 of file sync.h.

◆ WITH_LOCK

#define WITH_LOCK	(	cs,
		code
	)	(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 301 of file sync.h.

Typedef Documentation

◆ Mutex

using Mutex = AnnotatedMixin<std::mutex>

Wrapped mutex: supports waiting but not recursive locking.

Definition at line 129 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 126 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 79 of file sync.h.

◆ AssertLockNotHeldInline() [1/2]

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

inline

Definition at line 146 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 144 of file sync.h.

Here is the call graph for this function: