Similar to std::condition_variable but with improvements for testing, support for monotonic clocks, and less buggy. More...

#include <ConditionVariable.h>

Public Member Functions
	ConditionVariable ()
	~ConditionVariable ()
void	notify_one ()
void	notify_all ()
void	wait (std::unique_lock< std::mutex > &lockGuard)
void	wait (std::unique_lock< Core::Mutex > &lockGuard)
void	wait_until (std::unique_lock< std::mutex > &lockGuard, const Core::Time::SteadyClock::time_point &abs_time)
template<typename Clock , typename Duration >
void	wait_until (std::unique_lock< std::mutex > &lockGuard, const std::chrono::time_point< Clock, Duration > &abs_time)
template<typename Clock , typename Duration >
void	wait_until (std::unique_lock< Core::Mutex > &lockGuard, const std::chrono::time_point< Clock, Duration > &abs_time)
Public Attributes
std::atomic< uint64_t >	notificationCount
	The number of times this condition variable has been notified.
Core::Time::SteadyClock::time_point	lastWaitUntil
	In the last call to wait_until, the timeout that the caller provided (in terms of SteadyClock).
Private Attributes
pthread_cond_t	cv
	Underlying condition variable.
std::function< void()>	callback
	This function will be called with the lock released during every invocation of wait/wait_until.

Detailed Description

Similar to std::condition_variable but with improvements for testing, support for monotonic clocks, and less buggy.

For testing, you can set a callback to be called when the condition variable is waited on; instead of waiting, this callback will be called. This callback can, for example, change some shared state so that the calling thread's condition is satisfied. It also counts how many times the condition variable has been notified.

The interface to this class is a subset of std::condition_variable:

wait_for isn't exposed since it doesn't make much sense to me in light of spurious interrupts.
wait_until returns void instead of cv_status since it's almost always clearer to check whether timeout has elapsed explicitly. Also, gcc 4.4 doesn't have cv_status and uses bool instead.

This class also goes through some trouble so that it can be used with std::unique_lock<Core::Mutex>, since normal condition variables may only be used with std::unique_lock<std::mutex>.

All waiting on this class is done using a monotonic clock internally, so it will not be affected by time jumps from, e.g., NTP. This implies that, if you're actually waiting for a specific system time to come around, you might end up with surprising behavior. If you're wondering why, Linux/POSIX condition variables use a single clock for all waiters, whereas C++11 uses an impossible-to-implement interface where different waiters can use different clocks.

Definition at line 59 of file ConditionVariable.h.

Constructor & Destructor Documentation

LogCabin::Core::ConditionVariable::ConditionVariable ( )

Definition at line 25 of file ConditionVariable.cc.

LogCabin::Core::ConditionVariable::~ConditionVariable ( )

Definition at line 50 of file ConditionVariable.cc.

Member Function Documentation

void LogCabin::Core::ConditionVariable::notify_one ( )

Definition at line 58 of file ConditionVariable.cc.

void LogCabin::Core::ConditionVariable::notify_all ( )

Definition at line 67 of file ConditionVariable.cc.

void LogCabin::Core::ConditionVariable::wait ( std::unique_lock< std::mutex > & lockGuard )

Definition at line 76 of file ConditionVariable.cc.

void LogCabin::Core::ConditionVariable::wait ( std::unique_lock< Core::Mutex > & lockGuard )

Definition at line 91 of file ConditionVariable.cc.

void LogCabin::Core::ConditionVariable::wait_until	(	std::unique_lock< std::mutex > &	lockGuard,
		const Core::Time::SteadyClock::time_point &	abs_time
	)

Definition at line 109 of file ConditionVariable.cc.

template<typename Clock , typename Duration >

void LogCabin::Core::ConditionVariable::wait_until	(	std::unique_lock< std::mutex > &	lockGuard,
		const std::chrono::time_point< Clock, Duration > &	abs_time
	)		`[inline]`

Definition at line 76 of file ConditionVariable.h.

template<typename Clock , typename Duration >

void LogCabin::Core::ConditionVariable::wait_until	(	std::unique_lock< Core::Mutex > &	lockGuard,
		const std::chrono::time_point< Clock, Duration > &	abs_time
	)		`[inline]`