generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2024-12-16 03:42:53 +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
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.

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

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