Skip to content

FORMUS3IC_LAS3 / embb

Go to a project
Commit ae2f1813 by Danila Klimenko
Options

Readers-writers lock: updated interface to match C++14 standard

parent a257320c
Expand all
Inline Side-by-side
Showing with 473 additions and 310 deletions
base_c/include/embb/base/c/base.h
...@@ -55,6 +55,6 @@ ...@@ -55,6 +55,6 @@
#include <embb/base/c/thread.h> #include <embb/base/c/thread.h>
#include <embb/base/c/thread_specific_storage.h> #include <embb/base/c/thread_specific_storage.h>
#include <embb/base/c/time.h> #include <embb/base/c/time.h>
#include <embb/base/c/rwlock.h> #include <embb/base/c/shared_mutex.h>
#endif /* EMBB_BASE_C_BASE_H_ */ #endif /* EMBB_BASE_C_BASE_H_ */
base_c/include/embb/base/c/internal/platform.h
...@@ -66,7 +66,7 @@ typedef struct embb_thread_t { ...@@ -66,7 +66,7 @@ typedef struct embb_thread_t {
typedef DWORD embb_thread_id_t; typedef DWORD embb_thread_id_t;
typedef CRITICAL_SECTION embb_mutex_t; typedef CRITICAL_SECTION embb_mutex_t;
typedef CONDITION_VARIABLE embb_condition_t; typedef CONDITION_VARIABLE embb_condition_t;
typedef SRWLOCK embb_rwlock_t; typedef SRWLOCK embb_shared_mutex_t;
#define EMBB_DURATION_MIN_NANOSECONDS 1000 #define EMBB_DURATION_MIN_NANOSECONDS 1000
...@@ -91,7 +91,7 @@ typedef struct embb_thread_t { ...@@ -91,7 +91,7 @@ typedef struct embb_thread_t {
typedef pthread_t embb_thread_id_t; typedef pthread_t embb_thread_id_t;
typedef pthread_mutex_t embb_mutex_t; typedef pthread_mutex_t embb_mutex_t;
typedef pthread_cond_t embb_condition_t; typedef pthread_cond_t embb_condition_t;
typedef pthread_rwlock_t embb_rwlock_t; typedef pthread_rwlock_t embb_shared_mutex_t;
#define EMBB_DURATION_MIN_NANOSECONDS 1 #define EMBB_DURATION_MIN_NANOSECONDS 1
......
base_c/include/embb/base/c/rwlock.h → base_c/include/embb/base/c/shared_mutex.h
...@@ -24,16 +24,19 @@ ...@@ -24,16 +24,19 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef EMBB_BASE_C_RWLOCK_H_ #ifndef EMBB_BASE_C_SHARED_MUTEX_H_
#define EMBB_BASE_C_RWLOCK_H_ #define EMBB_BASE_C_SHARED_MUTEX_H_
/** /**
* \defgroup C_BASE_RWLOCK Readers-Writers Lock * \defgroup C_BASE_SHARED_MUTEX Shared mutex
* *
* Shared-read/exclusive-write lock for thread synchronization * Shared mutexes for thread synchronization
* *
* Provides an abstraction from platform-specific readers-writers lock * Provides an abstraction from platform-specific shared mutex implementations.
* implementations. * Shared mutexes provide two levels of access: exclusive access - only one
* thread can own the mutex; shared access - several threads can share ownership
* of the same mutex. Shared mutexes facilitate the "single writer, multiple
* readers" scenarios.
* *
* \ingroup C_BASE * \ingroup C_BASE
* \{ * \{
...@@ -48,139 +51,139 @@ extern "C" { ...@@ -48,139 +51,139 @@ extern "C" {
#ifdef DOXYGEN #ifdef DOXYGEN
/** /**
* Opaque type representing an rwlock. * Opaque type representing a shared mutex.
*/ */
typedef opaque_type embb_rwlock_t; typedef opaque_type embb_shared_mutex_t;
#endif // DOXYGEN #endif // DOXYGEN
/** /**
* Initializes an rwlock * Initializes a shared mutex
* *
* \post \c rwlock is initialized * \post \c shared_mutex is initialized
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if rwlock could be initialized \n * \return EMBB_SUCCESS if shared mutex could be initialized \n
* EMBB_ERROR otherwise * EMBB_ERROR otherwise
* *
* \memory (Potentially) allocates dynamic memory * \memory (Potentially) allocates dynamic memory
* *
* \notthreadsafe * \notthreadsafe
* *
* \see embb_rwlock_destroy() * \see embb_shared_mutex_destroy()
*/ */
int embb_rwlock_init(embb_rwlock_t* rwlock); int embb_shared_mutex_init(embb_shared_mutex_t* shared_mutex);
/** /**
* Waits until the rwlock can be locked for reading and locks it. * Waits until the shared mutex can be locked for writing and locks it.
* *
* \pre \c rwlock is initialized and not locked by the current thread. * \pre \c shared_mutex is initialized and not locked by the current thread.
* \post If successful, \c rwlock is locked for reading. * \post If successful, \c shared_mutex is locked for writing.
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if rwlock could be locked for reading \n * \return EMBB_SUCCESS if shared_mutex could be locked for writing \n
* EMBB_ERROR otherwise * EMBB_ERROR otherwise
* *
* \threadsafe * \threadsafe
* *
* \see embb_rwlock_try_lock_read(), embb_rwlock_unlock_read() * \see embb_shared_mutex_try_lock(), embb_shared_mutex_unlock()
*/ */
int embb_rwlock_lock_read(embb_rwlock_t* rwlock); int embb_shared_mutex_lock(embb_shared_mutex_t* shared_mutex);
/** /**
* Waits until the rwlock can be locked for writing and locks it. * Tries to lock the shared mutex for writing and returns immediately.
* *
* \pre \c rwlock is initialized and not locked by the current thread. * \pre \c shared_mutex is initialized
* \post If successful, \c rwlock is locked for writing. * \post If successful, \c shared_mutex is locked for writing
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if rwlock could be locked for writing \n * \return EMBB_SUCCESS if shared_mutex could be locked for writing \n
* EMBB_ERROR otherwise * EMBB_BUSY if shared_mutex could not be locked for writing \n
* EMBB_ERROR if an error occurred
* *
* \threadsafe * \threadsafe
* *
* \see embb_rwlock_try_lock_write(), embb_rwlock_unlock_write() * \see embb_shared_mutex_lock(), embb_shared_mutex_unlock()
*/ */
int embb_rwlock_lock_write(embb_rwlock_t* rwlock); int embb_shared_mutex_try_lock(embb_shared_mutex_t* shared_mutex);
/** /**
* Tries to lock the rwlock for reading and returns immediately. * Unlocks the shared mutex locked for writing.
* *
* \pre \c rwlock is initialized * \pre \c shared_mutex has been locked for writing by the current thread.
* \post If successful, \c rwlock is locked for reading * \post If successful, \c shared_mutex is unlocked.
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if rwlock could be locked for reading \n * \return EMBB_SUCCESS if the operation was successful \n
* EMBB_BUSY if rwlock could not be locked for reading \n * EMBB_ERROR otherwise
* EMBB_ERROR if an error occurred
* *
* \threadsafe * \threadsafe
* *
* \see embb_rwlock_lock_read(), embb_rwlock_unlock_read() * \see embb_shared_mutex_lock(), embb_shared_mutex_try_lock()
*/ */
int embb_rwlock_try_lock_read(embb_rwlock_t* rwlock); int embb_shared_mutex_unlock(embb_shared_mutex_t* shared_mutex);
/** /**
* Tries to lock the rwlock for writing and returns immediately. * Waits until the shared mutex can be locked for reading and locks it.
* *
* \pre \c rwlock is initialized * \pre \c shared_mutex is initialized and not locked by the current thread.
* \post If successful, \c rwlock is locked for writing * \post If successful, \c shared_mutex is locked for reading.
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if rwlock could be locked for writing \n * \return EMBB_SUCCESS if shared_mutex could be locked for reading \n
* EMBB_BUSY if rwlock could not be locked for writing \n * EMBB_ERROR otherwise
* EMBB_ERROR if an error occurred
* *
* \threadsafe * \threadsafe
* *
* \see embb_rwlock_lock_write(), embb_rwlock_unlock_write() * \see embb_shared_mutex_try_lock_shared(), embb_shared_mutex_unlock_shared()
*/ */
int embb_rwlock_try_lock_write(embb_rwlock_t* rwlock); int embb_shared_mutex_lock_shared(embb_shared_mutex_t* shared_mutex);
/** /**
* Unlocks an rwlock locked for reading. * Tries to lock the shared mutex for reading and returns immediately.
* *
* \pre \c rwlock has been locked for reading by the current thread. * \pre \c shared_mutex is initialized
* \post If successful, \c rwlock is unlocked. * \post If successful, \c shared_mutex is locked for reading
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if the operation was successful \n * \return EMBB_SUCCESS if shared_mutex could be locked for reading \n
* EMBB_ERROR otherwise * EMBB_BUSY if shared_mutex could not be locked for reading \n
* EMBB_ERROR if an error occurred
* *
* \threadsafe * \threadsafe
* *
* \see embb_rwlock_lock_read(), embb_rwlock_try_lock_read() * \see embb_shared_mutex_lock_shared(), embb_shared_mutex_unlock_shared()
*/ */
int embb_rwlock_unlock_read(embb_rwlock_t* rwlock); int embb_shared_mutex_try_lock_shared(embb_shared_mutex_t* shared_mutex);
/** /**
* Unlocks an rwlock locked for writing. * Unlocks the shared mutex locked for reading.
* *
* \pre \c rwlock has been locked for writing by the current thread. * \pre \c shared_mutex has been locked for reading by the current thread.
* \post If successful, \c rwlock is unlocked. * \post If successful, \c shared_mutex is unlocked.
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* \return EMBB_SUCCESS if the operation was successful \n * \return EMBB_SUCCESS if the operation was successful \n
* EMBB_ERROR otherwise * EMBB_ERROR otherwise
* *
* \threadsafe * \threadsafe
* *
* \see embb_rwlock_lock_write(), embb_rwlock_try_lock_write() * \see embb_shared_mutex_lock_shared(), embb_shared_mutex_try_lock_shared()
*/ */
int embb_rwlock_unlock_write(embb_rwlock_t* rwlock); int embb_shared_mutex_unlock_shared(embb_shared_mutex_t* shared_mutex);
/** /**
* Destroys an rwlock and frees its resources. * Destroys the shared mutex and frees its resources.
* *
* \pre \c rwlock has been initialized * \pre \c shared_mutex has been initialized
* \post \c rwlock is uninitialized * \post \c shared_mutex is uninitialized
* *
* \param rwlock Pointer to rwlock * \param shared_mutex Pointer to shared mutex
* *
* \notthreadsafe * \notthreadsafe
* *
* \see embb_rwlock_init() * \see embb_shared_mutex_init()
*/ */
void embb_rwlock_destroy(embb_rwlock_t* rwlock); void embb_shared_mutex_destroy(embb_shared_mutex_t* shared_mutex);
#ifdef __cplusplus #ifdef __cplusplus
} // Close extern "C" } // Close extern "C"
...@@ -190,4 +193,4 @@ void embb_rwlock_destroy(embb_rwlock_t* rwlock); ...@@ -190,4 +193,4 @@ void embb_rwlock_destroy(embb_rwlock_t* rwlock);
* \} * \}
*/ */
#endif // EMBB_BASE_C_RWLOCK_H_ #endif // EMBB_BASE_C_SHARED_MUTEX_H_
base_c/src/rwlock.c → base_c/src/shared_mutex.c
...@@ -24,87 +24,79 @@ ...@@ -24,87 +24,79 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <embb/base/c/rwlock.h> #include <embb/base/c/shared_mutex.h>
#include <assert.h> #include <assert.h>
#include <embb/base/c/internal/unused.h> #include <embb/base/c/internal/unused.h>
#ifdef EMBB_PLATFORM_THREADING_WINTHREADS #ifdef EMBB_PLATFORM_THREADING_WINTHREADS
int embb_rwlock_init(embb_rwlock_t* rwlock) { int embb_shared_mutex_init(embb_shared_mutex_t* shared_mutex) {
InitializeSRWLock(rwlock); InitializeSRWLock(shared_mutex);
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_lock_read(embb_rwlock_t* rwlock) { int embb_shared_mutex_lock(embb_shared_mutex_t* shared_mutex) {
AcquireSRWLockShared(rwlock); AcquireSRWLockExclusive(shared_mutex);
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_lock_write(embb_rwlock_t* rwlock) { int embb_shared_mutex_try_lock(embb_shared_mutex_t* shared_mutex) {
AcquireSRWLockExclusive(rwlock); BOOLEAN success;
success = TryAcquireSRWLockExclusive(shared_mutex);
if (success == FALSE) return EMBB_ERROR;
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_try_lock_read(embb_rwlock_t* rwlock) { int embb_shared_mutex_unlock(embb_shared_mutex_t* shared_mutex) {
BOOLEAN success; ReleaseSRWLockExclusive(shared_mutex);
success = TryAcquireSRWLockShared(rwlock);
if (success == FALSE) return EMBB_ERROR;
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_try_lock_write(embb_rwlock_t* rwlock) { int embb_shared_mutex_lock_shared(embb_shared_mutex_t* shared_mutex) {
BOOLEAN success; AcquireSRWLockShared(shared_mutex);
success = TryAcquireSRWLockExclusive(rwlock);
if (success == FALSE) return EMBB_ERROR;
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_unlock_read(embb_rwlock_t* rwlock) { int embb_shared_mutex_try_lock_shared(embb_shared_mutex_t* shared_mutex) {
ReleaseSRWLockShared(rwlock); BOOLEAN success;
success = TryAcquireSRWLockShared(shared_mutex);
if (success == FALSE) return EMBB_ERROR;
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_unlock_write(embb_rwlock_t* rwlock) { int embb_shared_mutex_unlock_shared(embb_shared_mutex_t* shared_mutex) {
ReleaseSRWLockExclusive(rwlock); ReleaseSRWLockShared(shared_mutex);
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
void embb_rwlock_destroy(embb_rwlock_t* rwlock) { void embb_shared_mutex_destroy(embb_shared_mutex_t* shared_mutex) {
// Quoting MSDN: "SRW locks do not need to be explicitly destroyed". // Quoting MSDN: "SRW locks do not need to be explicitly destroyed".
EMBB_UNUSED(rwlock); EMBB_UNUSED(shared_mutex);
} }
#endif /* EMBB_PLATFORM_THREADING_WINTHREADS */ #endif /* EMBB_PLATFORM_THREADING_WINTHREADS */
#ifdef EMBB_PLATFORM_THREADING_POSIXTHREADS #ifdef EMBB_PLATFORM_THREADING_POSIXTHREADS
int embb_rwlock_init(embb_rwlock_t* rwlock) { int embb_shared_mutex_init(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_init(rwlock, NULL); int result = pthread_rwlock_init(shared_mutex, NULL);
if (result != 0) { if (result != 0) {
return EMBB_ERROR; return EMBB_ERROR;
} }
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_lock_read(embb_rwlock_t* rwlock) { int embb_shared_mutex_lock(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_rdlock(rwlock); int result = pthread_rwlock_wrlock(shared_mutex);
if (result != 0) { if (result != 0) {
return EMBB_ERROR; return EMBB_ERROR;
} }
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_lock_write(embb_rwlock_t* rwlock) { int embb_shared_mutex_try_lock(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_wrlock(rwlock); int result = pthread_rwlock_trywrlock(shared_mutex);
if (result != 0) {
return EMBB_ERROR;
}
return EMBB_SUCCESS;
}
int embb_rwlock_try_lock_read(embb_rwlock_t* rwlock) {
int result = pthread_rwlock_tryrdlock(rwlock);
if (result == 0) { if (result == 0) {
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
...@@ -114,35 +106,43 @@ int embb_rwlock_try_lock_read(embb_rwlock_t* rwlock) { ...@@ -114,35 +106,43 @@ int embb_rwlock_try_lock_read(embb_rwlock_t* rwlock) {
return EMBB_ERROR; return EMBB_ERROR;
} }
int embb_rwlock_try_lock_write(embb_rwlock_t* rwlock) { int embb_shared_mutex_unlock(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_trywrlock(rwlock); int result = pthread_rwlock_unlock(shared_mutex);
if (result == 0) { if (result != 0) {
return EMBB_SUCCESS; return EMBB_ERROR;
}
if (result == EBUSY) {
return EMBB_BUSY;
} }
return EMBB_ERROR; return EMBB_SUCCESS;
} }
int embb_rwlock_unlock_read(embb_rwlock_t* rwlock) { int embb_shared_mutex_lock_shared(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_unlock(rwlock); int result = pthread_rwlock_rdlock(shared_mutex);
if (result != 0) { if (result != 0) {
return EMBB_ERROR; return EMBB_ERROR;
} }
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
int embb_rwlock_unlock_write(embb_rwlock_t* rwlock) { int embb_shared_mutex_try_lock_shared(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_unlock(rwlock); int result = pthread_rwlock_tryrdlock(shared_mutex);
if (result == 0) {
return EMBB_SUCCESS;
}
if (result == EBUSY) {
return EMBB_BUSY;
}
return EMBB_ERROR;
}
int embb_shared_mutex_unlock_shared(embb_shared_mutex_t* shared_mutex) {
int result = pthread_rwlock_unlock(shared_mutex);
if (result != 0) { if (result != 0) {
return EMBB_ERROR; return EMBB_ERROR;
} }
return EMBB_SUCCESS; return EMBB_SUCCESS;
} }
void embb_rwlock_destroy(embb_rwlock_t* rwlock) { void embb_shared_mutex_destroy(embb_shared_mutex_t* shared_mutex) {
pthread_rwlock_destroy(rwlock); pthread_rwlock_destroy(shared_mutex);
} }
#endif /* EMBB_PLATFORM_THREADING_POSIXTHREADS */ #endif /* EMBB_PLATFORM_THREADING_POSIXTHREADS */
base_c/test/main.cc
...@@ -35,7 +35,7 @@ ...@@ -35,7 +35,7 @@
#include <condition_var_test.h> #include <condition_var_test.h>
#include <thread_test.h> #include <thread_test.h>
#include <thread_specific_storage_test.h> #include <thread_specific_storage_test.h>
#include <rwlock_test.h> #include <shared_mutex_test.h>
#include <embb/base/c/thread.h> #include <embb/base/c/thread.h>
#include <embb/base/c/log.h> #include <embb/base/c/log.h>
#include <iostream> #include <iostream>
...@@ -52,7 +52,7 @@ using embb::base::test::CoreSetTest; ...@@ -52,7 +52,7 @@ using embb::base::test::CoreSetTest;
using embb::base::test::ConditionVarTest; using embb::base::test::ConditionVarTest;
using embb::base::test::ThreadTest; using embb::base::test::ThreadTest;
using embb::base::test::ThreadSpecificStorageTest; using embb::base::test::ThreadSpecificStorageTest;
using embb::base::test::RWLockTest; using embb::base::test::SharedMutexTest;
PT_MAIN("Base C") { PT_MAIN("Base C") {
embb_log_set_log_level(EMBB_LOG_LEVEL_WARNING); embb_log_set_log_level(EMBB_LOG_LEVEL_WARNING);
...@@ -70,7 +70,7 @@ PT_MAIN("Base C") { ...@@ -70,7 +70,7 @@ PT_MAIN("Base C") {
PT_RUN(ConditionVarTest); PT_RUN(ConditionVarTest);
PT_RUN(ThreadTest); PT_RUN(ThreadTest);
PT_RUN(ThreadSpecificStorageTest); PT_RUN(ThreadSpecificStorageTest);
PT_RUN(RWLockTest); PT_RUN(SharedMutexTest);
PT_EXPECT(embb_get_bytes_allocated() == 0); PT_EXPECT(embb_get_bytes_allocated() == 0);
} }
base_c/test/rwlock_test.cc → base_c/test/shared_mutex_test.cc
...@@ -24,85 +24,85 @@ ...@@ -24,85 +24,85 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <rwlock_test.h> #include <shared_mutex_test.h>
#include <embb/base/c/errors.h> #include <embb/base/c/errors.h>
namespace embb { namespace embb {
namespace base { namespace base {
namespace test { namespace test {
RWLockTest::RWLockTest() SharedMutexTest::SharedMutexTest()
: counter_(0), : counter_(0),
num_threads_(partest::TestSuite::GetDefaultNumThreads()), num_threads_(partest::TestSuite::GetDefaultNumThreads()),
num_iterations_(partest::TestSuite::GetDefaultNumIterations()) { num_iterations_(partest::TestSuite::GetDefaultNumIterations()) {
CreateUnit("Shared read") CreateUnit("Shared read")
.Pre(&RWLockTest::TestSharedRead_Pre, this) .Pre(&SharedMutexTest::TestSharedRead_Pre, this)
.Add(&RWLockTest::TestSharedRead_ThreadMethod, this, .Add(&SharedMutexTest::TestSharedRead_ThreadMethod, this,
num_threads_, num_iterations_) num_threads_, num_iterations_)
.Post(&RWLockTest::TestSharedRead_Post, this); .Post(&SharedMutexTest::TestSharedRead_Post, this);
CreateUnit("Exclusive write") CreateUnit("Exclusive write")
.Pre(&RWLockTest::TestExclusiveWrite_Pre, this) .Pre(&SharedMutexTest::TestExclusiveWrite_Pre, this)
.Add(&RWLockTest::TestExclusiveWrite_ReaderMethod, this, .Add(&SharedMutexTest::TestExclusiveWrite_ReaderMethod, this,
num_threads_, num_iterations_) num_threads_ / 2, num_iterations_)
.Add(&RWLockTest::TestExclusiveWrite_WriterMethod, this, .Add(&SharedMutexTest::TestExclusiveWrite_WriterMethod, this,
num_threads_, num_iterations_) num_threads_ / 2, num_iterations_)
.Post(&RWLockTest::TestExclusiveWrite_Post, this); .Post(&SharedMutexTest::TestExclusiveWrite_Post, this);
} }
void RWLockTest::TestSharedRead_Pre() { void SharedMutexTest::TestSharedRead_Pre() {
int success = embb_rwlock_init(&rwlock_); int success = embb_shared_mutex_init(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to initialize rwlock."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to initialize shared mutex.");
} }
void RWLockTest::TestSharedRead_ThreadMethod() { void SharedMutexTest::TestSharedRead_ThreadMethod() {
int success = embb_rwlock_try_lock_read(&rwlock_); int success = embb_shared_mutex_try_lock_shared(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to lock for reading."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to lock for reading.");
int spin = 10000; int spin = 10000;
while (--spin != 0); while (--spin != 0);
success = embb_rwlock_unlock_read(&rwlock_); success = embb_shared_mutex_unlock_shared(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to unlock (reading)."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to unlock (reading).");
} }
void RWLockTest::TestSharedRead_Post() { void SharedMutexTest::TestSharedRead_Post() {
embb_rwlock_destroy(&rwlock_); embb_shared_mutex_destroy(&shared_mutex_);
} }
void RWLockTest::TestExclusiveWrite_Pre() { void SharedMutexTest::TestExclusiveWrite_Pre() {
int success = embb_rwlock_init(&rwlock_); int success = embb_shared_mutex_init(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to initialize rwlock."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to initialize shared mutex.");
counter_ = 0; counter_ = 0;
} }
void RWLockTest::TestExclusiveWrite_ReaderMethod() { void SharedMutexTest::TestExclusiveWrite_ReaderMethod() {
// Just add some contention // Just add some contention
int success = embb_rwlock_try_lock_read(&rwlock_); int success = embb_shared_mutex_try_lock_shared(&shared_mutex_);
if (success != EMBB_SUCCESS) return; if (success != EMBB_SUCCESS) return;
int spin = 10000; int spin = 10000;
while (--spin != 0); while (--spin != 0);
success = embb_rwlock_unlock_read(&rwlock_); success = embb_shared_mutex_unlock_shared(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to unlock (reading)."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to unlock (reading).");
} }
void RWLockTest::TestExclusiveWrite_WriterMethod() { void SharedMutexTest::TestExclusiveWrite_WriterMethod() {
int success = embb_rwlock_lock_write(&rwlock_); int success = embb_shared_mutex_lock(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to lock for writing."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to lock for writing.");
++counter_; ++counter_;
success = embb_rwlock_unlock_write(&rwlock_); success = embb_shared_mutex_unlock(&shared_mutex_);
PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to unlock (writing)."); PT_ASSERT_EQ_MSG(success, EMBB_SUCCESS, "Failed to unlock (writing).");
} }
void RWLockTest::TestExclusiveWrite_Post() { void SharedMutexTest::TestExclusiveWrite_Post() {
PT_ASSERT_EQ_MSG(counter_, num_iterations_ * num_threads_, PT_ASSERT_EQ_MSG(counter_, num_iterations_ * (num_threads_ / 2),
"Counter value is inconsistent."); "Counter value is inconsistent.");
embb_rwlock_destroy(&rwlock_); embb_shared_mutex_destroy(&shared_mutex_);
} }
} // namespace test } // namespace test
......
base_c/test/rwlock_test.h → base_c/test/shared_mutex_test.h
...@@ -24,21 +24,21 @@ ...@@ -24,21 +24,21 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef BASE_C_TEST_RWLOCK_TEST_H_ #ifndef BASE_C_TEST_SHARED_MUTEX_TEST_H_
#define BASE_C_TEST_RWLOCK_TEST_H_ #define BASE_C_TEST_SHARED_MUTEX_TEST_H_
#include <partest/partest.h> #include <partest/partest.h>
#include <embb/base/c/internal/platform.h> #include <embb/base/c/internal/platform.h>
#include <embb/base/c/rwlock.h> #include <embb/base/c/shared_mutex.h>
namespace embb { namespace embb {
namespace base { namespace base {
namespace test { namespace test {
class RWLockTest : public partest::TestCase { class SharedMutexTest : public partest::TestCase {
public: public:
RWLockTest(); SharedMutexTest();
private: private:
void TestSharedRead_Pre(); void TestSharedRead_Pre();
...@@ -50,7 +50,7 @@ class RWLockTest : public partest::TestCase { ...@@ -50,7 +50,7 @@ class RWLockTest : public partest::TestCase {
void TestExclusiveWrite_WriterMethod(); void TestExclusiveWrite_WriterMethod();
void TestExclusiveWrite_Post(); void TestExclusiveWrite_Post();
embb_rwlock_t rwlock_; embb_shared_mutex_t shared_mutex_;
size_t counter_; size_t counter_;
size_t num_threads_; size_t num_threads_;
size_t num_iterations_; size_t num_iterations_;
...@@ -60,4 +60,4 @@ class RWLockTest : public partest::TestCase { ...@@ -60,4 +60,4 @@ class RWLockTest : public partest::TestCase {
} // namespace base } // namespace base
} // namespace embb } // namespace embb
#endif // BASE_C_TEST_RWLOCK_TEST_H_ #endif // BASE_C_TEST_SHARED_MUTEX_TEST_H_
base_cpp/include/embb/base/base.h
...@@ -59,6 +59,6 @@ ...@@ -59,6 +59,6 @@
#include <embb/base/thread.h> #include <embb/base/thread.h>
#include <embb/base/thread_specific_storage.h> #include <embb/base/thread_specific_storage.h>
#include <embb/base/time.h> #include <embb/base/time.h>
#include <embb/base/rwlock.h> #include <embb/base/shared_mutex.h>
#endif // EMBB_BASE_BASE_H_ #endif // EMBB_BASE_BASE_H_
base_cpp/include/embb/base/internal/platform.h
...@@ -44,7 +44,7 @@ typedef embb_thread_t ThreadType; ...@@ -44,7 +44,7 @@ typedef embb_thread_t ThreadType;
typedef DWORD IDType; typedef DWORD IDType;
typedef embb_mutex_t MutexType; typedef embb_mutex_t MutexType;
typedef embb_condition_t ConditionVariableType; typedef embb_condition_t ConditionVariableType;
typedef embb_rwlock_t RWLockType; typedef embb_shared_mutex_t SharedMutexType;
} // namespace internal } // namespace internal
} // namespace base } // namespace base
...@@ -60,7 +60,7 @@ typedef embb_thread_t ThreadType; ...@@ -60,7 +60,7 @@ typedef embb_thread_t ThreadType;
typedef embb_thread_id_t IDType; typedef embb_thread_id_t IDType;
typedef embb_mutex_t MutexType; typedef embb_mutex_t MutexType;
typedef embb_condition_t ConditionVariableType; typedef embb_condition_t ConditionVariableType;
typedef embb_rwlock_t RWLockType; typedef embb_shared_mutex_t SharedMutexType;
} // namespace internal } // namespace internal
} // namespace base } // namespace base
......
base_cpp/include/embb/base/internal/shared_mutex-inl.h 0 → 100644
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef EMBB_BASE_INTERNAL_SHARED_MUTEX_INL_H_
#define EMBB_BASE_INTERNAL_SHARED_MUTEX_INL_H_
#include <assert.h>
#include <algorithm> // For std::swap()
namespace embb {
namespace base {
template<typename SharedMutex>
SharedLock<SharedMutex>::SharedLock()
: shared_mutex_(NULL), locked_(false) {}
template<typename SharedMutex>
SharedLock<SharedMutex>::SharedLock(SharedMutex& shared_mutex)
: shared_mutex_(&shared_mutex), locked_(false) {
shared_mutex_->LockShared();
locked_ = true;
}
template<typename SharedMutex>
SharedLock<SharedMutex>::SharedLock(SharedMutex& shared_mutex, DeferLockTag)
: shared_mutex_(&shared_mutex), locked_(false) {}
template<typename SharedMutex>
SharedLock<SharedMutex>::SharedLock(SharedMutex& shared_mutex, TryLockTag)
: shared_mutex_(&shared_mutex), locked_(shared_mutex_->TryLockShared()) {}
template<typename SharedMutex>
SharedLock<SharedMutex>::SharedLock(SharedMutex& shared_mutex, AdoptLockTag)
: shared_mutex_(&shared_mutex), locked_(true) {}
template<typename SharedMutex>
SharedLock<SharedMutex>::~SharedLock() {
if (OwnsLock()) {
shared_mutex_->UnlockShared();
}
}
template<typename SharedMutex>
void SharedLock<SharedMutex>::LockShared() {
if (shared_mutex_ == NULL || locked_) {
EMBB_THROW(ErrorException, "Mutex not set or locked");
}
shared_mutex_->LockShared();
locked_ = true;
}
template<typename SharedMutex>
bool SharedLock<SharedMutex>::TryLockShared() {
if (shared_mutex_ == NULL || locked_) {
EMBB_THROW(ErrorException, "Mutex not set or locked");
}
locked_ = shared_mutex_->TryLockShared();
return locked_;
}
template<typename SharedMutex>
void SharedLock<SharedMutex>::UnlockShared() {
if (shared_mutex_ == NULL || !locked_) {
EMBB_THROW(ErrorException, "Mutex not set or unlocked");
}
shared_mutex_->UnlockShared();
locked_ = false;
}
template<typename SharedMutex>
void SharedLock<SharedMutex>::Swap(SharedLock& other) {
std::swap(shared_mutex_, other.shared_mutex_);
std::swap(locked_, other.locked_);
}
template<typename SharedMutex>
SharedMutex* SharedLock<SharedMutex>::Release() {
SharedMutex* to_release = shared_mutex_;
shared_mutex_ = NULL;
locked_ = false;
return to_release;
}
template<typename SharedMutex>
bool SharedLock<SharedMutex>::OwnsLock() const {
assert(!(locked_ && (shared_mutex_ == NULL)));
return locked_;
}
} // namespace base
} // namespace embb
#endif // EMBB_BASE_INTERNAL_SHARED_MUTEX_INL_H_
base_cpp/src/rwlock.cc → base_cpp/src/shared_mutex.cc
...@@ -24,73 +24,45 @@ ...@@ -24,73 +24,45 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <embb/base/rwlock.h> #include <embb/base/shared_mutex.h>
#include <embb/base/c/rwlock.h> #include <embb/base/c/shared_mutex.h>
namespace embb { namespace embb {
namespace base { namespace base {
RWLock::RWLock() SharedMutex::SharedMutex()
: rwlock_(), : shared_mutex_() {
// Disable "this is used in base member initializer" warning. embb_shared_mutex_init(&shared_mutex_);
// We explicitly want this.
#ifdef EMBB_PLATFORM_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable:4355)
#endif
reader_lock_(*this),
writer_lock_(*this) {
#ifdef EMBB_PLATFORM_COMPILER_MSVC
#pragma warning(pop)
#endif
embb_rwlock_init(&rwlock_);
} }
RWLock::~RWLock() { SharedMutex::~SharedMutex() {
embb_rwlock_destroy(&rwlock_); embb_shared_mutex_destroy(&shared_mutex_);
} }
void RWLock::LockRead() { void SharedMutex::Lock() {
embb_rwlock_lock_read(&rwlock_); embb_shared_mutex_lock(&shared_mutex_);
} }
void RWLock::LockWrite() { bool SharedMutex::TryLock() {
embb_rwlock_lock_write(&rwlock_); int result = embb_shared_mutex_try_lock(&shared_mutex_);
}
bool RWLock::TryLockRead() {
int result = embb_rwlock_try_lock_read(&rwlock_);
return result == EMBB_SUCCESS; return result == EMBB_SUCCESS;
} }
bool RWLock::TryLockWrite() { void SharedMutex::Unlock() {
int result = embb_rwlock_try_lock_write(&rwlock_); embb_shared_mutex_unlock(&shared_mutex_);
return result == EMBB_SUCCESS;
} }
void RWLock::UnlockRead() { void SharedMutex::LockShared() {
embb_rwlock_unlock_read(&rwlock_); embb_shared_mutex_lock_shared(&shared_mutex_);
} }
void RWLock::UnlockWrite() { bool SharedMutex::TryLockShared() {
embb_rwlock_unlock_write(&rwlock_); int result = embb_shared_mutex_try_lock_shared(&shared_mutex_);
return result == EMBB_SUCCESS;
} }
RWLock::ReaderLock::ReaderLock(RWLock& rwlock) : rwlock_(rwlock) {} void SharedMutex::UnlockShared() {
void RWLock::ReaderLock::Lock() { rwlock_.LockRead(); } embb_shared_mutex_unlock_shared(&shared_mutex_);
bool RWLock::ReaderLock::TryLock() { return rwlock_.TryLockRead(); }
void RWLock::ReaderLock::Unlock() { rwlock_.UnlockRead(); }
RWLock::WriterLock::WriterLock(RWLock& rwlock) : rwlock_(rwlock) {}
void RWLock::WriterLock::Lock() { rwlock_.LockWrite(); }
bool RWLock::WriterLock::TryLock() { return rwlock_.TryLockWrite(); }
void RWLock::WriterLock::Unlock() { rwlock_.UnlockWrite(); }
RWLock::ReaderLock& RWLock::GetReaderLock() {
return reader_lock_;
}
RWLock::WriterLock& RWLock::GetWriterLock() {
return writer_lock_;
} }
} // namespace base } // namespace base
......
base_cpp/test/main.cc
...@@ -34,7 +34,7 @@ ...@@ -34,7 +34,7 @@
#include <thread_specific_storage_test.h> #include <thread_specific_storage_test.h>
#include <atomic_test.h> #include <atomic_test.h>
#include <memory_allocation_test.h> #include <memory_allocation_test.h>
#include <rwlock_test.h> #include <shared_mutex_test.h>
#include <embb/base/c/memory_allocation.h> #include <embb/base/c/memory_allocation.h>
...@@ -46,7 +46,7 @@ using embb::base::test::ThreadSpecificStorageTest; ...@@ -46,7 +46,7 @@ using embb::base::test::ThreadSpecificStorageTest;
using embb::base::test::AtomicTest; using embb::base::test::AtomicTest;
using embb::base::test::MemoryAllocationTest; using embb::base::test::MemoryAllocationTest;
using embb::base::test::ThreadTest; using embb::base::test::ThreadTest;
using embb::base::test::RWLockTest; using embb::base::test::SharedMutexTest;
PT_MAIN("Base C++") { PT_MAIN("Base C++") {
unsigned int max_threads = unsigned int max_threads =
...@@ -60,7 +60,7 @@ PT_MAIN("Base C++") { ...@@ -60,7 +60,7 @@ PT_MAIN("Base C++") {
PT_RUN(AtomicTest); PT_RUN(AtomicTest);
PT_RUN(MemoryAllocationTest); PT_RUN(MemoryAllocationTest);
PT_RUN(ThreadTest); PT_RUN(ThreadTest);
PT_RUN(RWLockTest); PT_RUN(SharedMutexTest);
PT_EXPECT(embb_get_bytes_allocated() == 0); PT_EXPECT(embb_get_bytes_allocated() == 0);
} }
base_cpp/test/rwlock_test.cc deleted 100644 → 0
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <rwlock_test.h>
#include <embb/base/c/errors.h>
#include <embb/base/mutex.h>
namespace embb {
namespace base {
namespace test {
RWLockTest::RWLockTest()
: counter_(0),
num_threads_(partest::TestSuite::GetDefaultNumThreads()),
num_iterations_(partest::TestSuite::GetDefaultNumIterations()) {
CreateUnit("Shared read")
.Add(&RWLockTest::TestSharedRead_ThreadMethod, this,
num_threads_, num_iterations_);
CreateUnit("Exclusive write")
.Pre(&RWLockTest::TestExclusiveWrite_Pre, this)
.Add(&RWLockTest::TestExclusiveWrite_ReaderMethod, this,
num_threads_, num_iterations_)
.Add(&RWLockTest::TestExclusiveWrite_WriterMethod, this,
num_threads_, num_iterations_)
.Post(&RWLockTest::TestExclusiveWrite_Post, this);
}
void RWLockTest::TestSharedRead_ThreadMethod() {
UniqueLock<embb::base::RWLock::ReaderLock> lock(rwlock_.GetReaderLock(),
embb::base::try_lock);
PT_ASSERT_EQ_MSG(lock.OwnsLock(), true, "Failed to lock for reading.");
int spin = 10000;
while (--spin != 0);
}
void RWLockTest::TestExclusiveWrite_Pre() {
counter_ = 0;
}
void RWLockTest::TestExclusiveWrite_ReaderMethod() {
// Just add some contention
UniqueLock<embb::base::RWLock::ReaderLock> lock(rwlock_.GetReaderLock(),
embb::base::try_lock);
int spin = 10000;
while (--spin != 0);
}
void RWLockTest::TestExclusiveWrite_WriterMethod() {
UniqueLock<embb::base::RWLock::WriterLock> lock(rwlock_.GetWriterLock());
++counter_;
}
void RWLockTest::TestExclusiveWrite_Post() {
PT_ASSERT_EQ_MSG(counter_, num_iterations_ * num_threads_,
"Counter value is inconsistent.");
}
} // namespace test
} // namespace base
} // namespace embb
base_cpp/test/shared_mutex_test.cc 0 → 100644
/*
* Copyright (c) 2014-2015, Siemens AG. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <shared_mutex_test.h>
#include <embb/base/c/errors.h>
#include <embb/base/mutex.h>
namespace embb {
namespace base {
namespace test {
SharedMutexTest::SharedMutexTest()
: shared_mutex_(),
counter_(0),
num_threads_(partest::TestSuite::GetDefaultNumThreads()),
num_iterations_(partest::TestSuite::GetDefaultNumIterations()) {
CreateUnit("Shared read")
.Add(&SharedMutexTest::TestSharedRead_ThreadMethod, this,
num_threads_, num_iterations_);
CreateUnit("Exclusive write")
.Pre(&SharedMutexTest::TestExclusiveWrite_Pre, this)
.Add(&SharedMutexTest::TestExclusiveWrite_ReaderMethod, this,
num_threads_ / 2, num_iterations_)
.Add(&SharedMutexTest::TestExclusiveWrite_WriterMethod, this,
num_threads_ / 2, num_iterations_)
.Post(&SharedMutexTest::TestExclusiveWrite_Post, this);
CreateUnit("SharedLock")
.Add(&SharedMutexTest::TestSharedLock_ThreadMethod, this,
num_threads_, num_iterations_);
}
void SharedMutexTest::TestSharedRead_ThreadMethod() {
SharedLock<embb::base::SharedMutex> lock(shared_mutex_, embb::base::try_lock);
PT_ASSERT_EQ_MSG(lock.OwnsLock(), true, "Failed to lock for reading.");
int spin = 10000;
while (--spin != 0);
}
void SharedMutexTest::TestExclusiveWrite_Pre() {
counter_ = 0;
}
void SharedMutexTest::TestExclusiveWrite_ReaderMethod() {
// Just add some contention
SharedLock<embb::base::SharedMutex> lock(shared_mutex_, embb::base::try_lock);
if (lock.OwnsLock()) {
int spin = 10000;
while (--spin != 0);
}
}
void SharedMutexTest::TestExclusiveWrite_WriterMethod() {
UniqueLock<embb::base::SharedMutex> lock(shared_mutex_);
++counter_;
}
void SharedMutexTest::TestExclusiveWrite_Post() {
PT_ASSERT_EQ_MSG(counter_, num_iterations_ * (num_threads_ / 2),
"Counter value is inconsistent.");
}
void SharedMutexTest::TestSharedLock_ThreadMethod() {
// Test basic usage
{
SharedLock<> lock(shared_mutex_);
PT_EXPECT_EQ(lock.OwnsLock(), true);
lock.UnlockShared();
PT_EXPECT_EQ(lock.OwnsLock(), false);
lock.LockShared();
PT_EXPECT_EQ(lock.OwnsLock(), true);
lock.UnlockShared();
PT_EXPECT_EQ(lock.OwnsLock(), false);
bool locked_after_try = lock.TryLockShared();
PT_EXPECT_EQ(locked_after_try, true);
PT_EXPECT_EQ(lock.OwnsLock(), true);
lock.Release()->UnlockShared();
PT_EXPECT_EQ(lock.OwnsLock(), false);
}
// Test deferred lock construction
{
SharedLock<> lock(shared_mutex_, embb::base::defer_lock);
PT_EXPECT_EQ(lock.OwnsLock(), false);
}
// Test try-lock construction
{
SharedLock<> lock(shared_mutex_, embb::base::try_lock);
PT_EXPECT_EQ(lock.OwnsLock(), true);
}
// Test adopt lock construction
{
shared_mutex_.LockShared();
SharedLock<> lock(shared_mutex_, embb::base::adopt_lock);
PT_EXPECT_EQ(lock.OwnsLock(), true);
}
// Test lock swapping
{
SharedMutex another_mutex;
SharedLock<> lock1(another_mutex);
PT_EXPECT_EQ(lock1.OwnsLock(), true);
{
SharedLock<> lock2(shared_mutex_);
PT_EXPECT_EQ(lock2.OwnsLock(), true);
lock1.Swap(lock2);
PT_EXPECT_EQ(lock1.OwnsLock(), true);
PT_EXPECT_EQ(lock2.OwnsLock(), true);
}
// At this point, lock2 was destroyed and "another_mutex" must be unlocked
SharedLock<> lock3(another_mutex, embb::base::try_lock);
PT_EXPECT_EQ(lock3.OwnsLock(), true);
// But lock1 must still be locking "shared_mutex_"
PT_EXPECT_EQ(lock1.OwnsLock(), true);
lock1.Release()->UnlockShared();
PT_EXPECT_EQ(lock1.OwnsLock(), false);
}
}
} // namespace test
} // namespace base
} // namespace embb
base_cpp/test/rwlock_test.h → base_cpp/test/shared_mutex_test.h
...@@ -24,33 +24,33 @@ ...@@ -24,33 +24,33 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef BASE_CPP_TEST_RWLOCK_TEST_H_ #ifndef BASE_CPP_TEST_SHARED_MUTEX_TEST_H_
#define BASE_CPP_TEST_RWLOCK_TEST_H_ #define BASE_CPP_TEST_SHARED_MUTEX_TEST_H_
#include <partest/partest.h> #include <partest/partest.h>
#include <embb/base/c/internal/platform.h> #include <embb/base/c/internal/platform.h>
#include <embb/base/rwlock.h> #include <embb/base/shared_mutex.h>
namespace embb { namespace embb {
namespace base { namespace base {
namespace test { namespace test {
class RWLockTest : public partest::TestCase { class SharedMutexTest : public partest::TestCase {
public: public:
RWLockTest(); SharedMutexTest();
private: private:
void TestSharedRead_Pre();
void TestSharedRead_ThreadMethod(); void TestSharedRead_ThreadMethod();
void TestSharedRead_Post();
void TestExclusiveWrite_Pre(); void TestExclusiveWrite_Pre();
void TestExclusiveWrite_ReaderMethod(); void TestExclusiveWrite_ReaderMethod();
void TestExclusiveWrite_WriterMethod(); void TestExclusiveWrite_WriterMethod();
void TestExclusiveWrite_Post(); void TestExclusiveWrite_Post();
RWLock rwlock_; void TestSharedLock_ThreadMethod();
SharedMutex shared_mutex_;
size_t counter_; size_t counter_;
size_t num_threads_; size_t num_threads_;
size_t num_iterations_; size_t num_iterations_;
...@@ -60,4 +60,4 @@ class RWLockTest : public partest::TestCase { ...@@ -60,4 +60,4 @@ class RWLockTest : public partest::TestCase {
} // namespace base } // namespace base
} // namespace embb } // namespace embb
#endif // BASE_CPP_TEST_RWLOCK_TEST_H_ #endif // BASE_CPP_TEST_SHARED_MUTEX_TEST_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment