generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-26 10:32:56 +01:00
Code Issues Projects Releases Wiki Activity

style and interface fixes for thread affinity

Browse Source
This commit is contained in:
Guenter Obiltschnig
2015-03-18 16:40:22 +01:00
parent 8b96fd4a33
commit 2b1301b3e3
12 changed files with 217 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Foundation/include/Poco/TaskManager.h
View File

@@ -52,7 +52,7 @@ public:
typedef AutoPtr<Task> TaskPtr; typedef AutoPtr<Task> TaskPtr;
typedef std::list<TaskPtr> TaskList; typedef std::list<TaskPtr> TaskList;
TaskManager(ThreadPool::ThreadAffinityPolicy affinityPolicy = ThreadPool::OS_DEFAULT); TaskManager(ThreadPool::ThreadAffinityPolicy affinityPolicy = ThreadPool::TAP_DEFAULT);
/// Creates the TaskManager, using the /// Creates the TaskManager, using the
/// default ThreadPool. /// default ThreadPool.

23
Foundation/include/Poco/Thread.h
View File

@@ -25,6 +25,7 @@
#include "Poco/Mutex.h" #include "Poco/Mutex.h"
#include "Poco/Environment.h" #include "Poco/Environment.h"
#if defined(POCO_OS_FAMILY_WINDOWS) #if defined(POCO_OS_FAMILY_WINDOWS)
#if defined(_WIN32_WCE) #if defined(_WIN32_WCE)
#include "Poco/Thread_WINCE.h" #include "Poco/Thread_WINCE.h"
@@ -135,13 +136,16 @@ public:
/// Typically, the real stack size is rounded up to the nearest /// Typically, the real stack size is rounded up to the nearest
/// page size multiple. /// page size multiple.
void setAffinity(unsigned int cpu); void setAffinity(int cpu);
/// Limit specified thread to run only on the processors "cpu" /// Binds the thread to run only on the CPU core with the
/// cpu - processor (core) number /// given index.
/// Method would Throw SystemException if affinity did not setted ///
/// Does nothing if the system does not support CPU affinity for
/// threads.
unsigned getAffinity() const; int getAffinity() const;
/// Returns using cpu (core) number /// Returns the index of the CPU core this thread has been bound to,
/// or -1 if the thread has not been bound to a CPU.
int getStackSize() const; int getStackSize() const;
/// Returns the thread's stack size in bytes. /// Returns the thread's stack size in bytes.
@@ -358,16 +362,19 @@ inline void Thread::setStackSize(int size)
setStackSizeImpl(size); setStackSizeImpl(size);
} }
inline void Thread::setAffinity(unsigned int cpu)
inline void Thread::setAffinity(int cpu)
{ {
setAffinityImpl(cpu); setAffinityImpl(cpu);
} }
inline unsigned Thread::getAffinity() const
inline int Thread::getAffinity() const
{ {
return getAffinityImpl(); return getAffinityImpl();
} }
inline int Thread::getStackSize() const inline int Thread::getStackSize() const
{ {
return getStackSizeImpl(); return getStackSizeImpl();

26
Foundation/include/Poco/ThreadPool.h
View File

@@ -50,37 +50,37 @@ class Foundation_API ThreadPool
public: public:
enum ThreadAffinityPolicy enum ThreadAffinityPolicy
{ {
OS_DEFAULT = 0, TAP_DEFAULT = 0,
UNIFORM_DISTRIBUTION, TAP_UNIFORM_DISTRIBUTION,
CUSTOM TAP_CUSTOM
}; };
ThreadPool(int minCapacity = 2, ThreadPool(int minCapacity = 2,
int maxCapacity = 16, int maxCapacity = 16,
int idleTime = 60, int idleTime = 60,
int stackSize = POCO_THREAD_STACK_SIZE, int stackSize = POCO_THREAD_STACK_SIZE,
ThreadAffinityPolicy affinityPolicy = OS_DEFAULT); ThreadAffinityPolicy affinityPolicy = TAP_DEFAULT);
/// Creates a thread pool with minCapacity threads. /// Creates a thread pool with minCapacity threads.
/// If required, up to maxCapacity threads are created /// If required, up to maxCapacity threads are created
/// a NoThreadAvailableException exception is thrown. /// a NoThreadAvailableException exception is thrown.
/// If a thread is running idle for more than idleTime seconds, /// If a thread is running idle for more than idleTime seconds,
/// and more than minCapacity threads are running, the thread /// and more than minCapacity threads are running, the thread
/// is killed. Threads are created with given stack size. /// is killed. Threads are created with given stack size.
/// Threads are created with given affinity Policy /// Threads are created with given affinity policy.
ThreadPool(const std::string& name, ThreadPool(const std::string& name,
int minCapacity = 2, int minCapacity = 2,
int maxCapacity = 16, int maxCapacity = 16,
int idleTime = 60, int idleTime = 60,
int stackSize = POCO_THREAD_STACK_SIZE, int stackSize = POCO_THREAD_STACK_SIZE,
ThreadAffinityPolicy affinityPolicy = OS_DEFAULT); ThreadAffinityPolicy affinityPolicy = TAP_DEFAULT);
/// Creates a thread pool with the given name and minCapacity threads. /// Creates a thread pool with the given name and minCapacity threads.
/// If required, up to maxCapacity threads are created /// If required, up to maxCapacity threads are created
/// a NoThreadAvailableException exception is thrown. /// a NoThreadAvailableException exception is thrown.
/// If a thread is running idle for more than idleTime seconds, /// If a thread is running idle for more than idleTime seconds,
/// and more than minCapacity threads are running, the thread /// and more than minCapacity threads are running, the thread
/// is killed. Threads are created with given stack size. /// is killed. Threads are created with given stack size.
/// Threads are created with given affinity Policy /// Threads are created with given affinity policy.
~ThreadPool(); ~ThreadPool();
/// Currently running threads will remain active /// Currently running threads will remain active
@@ -101,10 +101,10 @@ public:
/// Returns the stack size used to create new threads. /// Returns the stack size used to create new threads.
void setAffinityPolicy(ThreadAffinityPolicy affinityPolicy); void setAffinityPolicy(ThreadAffinityPolicy affinityPolicy);
/// Sets the thread affinity policy for newly created threads /// Sets the thread affinity policy for newly created threads.
ThreadAffinityPolicy getAffinityPolicy(); ThreadAffinityPolicy getAffinityPolicy();
/// Returns the thread affinity policy used to create new thread /// Returns the thread affinity policy used to create new threads.
int used() const; int used() const;
/// Returns the number of currently used threads. /// Returns the number of currently used threads.
@@ -171,7 +171,7 @@ public:
/// or an empty string if no name has been /// or an empty string if no name has been
/// specified in the constructor. /// specified in the constructor.
static ThreadPool& defaultPool(ThreadAffinityPolicy affinityPolicy = OS_DEFAULT); static ThreadPool& defaultPool(ThreadAffinityPolicy affinityPolicy = TAP_DEFAULT);
/// Returns a reference to the default /// Returns a reference to the default
/// thread pool. /// thread pool.
@@ -180,11 +180,12 @@ protected:
PooledThread* createThread(); PooledThread* createThread();
void housekeep(); void housekeep();
int affinity(int cpu);
private: private:
ThreadPool(const ThreadPool& pool); ThreadPool(const ThreadPool& pool);
ThreadPool& operator = (const ThreadPool& pool); ThreadPool& operator = (const ThreadPool& pool);
int getCorrectCpu(int cpu);
typedef std::vector<PooledThread*> ThreadVec; typedef std::vector<PooledThread*> ThreadVec;
std::string _name; std::string _name;
@@ -215,16 +216,19 @@ inline int ThreadPool::getStackSize() const
return _stackSize; return _stackSize;
} }
inline void ThreadPool::setAffinityPolicy(ThreadPool::ThreadAffinityPolicy affinityPolicy) inline void ThreadPool::setAffinityPolicy(ThreadPool::ThreadAffinityPolicy affinityPolicy)
{ {
_affinityPolicy = affinityPolicy; _affinityPolicy = affinityPolicy;
} }
inline ThreadPool::ThreadAffinityPolicy ThreadPool::getAffinityPolicy() inline ThreadPool::ThreadAffinityPolicy ThreadPool::getAffinityPolicy()
{ {
return _affinityPolicy; return _affinityPolicy;
} }
inline const std::string& ThreadPool::name() const inline const std::string& ThreadPool::name() const
{ {
return _name; return _name;

4
Foundation/include/Poco/Thread_POSIX.h
View File

@@ -74,8 +74,8 @@ public:
static int getMaxOSPriorityImpl(int policy); static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size); void setStackSizeImpl(int size);
int getStackSizeImpl() const; int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu); void setAffinityImpl(int cpu);
unsigned getAffinityImpl() const; int getAffinityImpl() const;
void startImpl(SharedPtr<Runnable> pTarget); void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl(); void joinImpl();
bool joinImpl(long milliseconds); bool joinImpl(long milliseconds);

16
Foundation/include/Poco/Thread_VX.h
View File

@@ -80,8 +80,8 @@ public:
static int getMaxOSPriorityImpl(int policy); static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size); void setStackSizeImpl(int size);
int getStackSizeImpl() const; int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu); void setAffinityImpl(int cpu);
unsigned getAffinityImpl() const; int getAffinityImpl() const;
void startImpl(Runnable& target); void startImpl(Runnable& target);
void startImpl(Callable target, void* pData = 0); void startImpl(Callable target, void* pData = 0);
@@ -142,17 +142,19 @@ inline int ThreadImpl::getOSPriorityImpl() const
return _pData->osPrio; return _pData->osPrio;
} }
inline void ThreadImpl::setAffinityImpl(unsigned cpu)
inline void ThreadImpl::setAffinityImpl(int)
{ {
(void)cpu; // not supported
throw Poco::NotImplementedException("Thread affinity not supported on this system");
} }
inline unsigned ThreadImpl::getAffinityImpl()
inline int ThreadImpl::getAffinityImpl()
{ {
throw Poco::NotImplementedException("Thread affinity not supported on this system"); return -1;
} }
inline bool ThreadImpl::isRunningImpl() const inline bool ThreadImpl::isRunningImpl() const
{ {
return _pData->pRunnableTarget != 0 || return _pData->pRunnableTarget != 0 ||

5
Foundation/include/Poco/Thread_WIN32.h
View File

@@ -66,8 +66,8 @@ public:
static int getMinOSPriorityImpl(int policy); static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy); static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size); void setStackSizeImpl(int size);
void setAffinityImpl(unsigned cpu); void setAffinityImpl(int cpu);
unsigned getAffinityImpl() const; int getAffinityImpl() const;
int getStackSizeImpl() const; int getStackSizeImpl() const;
void startImpl(SharedPtr<Runnable> pTarget); void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl(); void joinImpl();
@@ -119,6 +119,7 @@ private:
DWORD _threadId; DWORD _threadId;
int _prio; int _prio;
int _stackSize; int _stackSize;
int _cpu;
static CurrentThreadHolder _currentThreadHolder; static CurrentThreadHolder _currentThreadHolder;
}; };

16
Foundation/include/Poco/Thread_WINCE.h
View File

@@ -67,8 +67,8 @@ public:
static int getMaxOSPriorityImpl(int policy); static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size); void setStackSizeImpl(int size);
int getStackSizeImpl() const; int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu); void setAffinityImpl(int cpu);
unsigned getAffinityImpl() const; int getAffinityImpl() const;
void startImpl(SharedPtr<Runnable> pTarget); void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl(); void joinImpl();
bool joinImpl(long milliseconds); bool joinImpl(long milliseconds);
@@ -146,17 +146,19 @@ inline int ThreadImpl::getMaxOSPriorityImpl(int /* policy */)
return PRIO_HIGHEST_IMPL; return PRIO_HIGHEST_IMPL;
} }
inline void ThreadImpl::setAffinityImpl(unsigned cpu)
inline void ThreadImpl::setAffinityImpl(int)
{ {
(void)cpu; // not supported
throw Poco::NotImplementedException("Thread affinity not supported on this system");
} }
inline unsigned ThreadImpl::getAffinityImpl() const
inline int ThreadImpl::getAffinityImpl() const
{ {
throw Poco::NotImplementedException("Thread affinity not supported on this system"); return -1;
} }
inline void ThreadImpl::sleepImpl(long milliseconds) inline void ThreadImpl::sleepImpl(long milliseconds)
{ {
Sleep(DWORD(milliseconds)); Sleep(DWORD(milliseconds));

48
Foundation/src/ThreadPool.cpp
View File

@@ -89,7 +89,8 @@ void PooledThread::start(int cpu)
{ {
_thread.start(*this); _thread.start(*this);
_started.wait(); _started.wait();
if (cpu >= 0) { if (cpu >= 0)
{
_thread.setAffinity(static_cast<unsigned>(cpu)); _thread.setAffinity(static_cast<unsigned>(cpu));
} }
} }
@@ -104,7 +105,8 @@ void PooledThread::start(Thread::Priority priority, Runnable& target, int cpu)
_pTarget = &target; _pTarget = &target;
_thread.setPriority(priority); _thread.setPriority(priority);
_targetReady.set(); _targetReady.set();
if (cpu >= 0) { if (cpu >= 0)
{
_thread.setAffinity(static_cast<unsigned>(cpu)); _thread.setAffinity(static_cast<unsigned>(cpu));
} }
} }
@@ -132,7 +134,8 @@ void PooledThread::start(Thread::Priority priority, Runnable& target, const std:
_pTarget = &target; _pTarget = &target;
_targetReady.set(); _targetReady.set();
if (cpu >= 0) { if (cpu >= 0)
{
_thread.setAffinity(static_cast<unsigned>(cpu)); _thread.setAffinity(static_cast<unsigned>(cpu));
} }
} }
@@ -267,7 +270,8 @@ ThreadPool::ThreadPool(int minCapacity,
for (int i = 0; i < _minCapacity; i++) for (int i = 0; i < _minCapacity; i++)
{ {
if (_affinityPolicy == UNIFORM_DISTRIBUTION) { if (_affinityPolicy == TAP_UNIFORM_DISTRIBUTION)
{
cpu = _lastCpu.value() % cpuCount; cpu = _lastCpu.value() % cpuCount;
_lastCpu++; _lastCpu++;
} }
@@ -300,7 +304,8 @@ ThreadPool::ThreadPool(const std::string& name,
int cpuCount = Poco::Environment::processorCount(); int cpuCount = Poco::Environment::processorCount();
for (int i = 0; i < _minCapacity; i++) for (int i = 0; i < _minCapacity; i++)
{ {
if (_affinityPolicy == UNIFORM_DISTRIBUTION) { if (_affinityPolicy == TAP_UNIFORM_DISTRIBUTION)
{
cpu = _lastCpu.value() % cpuCount; cpu = _lastCpu.value() % cpuCount;
_lastCpu++; _lastCpu++;
} }
@@ -375,23 +380,25 @@ int ThreadPool::allocated() const
} }
int ThreadPool::getCorrectCpu(int cpu) int ThreadPool::affinity(int cpu)
{ {
switch (static_cast<int>(_affinityPolicy)) { switch (static_cast<int>(_affinityPolicy))
case UNIFORM_DISTRIBUTION: {
case TAP_UNIFORM_DISTRIBUTION:
{ {
cpu = _lastCpu.value() % Environment::processorCount(); cpu = _lastCpu.value() % Environment::processorCount();
_lastCpu++; _lastCpu++;
} }
break; break;
case OS_DEFAULT: case TAP_DEFAULT:
{ {
cpu = -1; cpu = -1;
} }
break; break;
case CUSTOM: case TAP_CUSTOM:
{
if ((cpu < -1) || (cpu >= Environment::processorCount()))
{ {
if ((cpu < -1) || (cpu >= Environment::processorCount())) {
throw InvalidArgumentException("cpu argument is invalid"); throw InvalidArgumentException("cpu argument is invalid");
} }
} }
@@ -400,27 +407,28 @@ int ThreadPool::getCorrectCpu(int cpu)
return cpu; return cpu;
} }
void ThreadPool::start(Runnable& target, int cpu) void ThreadPool::start(Runnable& target, int cpu)
{ {
getThread()->start(Thread::PRIO_NORMAL, target, getCorrectCpu(cpu)); getThread()->start(Thread::PRIO_NORMAL, target, affinity(cpu));
} }
void ThreadPool::start(Runnable& target, const std::string& name, int cpu) void ThreadPool::start(Runnable& target, const std::string& name, int cpu)
{ {
getThread()->start(Thread::PRIO_NORMAL, target, name, getCorrectCpu(cpu)); getThread()->start(Thread::PRIO_NORMAL, target, name, affinity(cpu));
} }
void ThreadPool::startWithPriority(Thread::Priority priority, Runnable& target, int cpu) void ThreadPool::startWithPriority(Thread::Priority priority, Runnable& target, int cpu)
{ {
getThread()->start(priority, target, getCorrectCpu(cpu)); getThread()->start(priority, target, affinity(cpu));
} }
void ThreadPool::startWithPriority(Thread::Priority priority, Runnable& target, const std::string& name, int cpu) void ThreadPool::startWithPriority(Thread::Priority priority, Runnable& target, const std::string& name, int cpu)
{ {
getThread()->start(priority, target, name, getCorrectCpu(cpu)); getThread()->start(priority, target, name, affinity(cpu));
} }
@@ -518,14 +526,14 @@ PooledThread* ThreadPool::getThread()
{ {
pThread->start(); pThread->start();
_threads.push_back(pThread); _threads.push_back(pThread);
} catch (...) }
catch (...)
{ {
delete pThread; delete pThread;
throw; throw;
} }
} }
else else throw NoThreadAvailableException();
throw NoThreadAvailableException();
} }
pThread->activate(); pThread->activate();
return pThread; return pThread;
@@ -547,11 +555,13 @@ public:
{ {
_pPool = 0; _pPool = 0;
} }
~ThreadPoolSingletonHolder() ~ThreadPoolSingletonHolder()
{ {
delete _pPool; delete _pPool;
} }
ThreadPool* pool(ThreadPool::ThreadAffinityPolicy affinityPolicy = ThreadPool::OS_DEFAULT)
ThreadPool* pool(ThreadPool::ThreadAffinityPolicy affinityPolicy = ThreadPool::TAP_DEFAULT)
{ {
FastMutex::ScopedLock lock(_mutex); FastMutex::ScopedLock lock(_mutex);

20
Foundation/src/Thread_POSIX.cpp
View File

@@ -35,6 +35,8 @@
# include <mach/task.h> # include <mach/task.h>
# include <mach/thread_policy.h> # include <mach/thread_policy.h>
#endif #endif
// //
// Block SIGPIPE in main thread. // Block SIGPIPE in main thread.
// //
@@ -55,6 +57,7 @@ public:
} }
}; };
static SignalBlocker signalBlocker; static SignalBlocker signalBlocker;
} }
#endif #endif
@@ -183,7 +186,8 @@ void ThreadImpl::setStackSizeImpl(int size)
#endif #endif
} }
void ThreadImpl::setAffinityImpl(unsigned cpu)
void ThreadImpl::setAffinityImpl(int cpu)
{ {
#if defined (POCO_OS_FAMILY_UNIX) && POCO_OS != POCO_OS_MAC_OS_X #if defined (POCO_OS_FAMILY_UNIX) && POCO_OS != POCO_OS_MAC_OS_X
#ifdef HAVE_PTHREAD_SETAFFINITY_NP #ifdef HAVE_PTHREAD_SETAFFINITY_NP
@@ -219,10 +223,11 @@ void ThreadImpl::setAffinityImpl(unsigned cpu)
yieldImpl(); yieldImpl();
} }
unsigned ThreadImpl::getAffinityImpl() const
int ThreadImpl::getAffinityImpl() const
{ {
unsigned cpuSet = 0; int cpuSet = -1;
unsigned cpuCount = Environment::processorCount(); int cpuCount = Environment::processorCount();
#if defined (POCO_OS_FAMILY_UNIX) && POCO_OS != POCO_OS_MAC_OS_X #if defined (POCO_OS_FAMILY_UNIX) && POCO_OS != POCO_OS_MAC_OS_X
#ifdef HAVE_PTHREAD_SETAFFINITY_NP #ifdef HAVE_PTHREAD_SETAFFINITY_NP
cpu_set_t cpuset; cpu_set_t cpuset;
@@ -234,7 +239,7 @@ unsigned ThreadImpl::getAffinityImpl() const
if (pthread_getaffinity_np(_pData->thread, &cpuset) != 0) if (pthread_getaffinity_np(_pData->thread, &cpuset) != 0)
throw SystemException("Failed to get affinity", errno); throw SystemException("Failed to get affinity", errno);
#endif #endif
for (unsigned i = 0; i < cpuCount; i++) for (int i = 0; i < cpuCount; i++)
{ {
if (CPU_ISSET(i, &cpuset)) if (CPU_ISSET(i, &cpuset))
{ {
@@ -251,7 +256,7 @@ unsigned ThreadImpl::getAffinityImpl() const
kern_return_t ret; kern_return_t ret;
thread_affinity_policy policy; thread_affinity_policy policy;
mach_msg_type_number_t count = THREAD_AFFINITY_POLICY_COUNT; mach_msg_type_number_t count = THREAD_AFFINITY_POLICY_COUNT;
boolean_t get_default = FALSE; boolean_t get_default = false;
ret = thread_policy_get(pthread_mach_thread_np(_pData->thread), ret = thread_policy_get(pthread_mach_thread_np(_pData->thread),
THREAD_AFFINITY_POLICY, THREAD_AFFINITY_POLICY,
(thread_policy_t)&policy, (thread_policy_t)&policy,
@@ -263,12 +268,13 @@ unsigned ThreadImpl::getAffinityImpl() const
} }
cpuSet = policy.affinity_tag; cpuSet = policy.affinity_tag;
if (cpuSet >= cpuCount) if (cpuSet >= cpuCount)
cpuSet = 0; cpuSet = -1;
#endif #endif
return cpuSet; return cpuSet;
} }
void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget) void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
{ {
if (_pData->pRunnableTarget) if (_pData->pRunnableTarget)

13
Foundation/src/Thread_WIN32.cpp
View File

@@ -72,7 +72,8 @@ ThreadImpl::ThreadImpl():
_thread(0), _thread(0),
_threadId(0), _threadId(0),
_prio(PRIO_NORMAL_IMPL), _prio(PRIO_NORMAL_IMPL),
_stackSize(POCO_THREAD_STACK_SIZE) _stackSize(POCO_THREAD_STACK_SIZE),
_cpu(-1)
{ {
} }
@@ -102,7 +103,8 @@ void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
setPriorityImpl(prio); setPriorityImpl(prio);
} }
void ThreadImpl::setAffinityImpl(unsigned cpu)
void ThreadImpl::setAffinityImpl(int cpu)
{ {
DWORD mask = 1; DWORD mask = 1;
mask <<= cpu; mask <<= cpu;
@@ -110,13 +112,16 @@ void ThreadImpl::setAffinityImpl(unsigned cpu)
{ {
throw SystemException("Failed to set affinity"); throw SystemException("Failed to set affinity");
} }
_cpu = cpu;
} }
unsigned ThreadImpl::getAffinityImpl() const
int ThreadImpl::getAffinityImpl() const
{ {
throw Poco::NotImplementedException("Get thread affinity not supported on this system"); return _cpu;
} }
void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget) void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
{ {
if (isRunningImpl()) if (isRunningImpl())

12
Foundation/testsuite/src/TaskManagerTest.cpp
View File

@@ -246,7 +246,7 @@ TaskManagerTest::~TaskManagerTest()
void TaskManagerTest::testFinish() void TaskManagerTest::testFinish()
{ {
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION); TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskObserver to; TaskObserver to;
tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted)); tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled)); tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
@@ -281,7 +281,7 @@ void TaskManagerTest::testFinish()
void TaskManagerTest::testCancel() void TaskManagerTest::testCancel()
{ {
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION); TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskObserver to; TaskObserver to;
tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted)); tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled)); tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
@@ -315,7 +315,7 @@ void TaskManagerTest::testCancel()
void TaskManagerTest::testError() void TaskManagerTest::testError()
{ {
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION); TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskObserver to; TaskObserver to;
tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted)); tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled)); tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
@@ -348,7 +348,7 @@ void TaskManagerTest::testError()
void TaskManagerTest::testCustom() void TaskManagerTest::testCustom()
{ {
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION); TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
CustomTaskObserver<int> ti(0); CustomTaskObserver<int> ti(0);
tm.addObserver( tm.addObserver(
@@ -431,7 +431,7 @@ void TaskManagerTest::testCustom()
void TaskManagerTest::testMultiTasks() void TaskManagerTest::testMultiTasks()
{ {
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION); TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
tm.start(new SimpleTask); tm.start(new SimpleTask);
tm.start(new SimpleTask); tm.start(new SimpleTask);
tm.start(new SimpleTask); tm.start(new SimpleTask);
@@ -447,7 +447,7 @@ void TaskManagerTest::testMultiTasks()
void TaskManagerTest::testCustomThreadPool() void TaskManagerTest::testCustomThreadPool()
{ {
ThreadPool tp(2, 5, 120, POCO_THREAD_STACK_SIZE, ThreadPool::UNIFORM_DISTRIBUTION); ThreadPool tp(2, 5, 120, POCO_THREAD_STACK_SIZE, ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskManager tm(tp); TaskManager tm(tp);
// fill up the thread pool // fill up the thread pool

14
Foundation/testsuite/src/ThreadPoolTest.cpp
View File

@@ -38,9 +38,11 @@ ThreadPoolTest::~ThreadPoolTest()
void ThreadPoolTest::startThreadPoolTest(int affinityPolicy) void ThreadPoolTest::startThreadPoolTest(int affinityPolicy)
{ {
int cpu = -1; int cpu = -1;
if (affinityPolicy == static_cast<int>(ThreadPool::CUSTOM)) { if (affinityPolicy == static_cast<int>(ThreadPool::TAP_CUSTOM))
{
cpu = 0; cpu = 0;
} }
ThreadPool pool(2, 3, 3, POCO_THREAD_STACK_SIZE, static_cast<ThreadPool::ThreadAffinityPolicy>(affinityPolicy)); ThreadPool pool(2, 3, 3, POCO_THREAD_STACK_SIZE, static_cast<ThreadPool::ThreadAffinityPolicy>(affinityPolicy));
pool.setStackSize(1); pool.setStackSize(1);
@@ -134,21 +136,25 @@ void ThreadPoolTest::startThreadPoolTest(int affinityPolicy)
assert (pool.available() == 4); assert (pool.available() == 4);
} }
void ThreadPoolTest::testThreadPool() void ThreadPoolTest::testThreadPool()
{ {
startThreadPoolTest(Poco::ThreadPool::OS_DEFAULT); startThreadPoolTest(Poco::ThreadPool::TAP_DEFAULT);
} }
void ThreadPoolTest::testThreadPoolUniformDistribution() void ThreadPoolTest::testThreadPoolUniformDistribution()
{ {
startThreadPoolTest(Poco::ThreadPool::UNIFORM_DISTRIBUTION); startThreadPoolTest(Poco::ThreadPool::TAP_UNIFORM_DISTRIBUTION);
} }
void ThreadPoolTest::testThreadPoolCustomDistribution() void ThreadPoolTest::testThreadPoolCustomDistribution()
{ {
startThreadPoolTest(Poco::ThreadPool::CUSTOM); startThreadPoolTest(Poco::ThreadPool::TAP_CUSTOM);
} }
void ThreadPoolTest::setUp() void ThreadPoolTest::setUp()
{ {
_event.reset(); _event.reset();