sync.h File Reference

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

Include dependency graph for sync.h:

Go to the source code of this file.

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...

Macros
#define	AssertLockHeld(cs)
#define	AssertLockNotHeld(cs)
#define	REVERSE_LOCK(g, cs)
#define	LOCK(cs)
#define	LOCK2(cs1, cs2)
#define	LOCK_ARGS(cs)
#define	TRY_LOCK(cs, name)
#define	WAIT_LOCK(cs, name)
#define	WITH_LOCK(cs, code)

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.
using	Mutex = AnnotatedMixin<std::mutex>
	Wrapped mutex: supports waiting but not recursive locking.

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, RecursiveMutex *cs) LOCKS_EXCLUDED(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

)

Value:

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

Definition at line 136 of file sync.h.

AssertLockNotHeld

#define AssertLockNotHeld

(

cs

)

Value:

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

Definition at line 141 of file sync.h.

LOCK

#define LOCK

(

cs

)

Value:

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

Definition at line 258 of file sync.h.

LOCK2

#define LOCK2	(		cs1,
			cs2 )

Value:

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

Definition at line 259 of file sync.h.

LOCK_ARGS

#define LOCK_ARGS

(

cs

)

Value:

MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__

Definition at line 262 of file sync.h.

REVERSE_LOCK

#define REVERSE_LOCK	(		g,
			cs )

Value:

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

Definition at line 244 of file sync.h.

TRY_LOCK

#define TRY_LOCK	(		cs,
			name )

Value:

UniqueLock name(LOCK_ARGS(cs), true)

Definition at line 263 of file sync.h.

WAIT_LOCK

#define WAIT_LOCK	(		cs,
			name )

Value:

UniqueLock name(LOCK_ARGS(cs))

Definition at line 264 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, int i = 1; return i);

is int, the deduced type of:

WITH_LOCK(cs, 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 289 of file sync.h.

Typedef Documentation

Mutex

using Mutex = AnnotatedMixin<std::mutex>

Wrapped mutex: supports waiting but not recursive locking.

Definition at line 123 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 120 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 73 of file sync.h.

AssertLockNotHeldInline() [1/3]

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

inline

Definition at line 140 of file sync.h.

Here is the call graph for this function:

AssertLockNotHeldInline() [2/3]

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

inline

Definition at line 138 of file sync.h.

Here is the call graph for this function:

AssertLockNotHeldInline() [3/3]

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

inline

Definition at line 139 of file sync.h.

Here is the call graph for this function:

AssertLockNotHeldInternal()

template<typename MutexType>

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

Definition at line 75 of file sync.h.

Here is the caller graph for this function:

CheckLastCritical()

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

inline

Definition at line 71 of file sync.h.

Here is the caller graph for this function:

DeleteLock()

void DeleteLock ( void * cs )

inline

Definition at line 76 of file sync.h.

Here is the caller graph for this function:

EnterCritical()

template<typename MutexType>

void EnterCritical ( const char * pszName, const char * pszFile, int nLine, MutexType * cs, bool fTry = false )

inline

Definition at line 69 of file sync.h.

Here is the caller graph for this function:

LeaveCritical()

void LeaveCritical ( )

inline

Definition at line 70 of file sync.h.

Here is the caller graph for this function:

LockStackEmpty()

bool LockStackEmpty ( )

inline

Definition at line 77 of file sync.h.

MaybeCheckNotHeld() [1/4]

Mutex & MaybeCheckNotHeld ( Mutex & cs )

inline

Definition at line 248 of file sync.h.

MaybeCheckNotHeld() [2/4]

Mutex * MaybeCheckNotHeld ( Mutex * cs )

inline

Definition at line 249 of file sync.h.

MaybeCheckNotHeld() [3/4]

template<typename MutexType>

MutexType & MaybeCheckNotHeld ( MutexType & m )

inline

Definition at line 254 of file sync.h.

MaybeCheckNotHeld() [4/4]

template<typename MutexType>

MutexType * MaybeCheckNotHeld ( MutexType * m )

inline

Definition at line 256 of file sync.h.