#include <threadsafety.h>
#include <util/macros.h>
#include <cassert>
#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...

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

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

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

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

#define	LOCK2(cs1, cs2)

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

#define	TRY_LOCK(cs, name) UniqueLock name(LOCK_ARGS(cs), true)

#define	WAIT_LOCK(cs, name) UniqueLock name(LOCK_ARGS(cs))

#define	WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
	Run code while locking a mutex.

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, 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 136 of file sync.h.

◆ AssertLockNotHeld

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

Definition at line 141 of file sync.h.

◆ LOCK

#define LOCK ( cs ) 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__)

UniqueLock

Wrapper around std::unique_lock style lock for MutexType.

Definition sync.h:146

MaybeCheckNotHeld

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

Definition sync.h:248

Ticks

constexpr auto Ticks(Dur2 d)

Helper to count the seconds of a duration/time_point.

Definition time.h:73

Definition at line 259 of file sync.h.

◆ LOCK_ARGS

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

Definition at line 262 of file sync.h.

◆ REVERSE_LOCK

#define REVERSE_LOCK	(		g,
			cs ) 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 ) UniqueLock name(LOCK_ARGS(cs), true)

Definition at line 263 of file sync.h.

◆ WAIT_LOCK

#define WAIT_LOCK	(		cs,
			name ) UniqueLock name(LOCK_ARGS(cs))

Definition at line 264 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, 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/2]

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/2]

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: