sync.h File Reference

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

Include dependency graph for sync.h:

This graph shows which files directly or indirectly include this file:

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	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)   AssertLockNotHeldInternal(#cs, __FILE__, __LINE__, &cs)
#define	REVERSE_LOCK(g)   typename std::decay<decltype(g)>::type::reverse_lock PASTE2(revlock, __COUNTER__)(g, #g, __FILE__, __LINE__)
#define	LOCK(cs)   DebugLock<decltype(cs)> PASTE2(criticalblock, __COUNTER__)(cs, #cs, __FILE__, __LINE__)
#define	LOCK2(cs1, cs2)
#define	TRY_LOCK(cs, name)   DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__, true)
#define	WAIT_LOCK(cs, name)   DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__)
#define	ENTER_CRITICAL_SECTION(cs)
#define	LEAVE_CRITICAL_SECTION(cs)
#define	WITH_LOCK(cs, code)   [&]() -> 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...
typedef AnnotatedMixin< std::mutex >	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 ()

Macro Definition Documentation

AssertLockHeld

#define AssertLockHeld

(

cs

)

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

Definition at line 83 of file sync.h.

AssertLockNotHeld

#define AssertLockNotHeld

(

cs

)

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

Definition at line 84 of file sync.h.

ENTER_CRITICAL_SECTION

#define ENTER_CRITICAL_SECTION

(

cs

)

Value:

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

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

LOCK

#define LOCK

(

cs

)

DebugLock<decltype(cs)> PASTE2(criticalblock, __COUNTER__)(cs, #cs, __FILE__, __LINE__)

Definition at line 226 of file sync.h.

LOCK2

#define LOCK2	(		cs1,
			cs2
	)

Value:

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

Definition at line 227 of file sync.h.

REVERSE_LOCK

#define REVERSE_LOCK

(

g

)

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

Definition at line 221 of file sync.h.

TRY_LOCK

#define TRY_LOCK	(		cs,
			name
	)		DebugLock<decltype(cs)> name(cs, #cs, __FILE__, __LINE__, true)

Definition at line 230 of file sync.h.

WAIT_LOCK

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

Definition at line 231 of file sync.h.

WITH_LOCK

#define WITH_LOCK	(		cs,
			code
	)		[&]() -> 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 270 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 224 of file sync.h.

Mutex

typedef AnnotatedMixin<std::mutex> 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 77 of file sync.h.

AssertLockNotHeldInternal()

template<typename MutexType >

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

Definition at line 79 of file sync.h.

CheckLastCritical()

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

inline

Definition at line 75 of file sync.h.

Here is the caller graph for this function:

DeleteLock()

void DeleteLock ( void *  cs )

inline

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

Here is the caller graph for this function:

LeaveCritical()

void LeaveCritical ( )

inline

Definition at line 74 of file sync.h.

Here is the caller graph for this function:

LockStackEmpty()

bool LockStackEmpty ( )

inline

Definition at line 81 of file sync.h.