SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

PIThreadPoolExecutor & PIBlockingDequeue improvements

Browse Source 
- add support move & copy semantic
- introduce submit method for executor with future result
This commit is contained in:
Фоменко Степан Владимирович
2020-08-05 22:59:33 +03:00
parent 3ec1ecfb5b
commit 3cfdda7365
8 changed files with 193 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
lib/main/thread/piblockingdequeue.h
View File

@@ -20,6 +20,7 @@
#ifndef PIBLOCKINGDEQUEUE_H
#define PIBLOCKINGDEQUEUE_H
#include <queue>
#include "pideque.h"
#include "piconditionvar.h"
@@ -28,8 +29,9 @@
* wait for space to become available in the queue when storing an element.
*/
template <typename T>
class PIBlockingDequeue: private PIDeque<T> {
class PIBlockingDequeue {
public:
typedef typename std::deque<T> QueueType;
/**
* @brief Constructor
@@ -42,21 +44,21 @@ public:
/**
* @brief Copy constructor. Initialize queue with copy of other queue elements. Not thread-safe for other queue.
*/
explicit inline PIBlockingDequeue(const PIDeque<T>& other) : cond_var_add(new PIConditionVariable()), cond_var_rem(new PIConditionVariable()) {
explicit inline PIBlockingDequeue(const QueueType& other) : cond_var_add(new PIConditionVariable()), cond_var_rem(new PIConditionVariable()) {
mutex.lock();
max_size = SIZE_MAX;
PIDeque<T>::append(other);
data_queue = QueueType(other);
mutex.unlock();
}
/**
* @brief Thread-safe copy constructor. Initialize queue with copy of other queue elements.
*/
inline PIBlockingDequeue(PIBlockingDequeue<T> & other) : cond_var_add(new PIConditionVariable()), cond_var_rem(new PIConditionVariable()) {
inline PIBlockingDequeue(PIBlockingDequeue<T>& other) : cond_var_add(new PIConditionVariable()), cond_var_rem(new PIConditionVariable()) {
other.mutex.lock();
mutex.lock();
max_size = other.max_size;
PIDeque<T>::append(static_cast<PIDeque<T>&>(other));
data_queue = QueueType(other.data_queue);
mutex.unlock();
other.mutex.unlock();
}
@@ -71,10 +73,10 @@ public:
*
* @param v the element to add
*/
void put(const T & v) {
void put(T && v) {
mutex.lock();
cond_var_rem->wait(mutex, [&]() { return PIDeque<T>::size() < max_size; });
PIDeque<T>::push_back(v);
cond_var_rem->wait(mutex, [&]() { return data_queue.size() < max_size; });
data_queue.push_back(std::forward<T>(v));
mutex.unlock();
cond_var_add->notifyOne();
}
@@ -86,13 +88,13 @@ public:
* @param v the element to add
* @return true if the element was added to this queue, else false
*/
bool offer(const T & v) {
bool offer(T && v) {
mutex.lock();
if (PIDeque<T>::size() >= max_size) {
if (data_queue.size() >= max_size) {
mutex.unlock();
return false;
}
PIDeque<T>::push_back(v);
data_queue.push_back(std::forward<T>(v));
mutex.unlock();
cond_var_add->notifyOne();
return true;
@@ -106,10 +108,10 @@ public:
* @param timeoutMs how long to wait before giving up, in milliseconds
* @return true if successful, or false if the specified waiting time elapses before space is available
*/
bool offer(const T & v, int timeoutMs) {
bool offer(T && v, int timeoutMs) {
mutex.lock();
bool isOk = cond_var_rem->waitFor(mutex, timeoutMs, [&]() { return PIDeque<T>::size() < max_size; } );
if (isOk) PIDeque<T>::push_back(v);
bool isOk = cond_var_rem->waitFor(mutex, timeoutMs, [&]() { return data_queue.size() < max_size; } );
if (isOk) data_queue.push_back(std::forward<T>(v));
mutex.unlock();
if (isOk) cond_var_add->notifyOne();
return isOk;
@@ -121,10 +123,10 @@ public:
* @return the head of this queue
*/
T take() {
T t;
mutex.lock();
cond_var_add->wait(mutex, [&]() { return !PIDeque<T>::isEmpty(); });
t = T(PIDeque<T>::take_front());
cond_var_add->wait(mutex, [&]() { return !data_queue.empty(); });
T t = std::move(data_queue.front());
data_queue.pop_front();
mutex.unlock();
cond_var_rem->notifyOne();
return t;
@@ -140,11 +142,16 @@ public:
* return value is retrieved value
* @return the head of this queue, or defaultVal if the specified waiting time elapses before an element is available
*/
T poll(int timeoutMs, const T & defaultVal = T(), bool * isOk = nullptr) {
T t;
T poll(int timeoutMs, T && defaultVal = T(), bool * isOk = nullptr) {
mutex.lock();
bool isNotEmpty = cond_var_add->waitFor(mutex, timeoutMs, [&]() { return !PIDeque<T>::isEmpty(); });
t = isNotEmpty ? T(PIDeque<T>::take_front()) : defaultVal;
bool isNotEmpty = cond_var_add->waitFor(mutex, timeoutMs, [&]() { return !data_queue.empty(); });
T t;
if (isNotEmpty) {
t = std::move(data_queue.front());
data_queue.pop_front();
} else {
t = std::move(defaultVal);
}
mutex.unlock();
if (isNotEmpty) cond_var_rem->notifyOne();
if (isOk) *isOk = isNotEmpty;
@@ -160,11 +167,16 @@ public:
* return value is retrieved value
* @return the head of this queue, or defaultVal if the specified waiting time elapses before an element is available
*/
T poll(const T & defaultVal = T(), bool * isOk = nullptr) {
T poll(T && defaultVal = T(), bool * isOk = nullptr) {
T t;
mutex.lock();
bool isNotEmpty = !PIDeque<T>::isEmpty();
t = isNotEmpty ? PIDeque<T>::take_front() : defaultVal;
bool isNotEmpty = !data_queue.empty();
if (isNotEmpty) {
t = std::move(data_queue.front());
data_queue.pop_front();
} else {
t = std::move(defaultVal);
}
mutex.unlock();
if (isNotEmpty) cond_var_rem->notifyOne();
if (isOk) *isOk = isNotEmpty;
@@ -193,7 +205,7 @@ public:
*/
size_t remainingCapacity() {
mutex.lock();
size_t c = max_size - PIDeque<T>::size();
size_t c = max_size - data_queue.size();
mutex.unlock();
return c;
}
@@ -203,7 +215,7 @@ public:
*/
size_t size() {
mutex.lock();
size_t s = PIDeque<T>::size();
size_t s = data_queue.size();
mutex.unlock();
return s;
}
@@ -211,10 +223,13 @@ public:
/**
* @brief Removes all available elements from this queue and adds them to other given queue.
*/
size_t drainTo(PIDeque<T>& other, size_t maxCount = SIZE_MAX) {
size_t drainTo(QueueType& other, size_t maxCount = SIZE_MAX) {
mutex.lock();
size_t count = ((maxCount > PIDeque<T>::size()) ? PIDeque<T>::size() : maxCount);
for (size_t i = 0; i < count; ++i) other.push_back(PIDeque<T>::take_front());
size_t count = ((maxCount > data_queue.size()) ? data_queue.size() : maxCount);
for (size_t i = 0; i < count; ++i) {
other.push_back(std::move(data_queue.front()));
data_queue.pop_front();
}
mutex.unlock();
return count;
}
@@ -225,10 +240,13 @@ public:
size_t drainTo(PIBlockingDequeue<T>& other, size_t maxCount = SIZE_MAX) {
mutex.lock();
other.mutex.lock();
size_t count = maxCount > PIDeque<T>::size() ? PIDeque<T>::size() : maxCount;
size_t otherRemainingCapacity = other.max_size - static_cast<PIDeque<T> >(other).size();
size_t count = maxCount > data_queue.size() ? data_queue.size() : maxCount;
size_t otherRemainingCapacity = other.max_size - data_queue.size();
if (count > otherRemainingCapacity) count = otherRemainingCapacity;
for (size_t i = 0; i < count; ++i) other.push_back(PIDeque<T>::take_front());
for (size_t i = 0; i < count; ++i) {
other.data_queue.push_back(std::move(data_queue.front()));
data_queue.pop_front();
}
other.mutex.unlock();
mutex.unlock();
return count;
@@ -237,6 +255,7 @@ public:
private:
PIMutex mutex;
PIConditionVariable * cond_var_add, * cond_var_rem;
QueueType data_queue;
size_t max_size;
};

74
lib/main/thread/piexecutor.h
View File

@@ -22,8 +22,47 @@
#include "piblockingdequeue.h"
#include <atomic>
#include <future>
template <typename Thread_, typename Dequeue_>
/**
* @brief Wrapper for custom invoke operator available function types.
* @note Source from: "Энтони Уильямс, Параллельное программирование на С++ в действии. Практика разработки многопоточных
* программ. Пер. с англ. Слинкин А. А. - M.: ДМК Пресс, 2012 - 672c.: ил." (page 387)
*/
class FunctionWrapper {
struct ImplBase {
virtual void call() = 0;
virtual ~ImplBase() = default;
};
std::unique_ptr<ImplBase> impl;
template<typename F>
struct ImplType: ImplBase {
F f;
explicit ImplType(F&& f): f(std::forward<F>(f)) {}
void call() final { f(); }
};
public:
template<typename F, typename = std::enable_if<!std::is_same<F, FunctionWrapper>::value> >
explicit FunctionWrapper(F&& f): impl(new ImplType<F>(std::forward<F>(f))) {}
void operator()() { impl->call(); }
explicit operator bool() const noexcept { return static_cast<bool>(impl); }
FunctionWrapper() = default;
FunctionWrapper(FunctionWrapper&& other) noexcept : impl(std::move(other.impl)) {}
FunctionWrapper& operator=(FunctionWrapper&& other) noexcept {
impl = std::move(other.impl);
return *this;
}
FunctionWrapper(const FunctionWrapper& other) = delete;
FunctionWrapper& operator=(const FunctionWrapper&) = delete;
};
template <typename Thread_, template<typename> class Dequeue_>
class PIThreadPoolExecutorTemplate {
public:
NO_COPY_CLASS(PIThreadPoolExecutorTemplate)
@@ -34,8 +73,27 @@ public:
while (threadPool.size() > 0) delete threadPool.take_back();
}
void execute(const std::function<void()> & runnable) {
if (!isShutdown_) taskQueue.offer(runnable);
template<typename FunctionType>
std::future<typename std::result_of<FunctionType()>::type> submit(FunctionType&& callable) {
typedef typename std::result_of<FunctionType()>::type ResultType;
if (!isShutdown_) {
std::packaged_task<ResultType()> callable_task(std::forward<FunctionType>(callable));
auto future = callable_task.get_future();
FunctionWrapper functionWrapper(callable_task);
taskQueue.offer(std::move(functionWrapper));
return future;
} else {
return std::future<ResultType>();
}
}
template<typename FunctionType>
void execute(FunctionType&& runnable) {
if (!isShutdown_) {
FunctionWrapper function_wrapper(std::forward<FunctionType>(runnable));
taskQueue.offer(std::move(function_wrapper));
}
}
void shutdown() {
@@ -63,15 +121,15 @@ public:
protected:
std::atomic_bool isShutdown_;
Dequeue_ taskQueue;
Dequeue_<FunctionWrapper> taskQueue;
PIVector<Thread_*> threadPool;
template<typename Function>
PIThreadPoolExecutorTemplate(size_t corePoolSize, Function onBeforeStart) : isShutdown_(false) {
makePool(corePoolSize, onBeforeStart);
PIThreadPoolExecutorTemplate(size_t corePoolSize, Function&& onBeforeStart) : isShutdown_(false) {
makePool(corePoolSize, std::forward<Function>(onBeforeStart));
}
void makePool(size_t corePoolSize, std::function<void(Thread_*)> onBeforeStart = [](Thread_*){}) {
void makePool(size_t corePoolSize, std::function<void(Thread_*)>&& onBeforeStart = [](Thread_*){}) {
for (size_t i = 0; i < corePoolSize; ++i) {
auto* thread = new Thread_([&, i](){
auto runnable = taskQueue.poll(100);
@@ -87,7 +145,7 @@ protected:
}
};
typedef PIThreadPoolExecutorTemplate<PIThread, PIBlockingDequeue<std::function<void()> > > PIThreadPoolExecutor;
typedef PIThreadPoolExecutorTemplate<PIThread, PIBlockingDequeue> PIThreadPoolExecutor;
#ifdef DOXYGEN
/**

13
tests/concurrent/BlockingDequeueUnitTest.cpp
View File

@@ -1,4 +1,5 @@
#include "gtest/gtest.h"
#include "testutil.h"
#include "piblockingdequeue.h"
class MockConditionVar: public PIConditionVariable {
@@ -236,10 +237,10 @@ TEST(BlockingDequeueUnitTest, size_is_eq_to_capacity_when_capacity_reach) {
TEST(BlockingDequeueUnitTest, drainTo_is_elements_moved) {
size_t capacity = 10;
PIDeque<int> refDeque;
PIBlockingDequeue<int>::QueueType refDeque;
for (size_t i = 0; i < capacity / 2; ++i) refDeque.push_back(i * 10);
PIBlockingDequeue<int> blockingDequeue(refDeque);
PIDeque<int> deque;
PIBlockingDequeue<int>::QueueType deque;
blockingDequeue.drainTo(deque);
ASSERT_EQ(blockingDequeue.size(), 0);
ASSERT_TRUE(deque == refDeque);
@@ -247,18 +248,18 @@ TEST(BlockingDequeueUnitTest, drainTo_is_elements_moved) {
TEST(BlockingDequeueUnitTest, drainTo_is_ret_eq_to_size_when_all_moved) {
size_t capacity = 10;
PIDeque<int> refDeque;
PIBlockingDequeue<int>::QueueType refDeque;
for (size_t i = 0; i < capacity / 2; ++i) refDeque.push_back(i * 10);
PIBlockingDequeue<int> blockingDequeue(refDeque);
PIDeque<int> deque;
PIBlockingDequeue<int>::QueueType deque;
ASSERT_EQ(blockingDequeue.drainTo(deque), refDeque.size());
}
TEST(BlockingDequeueUnitTest, drainTo_is_ret_eq_to_maxCount) {
size_t capacity = 10;
PIDeque<int> refDeque;
PIBlockingDequeue<int>::QueueType refDeque;
for (size_t i = 0; i < capacity / 2; ++i) refDeque.push_back(i * 10);
PIBlockingDequeue<int> blockingDequeue(refDeque);
PIDeque<int> deque;
PIBlockingDequeue<int>::QueueType deque;
ASSERT_EQ(blockingDequeue.drainTo(deque, refDeque.size() - 1), refDeque.size() - 1);
}

32
tests/concurrent/ConditionVariableIntegrationTest.cpp
View File

@@ -3,7 +3,7 @@
#include "pithread.h"
#include "testutil.h"
class ConditionVariable : public ::testing::Test, public TestUtil {
class ConditionVariableIntegrationTest : public ::testing::Test, public TestUtil {
public:
PIMutex m;
PIConditionVariable* variable;
@@ -19,30 +19,30 @@ protected:
}
};
TEST_F(ConditionVariable, wait_is_block) {
TEST_F(ConditionVariableIntegrationTest, wait_is_block) {
createThread();
ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
}
TEST_F(ConditionVariable, wait_is_block_when_notifyOne_before_wait) {
TEST_F(ConditionVariableIntegrationTest, wait_is_block_when_notifyOne_before_wait) {
variable->notifyOne();
createThread();
ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
}
TEST_F(ConditionVariable, wait_is_block_when_notifyAll_before_wait) {
TEST_F(ConditionVariableIntegrationTest, wait_is_block_when_notifyAll_before_wait) {
variable->notifyAll();
createThread();
ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
}
TEST_F(ConditionVariable, wait_is_unblock_when_notifyOne_after_wait) {
TEST_F(ConditionVariableIntegrationTest, wait_is_unblock_when_notifyOne_after_wait) {
createThread();
variable->notifyOne();
ASSERT_TRUE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
}
TEST_F(ConditionVariable, wait_is_unblock_when_notifyAll_after_wait) {
TEST_F(ConditionVariableIntegrationTest, wait_is_unblock_when_notifyAll_after_wait) {
PIVector<PIThread*> threads;
for (int i = 0; i < THREAD_COUNT; ++i) {
@@ -61,7 +61,7 @@ TEST_F(ConditionVariable, wait_is_unblock_when_notifyAll_after_wait) {
piForeach(PIThread* thread, threads) delete thread;
}
TEST_F(ConditionVariable, wait_is_one_unblock_when_notifyOne) {
TEST_F(ConditionVariableIntegrationTest, wait_is_one_unblock_when_notifyOne) {
PIVector<PIThread*> threads;
for (int i = 0; i < THREAD_COUNT; ++i) {
@@ -77,7 +77,7 @@ TEST_F(ConditionVariable, wait_is_one_unblock_when_notifyOne) {
ASSERT_EQ(runningThreadCount, THREAD_COUNT - 1);
}
TEST_F(ConditionVariable, wait_is_protected_unblock_when_notifyOne) {
TEST_F(ConditionVariableIntegrationTest, wait_is_protected_unblock_when_notifyOne) {
createThread([&](){
m.lock();
variable->wait(m);
@@ -89,7 +89,7 @@ TEST_F(ConditionVariable, wait_is_protected_unblock_when_notifyOne) {
ASSERT_FALSE(m.tryLock());
}
TEST_F(ConditionVariable, wait_condition_is_block) {
TEST_F(ConditionVariableIntegrationTest, wait_condition_is_block) {
createThread([&](){
m.lock();
variable->wait(m, [](){ return false; });
@@ -98,7 +98,7 @@ TEST_F(ConditionVariable, wait_condition_is_block) {
ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
}
TEST_F(ConditionVariable, wait_condition_is_check_condition_before_block) {
TEST_F(ConditionVariableIntegrationTest, wait_condition_is_check_condition_before_block) {
bool isConditionChecked = false;
createThread([&](){
m.lock();
@@ -113,7 +113,7 @@ TEST_F(ConditionVariable, wait_condition_is_check_condition_before_block) {
m.unlock();
}
TEST_F(ConditionVariable, wait_condition_is_check_condition_when_notifyOne) {
TEST_F(ConditionVariableIntegrationTest, wait_condition_is_check_condition_when_notifyOne) {
bool isConditionChecked;
createThread([&](){
m.lock();
@@ -133,7 +133,7 @@ TEST_F(ConditionVariable, wait_condition_is_check_condition_when_notifyOne) {
m.unlock();
}
TEST_F(ConditionVariable, wait_condition_is_unblock_when_condition_and_notifyOne) {
TEST_F(ConditionVariableIntegrationTest, wait_condition_is_unblock_when_condition_and_notifyOne) {
bool condition = false;
createThread([&](){
m.lock();
@@ -147,7 +147,7 @@ TEST_F(ConditionVariable, wait_condition_is_unblock_when_condition_and_notifyOne
ASSERT_TRUE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
}
TEST_F(ConditionVariable, DISABLED_waitFor_is_block_before_timeout) {
TEST_F(ConditionVariableIntegrationTest, DISABLED_waitFor_is_block_before_timeout) {
createThread([&](){
PITimeMeasurer measurer;
m.lock();
@@ -159,7 +159,7 @@ TEST_F(ConditionVariable, DISABLED_waitFor_is_block_before_timeout) {
EXPECT_TRUE(thread->waitForFinish(WAIT_THREAD_TIME_MS * 3));
}
TEST_F(ConditionVariable, waitFor_is_unblock_when_timeout) {
TEST_F(ConditionVariableIntegrationTest, waitFor_is_unblock_when_timeout) {
std::atomic_bool isUnblock(false);
createThread([&](){
m.lock();
@@ -172,7 +172,7 @@ TEST_F(ConditionVariable, waitFor_is_unblock_when_timeout) {
ASSERT_TRUE(isUnblock);
}
TEST_F(ConditionVariable, waitFor_is_false_when_timeout) {
TEST_F(ConditionVariableIntegrationTest, waitFor_is_false_when_timeout) {
bool waitRet = true;
createThread([&](){
m.lock();
@@ -183,7 +183,7 @@ TEST_F(ConditionVariable, waitFor_is_false_when_timeout) {
ASSERT_FALSE(waitRet);
}
TEST_F(ConditionVariable, waitFor_is_unblock_when_condition_and_notifyOne) {
TEST_F(ConditionVariableIntegrationTest, waitFor_is_unblock_when_condition_and_notifyOne) {
bool condition = false;
createThread([&](){
m.lock();

4
tests/concurrent/ExecutorIntegrationTest.cpp
View File

@@ -1,7 +1,7 @@
#include "gtest/gtest.h"
#include "piexecutor.h"
#include "pimutex.h"
#include "testutil.h"
#include "pimutex.h"
#include "piexecutor.h"
TEST(ExcutorIntegrationTest, execute_is_runnable_invoke) {
PIMutex m;

46
tests/concurrent/ExecutorUnitTest.cpp
View File

@@ -1,13 +1,14 @@
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "piexecutor.h"
#include "testutil.h"
#include "piexecutor.h"
using ::testing::_;
using ::testing::SetArgReferee;
using ::testing::DoAll;
using ::testing::DeleteArg;
using ::testing::Return;
using ::testing::ByMove;
using ::testing::AtLeast;
using ::testing::ByRef;
using ::testing::Eq;
@@ -27,9 +28,9 @@ namespace std {
class MockThread {
public:
std::function<void()> runnnable;
VoidFunc runnnable;
MockThread(std::function<void()> runnnable) : runnnable(runnnable) { }
MockThread(VoidFunc runnnable) : runnnable(runnnable) { }
MOCK_METHOD0(start, bool());
MOCK_METHOD0(stop, void());
@@ -37,11 +38,12 @@ public:
MOCK_METHOD1(waitForFinish, bool(int timeout_msecs));
};
class MockDeque : public PIBlockingDequeue<VoidFunc> {
template<typename F>
class MockDeque : public PIBlockingDequeue<F> {
public:
MOCK_METHOD1(offer, bool(const VoidFunc&));
MOCK_METHOD0(take, VoidFunc());
MOCK_METHOD1(poll, VoidFunc(int));
MOCK_METHOD1(offer, bool(const FunctionWrapper&));
MOCK_METHOD0(take, FunctionWrapper());
MOCK_METHOD1(poll, FunctionWrapper(int));
MOCK_METHOD0(capacity, size_t());
MOCK_METHOD0(remainingCapacity, size_t());
};
@@ -57,7 +59,7 @@ public:
PIVector<testing::NiceMock<MockThread>*>* getThreadPool() { return &threadPool; }
bool isShutdown() { return isShutdown_; }
MockDeque* getTaskQueue() { return &taskQueue; }
MockDeque<FunctionWrapper>* getTaskQueue() { return &taskQueue; }
};
TEST(ExecutorUnitTest, is_corePool_created) {
@@ -73,10 +75,30 @@ TEST(ExecutorUnitTest, is_corePool_started) {
EXPECT_EQ(THREAD_COUNT, executor.getThreadPool()->size());
}
TEST(ExecutorUnitTest, submit_is_added_to_taskQueue) {
VoidFunc voidFunc = [](){};
PIThreadPoolExecutorMoc executor(THREAD_COUNT);
// TODO add check of offered
EXPECT_CALL(*executor.getTaskQueue(), offer)
.WillOnce(Return(true));
executor.submit(voidFunc);
}
TEST(ExecutorUnitTest, submit_is_return_valid_future) {
VoidFunc voidFunc = [](){};
PIThreadPoolExecutorMoc executor(THREAD_COUNT);
// TODO add check of offered
EXPECT_CALL(*executor.getTaskQueue(), offer)
.WillOnce(Return(true));
auto future = executor.submit(voidFunc);
EXPECT_TRUE(future.valid());
}
TEST(ExecutorUnitTest, execute_is_added_to_taskQueue) {
VoidFunc voidFunc = [](){};
PIThreadPoolExecutorMoc executor(THREAD_COUNT);
EXPECT_CALL(*executor.getTaskQueue(), offer(Eq(voidFunc)))
// TODO add check of offered
EXPECT_CALL(*executor.getTaskQueue(), offer)
.WillOnce(Return(true));
executor.execute(voidFunc);
}
@@ -86,7 +108,9 @@ TEST(ExecutorUnitTest, is_corePool_execute_queue_elements) {
PIThreadPoolExecutorMoc executor(1);
EXPECT_EQ(executor.getThreadPool()->size(), 1);
EXPECT_CALL(*executor.getTaskQueue(), poll(Ge(0)))
.WillOnce(Return([&](){ is_executed = true; }));
.WillOnce([&is_executed](int){
return FunctionWrapper([&is_executed](){ is_executed = true; });
});
executor.getThreadPool()->at(0)->runnnable();
ASSERT_TRUE(is_executed);
}
@@ -102,7 +126,7 @@ TEST(ExecutorUnitTest, shutdown_is_stop_threads) {
testing::Mock::AllowLeak(executor->getTaskQueue());
EXPECT_CALL(*executor->getTaskQueue(), poll(Ge(0)))
.WillRepeatedly(Return(std::function<VoidFunc()>()));
.WillRepeatedly([](int){ return FunctionWrapper(); });
executor->shutdown();
executor->getThreadPool()->forEach([](MockThread* thread){ thread->runnnable(); });
}

12
tests/concurrent/MutexIntegrationTest.cpp
View File

@@ -3,12 +3,12 @@
#include "pithread.h"
#include "testutil.h"
class Mutex : public ::testing::Test, public TestUtil {
class MutexIntegartionTest : public ::testing::Test, public TestUtil {
public:
PIMutex* m = new PIMutex();
};
TEST_F(Mutex, lock_is_protect) {
TEST_F(MutexIntegartionTest, lock_is_protect) {
m->lock();
bool* isProtect = new bool(true);
@@ -20,7 +20,7 @@ TEST_F(Mutex, lock_is_protect) {
ASSERT_TRUE(*isProtect);
}
TEST_F(Mutex, unlock_is_release) {
TEST_F(MutexIntegartionTest, unlock_is_release) {
m->lock();
bool* isReleased = new bool(false);
m->unlock();
@@ -33,7 +33,7 @@ TEST_F(Mutex, unlock_is_release) {
ASSERT_TRUE(*isReleased);
}
TEST_F(Mutex, tryLock_is_false_when_locked) {
TEST_F(MutexIntegartionTest, tryLock_is_false_when_locked) {
createThread([&](){
m->lock();
piMSleep(WAIT_THREAD_TIME_MS);
@@ -41,11 +41,11 @@ TEST_F(Mutex, tryLock_is_false_when_locked) {
ASSERT_FALSE(m->tryLock());
}
TEST_F(Mutex, tryLock_is_true_when_unlocked) {
TEST_F(MutexIntegartionTest, tryLock_is_true_when_unlocked) {
ASSERT_TRUE(m->tryLock());
}
TEST_F(Mutex, tryLock_is_recursive_lock_enable) {
TEST_F(MutexIntegartionTest, tryLock_is_recursive_lock_enable) {
m->lock();
ASSERT_TRUE(m->tryLock());
}

10
tests/concurrent/testutil.h
View File

@@ -4,11 +4,19 @@
#include "pithread.h"
#include <atomic>
template<typename T>
void print_type_info() {
std::cout << typeid(T).name() << " is a "
<< (std::is_const<typename std::remove_reference<T>::type>::value ? "const " : "")
<< (std::is_lvalue_reference<T>::value ? "lvalue" : "rvalue")
<< " reference" << std::endl;
}
/**
* Minimum wait thread start, switch context or another interthread communication action time. Increase it if tests
* write "Start thread timeout reach!" message. You can reduce it if you want increase test performance.
*/
const int WAIT_THREAD_TIME_MS = 10;
const int WAIT_THREAD_TIME_MS = 30;
const int THREAD_COUNT = 2;