generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-04-01 09:24:55 +02: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
Show Stats 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 std::list<TaskPtr> TaskList;
TaskManager(ThreadPool::ThreadAffinityPolicy affinityPolicy = ThreadPool::OS_DEFAULT);
TaskManager(ThreadPool::ThreadAffinityPolicy affinityPolicy = ThreadPool::TAP_DEFAULT);
/// Creates the TaskManager, using the
/// default ThreadPool.

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

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

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

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

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

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

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

@ -80,8 +80,8 @@ public:
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void setAffinityImpl(int cpu);
int getAffinityImpl() const;
void startImpl(Runnable& target);
void startImpl(Callable target, void* pData = 0);
@ -142,17 +142,19 @@ inline int ThreadImpl::getOSPriorityImpl() const
return _pData->osPrio;
}
inline void ThreadImpl::setAffinityImpl(unsigned cpu)
inline void ThreadImpl::setAffinityImpl(int)
{
(void)cpu;
throw Poco::NotImplementedException("Thread affinity not supported on this system");
// not supported
}
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
{
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 getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void setAffinityImpl(int cpu);
int getAffinityImpl() const;
int getStackSizeImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
@ -119,6 +119,7 @@ private:
DWORD _threadId;
int _prio;
int _stackSize;
int _cpu;
static CurrentThreadHolder _currentThreadHolder;
};

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

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

48
Foundation/src/ThreadPool.cpp
View File

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

20
Foundation/src/Thread_POSIX.cpp
View File

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

13
Foundation/src/Thread_WIN32.cpp
View File

@ -72,7 +72,8 @@ ThreadImpl::ThreadImpl():
_thread(0),
_threadId(0),
_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);
}
void ThreadImpl::setAffinityImpl(unsigned cpu)
void ThreadImpl::setAffinityImpl(int cpu)
{
DWORD mask = 1;
mask <<= cpu;
@ -110,13 +112,16 @@ void ThreadImpl::setAffinityImpl(unsigned cpu)
{
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)
{
if (isRunningImpl())

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

@ -246,7 +246,7 @@ TaskManagerTest::~TaskManagerTest()
void TaskManagerTest::testFinish()
{
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION);
TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskObserver to;
tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
@ -281,7 +281,7 @@ void TaskManagerTest::testFinish()
void TaskManagerTest::testCancel()
{
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION);
TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskObserver to;
tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
@ -315,7 +315,7 @@ void TaskManagerTest::testCancel()
void TaskManagerTest::testError()
{
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION);
TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
TaskObserver to;
tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted));
tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled));
@ -348,7 +348,7 @@ void TaskManagerTest::testError()
void TaskManagerTest::testCustom()
{
TaskManager tm(ThreadPool::UNIFORM_DISTRIBUTION);
TaskManager tm(ThreadPool::TAP_UNIFORM_DISTRIBUTION);
CustomTaskObserver<int> ti(0);
tm.addObserver(
@ -431,7 +431,7 @@ void TaskManagerTest::testCustom()
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);
@ -447,7 +447,7 @@ void TaskManagerTest::testMultiTasks()
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);
// fill up the thread pool

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

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