generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-27 11:06:50 +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 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));