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 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.

207
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"
@ -46,13 +47,13 @@ class ThreadLocalStorage;
class Foundation_API Thread: private ThreadImpl class Foundation_API Thread: private ThreadImpl
/// This class implements a platform-independent /// This class implements a platform-independent
/// wrapper to an operating system thread. /// wrapper to an operating system thread.
/// ///
/// Every Thread object gets a unique (within /// Every Thread object gets a unique (within
/// its process) numeric thread ID. /// its process) numeric thread ID.
/// Furthermore, a thread can be assigned a name. /// Furthermore, a thread can be assigned a name.
/// The name of a thread can be changed at any time. /// The name of a thread can be changed at any time.
{ {
public: public:
typedef ThreadImpl::TIDImpl TID; typedef ThreadImpl::TIDImpl TID;
@ -60,7 +61,7 @@ public:
using ThreadImpl::Callable; using ThreadImpl::Callable;
enum Priority enum Priority
/// Thread priorities. /// Thread priorities.
{ {
PRIO_LOWEST = PRIO_LOWEST_IMPL, /// The lowest thread priority. PRIO_LOWEST = PRIO_LOWEST_IMPL, /// The lowest thread priority.
PRIO_LOW = PRIO_LOW_IMPL, /// A lower than normal thread priority. PRIO_LOW = PRIO_LOW_IMPL, /// A lower than normal thread priority.
@ -75,167 +76,170 @@ public:
}; };
Thread(); Thread();
/// Creates a thread. Call start() to start it. /// Creates a thread. Call start() to start it.
Thread(const std::string& name); Thread(const std::string& name);
/// Creates a named thread. Call start() to start it. /// Creates a named thread. Call start() to start it.
~Thread(); ~Thread();
/// Destroys the thread. /// Destroys the thread.
int id() const; int id() const;
/// Returns the unique thread ID of the thread. /// Returns the unique thread ID of the thread.
TID tid() const; TID tid() const;
/// Returns the native thread ID of the thread. /// Returns the native thread ID of the thread.
std::string name() const; std::string name() const;
/// Returns the name of the thread. /// Returns the name of the thread.
std::string getName() const; std::string getName() const;
/// Returns the name of the thread. /// Returns the name of the thread.
void setName(const std::string& name); void setName(const std::string& name);
/// Sets the name of the thread. /// Sets the name of the thread.
void setPriority(Priority prio); void setPriority(Priority prio);
/// Sets the thread's priority. /// Sets the thread's priority.
/// ///
/// Some platform only allow changing a thread's priority /// Some platform only allow changing a thread's priority
/// if the process has certain privileges. /// if the process has certain privileges.
Priority getPriority() const; Priority getPriority() const;
/// Returns the thread's priority. /// Returns the thread's priority.
void setOSPriority(int prio, int policy = POLICY_DEFAULT); void setOSPriority(int prio, int policy = POLICY_DEFAULT);
/// Sets the thread's priority, using an operating system specific /// Sets the thread's priority, using an operating system specific
/// priority value. Use getMinOSPriority() and getMaxOSPriority() to /// priority value. Use getMinOSPriority() and getMaxOSPriority() to
/// obtain mininum and maximum priority values. Additionally, /// obtain mininum and maximum priority values. Additionally,
/// a scheduling policy can be specified. The policy is currently /// a scheduling policy can be specified. The policy is currently
/// only used on POSIX platforms where the values SCHED_OTHER (default), /// only used on POSIX platforms where the values SCHED_OTHER (default),
/// SCHED_FIFO and SCHED_RR are supported. /// SCHED_FIFO and SCHED_RR are supported.
int getOSPriority() const; int getOSPriority() const;
/// Returns the thread's priority, expressed as an operating system /// Returns the thread's priority, expressed as an operating system
/// specific priority value. /// specific priority value.
/// ///
/// May return 0 if the priority has not been explicitly set. /// May return 0 if the priority has not been explicitly set.
static int getMinOSPriority(int policy = POLICY_DEFAULT); static int getMinOSPriority(int policy = POLICY_DEFAULT);
/// Returns the minimum operating system-specific priority value, /// Returns the minimum operating system-specific priority value,
/// which can be passed to setOSPriority() for the given policy. /// which can be passed to setOSPriority() for the given policy.
static int getMaxOSPriority(int policy = POLICY_DEFAULT); static int getMaxOSPriority(int policy = POLICY_DEFAULT);
/// Returns the maximum operating system-specific priority value, /// Returns the maximum operating system-specific priority value,
/// which can be passed to setOSPriority() for the given policy. /// which can be passed to setOSPriority() for the given policy.
void setStackSize(int size); void setStackSize(int size);
/// Sets the thread's stack size in bytes. /// Sets the thread's stack size in bytes.
/// Setting the stack size to 0 will use the default stack size. /// Setting the stack size to 0 will use the default stack size.
/// 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.
/// If the default stack size is used, 0 is returned. /// If the default stack size is used, 0 is returned.
void start(Runnable& target); void start(Runnable& target);
/// Starts the thread with the given target. /// Starts the thread with the given target.
/// ///
/// Note that the given Runnable object must remain /// Note that the given Runnable object must remain
/// valid during the entire lifetime of the thread, as /// valid during the entire lifetime of the thread, as
/// only a reference to it is stored internally. /// only a reference to it is stored internally.
void start(Callable target, void* pData = 0); void start(Callable target, void* pData = 0);
/// Starts the thread with the given target and parameter. /// Starts the thread with the given target and parameter.
template <class Functor> template <class Functor>
void startFunc(Functor fn) void startFunc(Functor fn)
/// Starts the thread with the given functor object or lambda. /// Starts the thread with the given functor object or lambda.
{ {
startImpl(new FunctorRunnable<Functor>(fn)); startImpl(new FunctorRunnable<Functor>(fn));
} }
void join(); void join();
/// Waits until the thread completes execution. /// Waits until the thread completes execution.
/// If multiple threads try to join the same /// If multiple threads try to join the same
/// thread, the result is undefined. /// thread, the result is undefined.
void join(long milliseconds); void join(long milliseconds);
/// Waits for at most the given interval for the thread /// Waits for at most the given interval for the thread
/// to complete. Throws a TimeoutException if the thread /// to complete. Throws a TimeoutException if the thread
/// does not complete within the specified time interval. /// does not complete within the specified time interval.
bool tryJoin(long milliseconds); bool tryJoin(long milliseconds);
/// Waits for at most the given interval for the thread /// Waits for at most the given interval for the thread
/// to complete. Returns true if the thread has finished, /// to complete. Returns true if the thread has finished,
/// false otherwise. /// false otherwise.
bool isRunning() const; bool isRunning() const;
/// Returns true if the thread is running. /// Returns true if the thread is running.
static bool trySleep(long milliseconds); static bool trySleep(long milliseconds);
/// Starts an interruptible sleep. When trySleep() is called, /// Starts an interruptible sleep. When trySleep() is called,
/// the thread will remain suspended until: /// the thread will remain suspended until:
/// - the timeout expires or /// - the timeout expires or
/// - wakeUp() is called /// - wakeUp() is called
/// ///
/// Function returns true if sleep attempt was completed, false /// Function returns true if sleep attempt was completed, false
/// if sleep was interrupted by a wakeUp() call. /// if sleep was interrupted by a wakeUp() call.
/// A frequent scenario where trySleep()/wakeUp() pair of functions /// A frequent scenario where trySleep()/wakeUp() pair of functions
/// is useful is with threads spending most of the time idle, /// is useful is with threads spending most of the time idle,
/// with periodic activity between the idle times; trying to sleep /// with periodic activity between the idle times; trying to sleep
/// (as opposed to sleeping) allows immediate ending of idle thread /// (as opposed to sleeping) allows immediate ending of idle thread
/// from the outside. /// from the outside.
/// ///
/// The trySleep() and wakeUp() calls should be used with /// The trySleep() and wakeUp() calls should be used with
/// understanding that the suspended state is not a true sleep, /// understanding that the suspended state is not a true sleep,
/// but rather a state of waiting for an event, with timeout /// but rather a state of waiting for an event, with timeout
/// expiration. This makes order of calls significant; calling /// expiration. This makes order of calls significant; calling
/// wakeUp() before calling trySleep() will prevent the next /// wakeUp() before calling trySleep() will prevent the next
/// trySleep() call to actually suspend the thread (which, in /// trySleep() call to actually suspend the thread (which, in
/// some scenarios, may be desirable behavior). /// some scenarios, may be desirable behavior).
void wakeUp(); void wakeUp();
/// Wakes up the thread which is in the state of interruptible /// Wakes up the thread which is in the state of interruptible
/// sleep. For threads that are not suspended, calling this /// sleep. For threads that are not suspended, calling this
/// function has the effect of preventing the subsequent /// function has the effect of preventing the subsequent
/// trySleep() call to put thread in a suspended state. /// trySleep() call to put thread in a suspended state.
static void sleep(long milliseconds); static void sleep(long milliseconds);
/// Suspends the current thread for the specified /// Suspends the current thread for the specified
/// amount of time. /// amount of time.
static void yield(); static void yield();
/// Yields cpu to other threads. /// Yields cpu to other threads.
static Thread* current(); static Thread* current();
/// Returns the Thread object for the currently active thread. /// Returns the Thread object for the currently active thread.
/// If the current thread is the main thread, 0 is returned. /// If the current thread is the main thread, 0 is returned.
static TID currentTid(); static TID currentTid();
/// Returns the native thread ID for the current thread. /// Returns the native thread ID for the current thread.
protected: protected:
ThreadLocalStorage& tls(); ThreadLocalStorage& tls();
/// Returns a reference to the thread's local storage. /// Returns a reference to the thread's local storage.
void clearTLS(); void clearTLS();
/// Clears the thread's local storage. /// Clears the thread's local storage.
std::string makeName(); std::string makeName();
/// Creates a unique name for a thread. /// Creates a unique name for a thread.
static int uniqueId(); static int uniqueId();
/// Creates and returns a unique id for a thread. /// Creates and returns a unique id for a thread.
template <class Functor> template <class Functor>
class FunctorRunnable: public Runnable class FunctorRunnable: public Runnable
@ -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);

28
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
@ -203,8 +207,8 @@ void ThreadImpl::setAffinityImpl(unsigned cpu)
#endif // defined unix & !defined mac os x #endif // defined unix & !defined mac os x
#if POCO_OS == POCO_OS_MAC_OS_X #if POCO_OS == POCO_OS_MAC_OS_X
kern_return_t ret; kern_return_t ret;
thread_affinity_policy policy; thread_affinity_policy policy;
policy.affinity_tag = cpu; policy.affinity_tag = cpu;
ret = thread_policy_set(pthread_mach_thread_np(_pData->thread), ret = thread_policy_set(pthread_mach_thread_np(_pData->thread),
@ -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))
{ {
@ -248,10 +253,10 @@ unsigned ThreadImpl::getAffinityImpl() const
#endif // defined unix & !defined mac os x #endif // defined unix & !defined mac os x
#if POCO_OS == POCO_OS_MAC_OS_X #if POCO_OS == POCO_OS_MAC_OS_X
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();