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

fix indentation

Browse Source
This commit is contained in:
ale_bychuk 2015-03-08 22:54:45 +03:00
parent 3af35f548c
commit a0e172419f
8 changed files with 1212 additions and 1207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -55,222 +55,222 @@ class Foundation_API Thread: private ThreadImpl
/// The name of a thread can be changed at any time.
{
public:
typedef ThreadImpl::TIDImpl TID;
typedef ThreadImpl::TIDImpl TID;
using ThreadImpl::Callable;
using ThreadImpl::Callable;
enum Priority
/// Thread priorities.
{
PRIO_LOWEST = PRIO_LOWEST_IMPL, /// The lowest thread priority.
PRIO_LOW = PRIO_LOW_IMPL, /// A lower than normal thread priority.
PRIO_NORMAL = PRIO_NORMAL_IMPL, /// The normal thread priority.
PRIO_HIGH = PRIO_HIGH_IMPL, /// A higher than normal thread priority.
PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority.
};
enum Priority
/// Thread priorities.
{
PRIO_LOWEST = PRIO_LOWEST_IMPL, /// The lowest thread priority.
PRIO_LOW = PRIO_LOW_IMPL, /// A lower than normal thread priority.
PRIO_NORMAL = PRIO_NORMAL_IMPL, /// The normal thread priority.
PRIO_HIGH = PRIO_HIGH_IMPL, /// A higher than normal thread priority.
PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority.
};
enum Policy
{
POLICY_DEFAULT = POLICY_DEFAULT_IMPL
};
enum Policy
{
POLICY_DEFAULT = POLICY_DEFAULT_IMPL
};
Thread();
/// Creates a thread. Call start() to start it.
Thread();
/// Creates a thread. Call start() to start it.
Thread(const std::string& name);
/// Creates a named thread. Call start() to start it.
Thread(const std::string& name);
/// Creates a named thread. Call start() to start it.
~Thread();
/// Destroys the thread.
~Thread();
/// Destroys the thread.
int id() const;
/// Returns the unique thread ID of the thread.
int id() const;
/// Returns the unique thread ID of the thread.
TID tid() const;
/// Returns the native thread ID of the thread.
TID tid() const;
/// Returns the native thread ID of the thread.
std::string name() const;
/// Returns the name of the thread.
std::string name() const;
/// Returns the name of the thread.
std::string getName() const;
/// Returns the name of the thread.
std::string getName() const;
/// Returns the name of the thread.
void setName(const std::string& name);
/// Sets the name of the thread.
void setName(const std::string& name);
/// 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.
void setPriority(Priority prio);
/// 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.
Priority getPriority() const;
/// 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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(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
unsigned getAffinity() const;
/// Returns using cpu (core) number
unsigned getAffinity() const;
/// Returns using cpu (core) number
int getStackSize() const;
/// Returns the thread's stack size in bytes.
/// If the default stack size is used, 0 is returned.
int getStackSize() const;
/// 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.
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.
void start(Callable target, void* pData = 0);
/// Starts the thread with the given target and parameter.
void start(Callable target, void* pData = 0);
/// 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.
{
startImpl(new FunctorRunnable<Functor>(fn));
}
template <class Functor>
void startFunc(Functor fn)
/// 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.
void join();
/// 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.
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.
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.
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.
bool isRunning() const;
/// Returns true if the thread is running.
bool isRunning() const;
/// 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).
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).
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.
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.
static void sleep(long milliseconds);
/// Suspends the current thread for the specified
/// amount of time.
static void sleep(long milliseconds);
/// Suspends the current thread for the specified
/// amount of time.
static void yield();
/// Yields cpu to other threads.
static void yield();
/// 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.
static Thread* current();
/// 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.
static TID currentTid();
/// Returns the native thread ID for the current thread.
protected:
ThreadLocalStorage& tls();
/// Returns a reference to the thread's local storage.
ThreadLocalStorage& tls();
/// Returns a reference to the thread's local storage.
void clearTLS();
/// Clears the thread's local storage.
void clearTLS();
/// Clears the thread's local storage.
std::string makeName();
/// Creates a unique name for a thread.
std::string makeName();
/// Creates a unique name for a thread.
static int uniqueId();
/// Creates and returns a unique id for a thread.
static int uniqueId();
/// Creates and returns a unique id for a thread.
template <class Functor>
class FunctorRunnable: public Runnable
{
public:
FunctorRunnable(const Functor& functor):
_functor(functor)
{
}
template <class Functor>
class FunctorRunnable: public Runnable
{
public:
FunctorRunnable(const Functor& functor):
_functor(functor)
{
}
~FunctorRunnable()
{
}
~FunctorRunnable()
{
}
void run()
{
_functor();
}
void run()
{
_functor();
}
private:
Functor _functor;
};
private:
Functor _functor;
};
private:
Thread(const Thread&);
Thread& operator = (const Thread&);
Thread(const Thread&);
Thread& operator = (const Thread&);
int _id;
std::string _name;
ThreadLocalStorage* _pTLS;
Event _event;
mutable FastMutex _mutex;
int _id;
std::string _name;
ThreadLocalStorage* _pTLS;
Event _event;
mutable FastMutex _mutex;
friend class ThreadLocalStorage;
friend class PooledThread;
friend class ThreadLocalStorage;
friend class PooledThread;
};
@ -279,104 +279,104 @@ private:
//
inline Thread::TID Thread::tid() const
{
return tidImpl();
return tidImpl();
}
inline int Thread::id() const
{
return _id;
return _id;
}
inline std::string Thread::name() const
{
FastMutex::ScopedLock lock(_mutex);
FastMutex::ScopedLock lock(_mutex);
return _name;
return _name;
}
inline std::string Thread::getName() const
{
FastMutex::ScopedLock lock(_mutex);
FastMutex::ScopedLock lock(_mutex);
return _name;
return _name;
}
inline bool Thread::isRunning() const
{
return isRunningImpl();
return isRunningImpl();
}
inline void Thread::sleep(long milliseconds)
{
sleepImpl(milliseconds);
sleepImpl(milliseconds);
}
inline void Thread::yield()
{
yieldImpl();
yieldImpl();
}
inline Thread* Thread::current()
{
return static_cast<Thread*>(currentImpl());
return static_cast<Thread*>(currentImpl());
}
inline void Thread::setOSPriority(int prio, int policy)
{
setOSPriorityImpl(prio, policy);
setOSPriorityImpl(prio, policy);
}
inline int Thread::getOSPriority() const
{
return getOSPriorityImpl();
return getOSPriorityImpl();
}
inline int Thread::getMinOSPriority(int policy)
{
return ThreadImpl::getMinOSPriorityImpl(policy);
return ThreadImpl::getMinOSPriorityImpl(policy);
}
inline int Thread::getMaxOSPriority(int policy)
{
return ThreadImpl::getMaxOSPriorityImpl(policy);
return ThreadImpl::getMaxOSPriorityImpl(policy);
}
inline void Thread::setStackSize(int size)
{
setStackSizeImpl(size);
setStackSizeImpl(size);
}
inline void Thread::setAffinity(unsigned int cpu)
{
setAffinityImpl(cpu);
setAffinityImpl(cpu);
}
inline unsigned Thread::getAffinity() const
{
return getAffinityImpl();
return getAffinityImpl();
}
inline int Thread::getStackSize() const
{
return getStackSizeImpl();
return getStackSizeImpl();
}
inline Thread::TID Thread::currentTid()
{
return currentTidImpl();
return currentTidImpl();
}

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

@ -45,113 +45,113 @@ namespace Poco {
class Foundation_API ThreadImpl
{
public:
typedef pthread_t TIDImpl;
typedef void (*Callable)(void*);
typedef pthread_t TIDImpl;
typedef void (*Callable)(void*);
enum Priority
{
PRIO_LOWEST_IMPL,
PRIO_LOW_IMPL,
PRIO_NORMAL_IMPL,
PRIO_HIGH_IMPL,
PRIO_HIGHEST_IMPL
};
enum Priority
{
PRIO_LOWEST_IMPL,
PRIO_LOW_IMPL,
PRIO_NORMAL_IMPL,
PRIO_HIGH_IMPL,
PRIO_HIGHEST_IMPL
};
enum Policy
{
POLICY_DEFAULT_IMPL = SCHED_OTHER
};
enum Policy
{
POLICY_DEFAULT_IMPL = SCHED_OTHER
};
ThreadImpl();
~ThreadImpl();
ThreadImpl();
~ThreadImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = SCHED_OTHER);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = SCHED_OTHER);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
protected:
static void* runnableEntry(void* pThread);
static int mapPrio(int prio, int policy = SCHED_OTHER);
static int reverseMapPrio(int osPrio, int policy = SCHED_OTHER);
static void* runnableEntry(void* pThread);
static int mapPrio(int prio, int policy = SCHED_OTHER);
static int reverseMapPrio(int osPrio, int policy = SCHED_OTHER);
private:
class CurrentThreadHolder
{
public:
CurrentThreadHolder()
{
if (pthread_key_create(&_key, NULL))
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
pthread_key_delete(_key);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(pthread_getspecific(_key));
}
void set(ThreadImpl* pThread)
{
pthread_setspecific(_key, pThread);
}
class CurrentThreadHolder
{
public:
CurrentThreadHolder()
{
if (pthread_key_create(&_key, NULL))
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
pthread_key_delete(_key);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(pthread_getspecific(_key));
}
void set(ThreadImpl* pThread)
{
pthread_setspecific(_key, pThread);
}
private:
pthread_key_t _key;
};
private:
pthread_key_t _key;
};
struct ThreadData: public RefCountedObject
{
ThreadData():
thread(0),
prio(PRIO_NORMAL_IMPL),
policy(SCHED_OTHER),
done(Event::EVENT_MANUALRESET),
stackSize(POCO_THREAD_STACK_SIZE),
started(false),
joined(false)
{
struct ThreadData: public RefCountedObject
{
ThreadData():
thread(0),
prio(PRIO_NORMAL_IMPL),
policy(SCHED_OTHER),
done(Event::EVENT_MANUALRESET),
stackSize(POCO_THREAD_STACK_SIZE),
started(false),
joined(false)
{
#if defined(POCO_VXWORKS)
// This workaround is for VxWorks 5.x where
// pthread_init() won't properly initialize the thread.
std::memset(&thread, 0, sizeof(thread));
// This workaround is for VxWorks 5.x where
// pthread_init() won't properly initialize the thread.
std::memset(&thread, 0, sizeof(thread));
#endif
}
}
SharedPtr<Runnable> pRunnableTarget;
pthread_t thread;
int prio;
int osPrio;
int policy;
Event done;
std::size_t stackSize;
bool started;
bool joined;
};
SharedPtr<Runnable> pRunnableTarget;
pthread_t thread;
int prio;
int osPrio;
int policy;
Event done;
std::size_t stackSize;
bool started;
bool joined;
};
AutoPtr<ThreadData> _pData;
AutoPtr<ThreadData> _pData;
static CurrentThreadHolder _currentThreadHolder;
static CurrentThreadHolder _currentThreadHolder;
#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
SignalHandler::JumpBufferVec _jumpBufferVec;
friend class SignalHandler;
SignalHandler::JumpBufferVec _jumpBufferVec;
friend class SignalHandler;
#endif
};
@ -161,37 +161,37 @@ private:
//
inline int ThreadImpl::getPriorityImpl() const
{
return _pData->prio;
return _pData->prio;
}
inline int ThreadImpl::getOSPriorityImpl() const
{
return _pData->osPrio;
return _pData->osPrio;
}
inline bool ThreadImpl::isRunningImpl() const
{
return !_pData->pRunnableTarget.isNull();
return !_pData->pRunnableTarget.isNull();
}
inline void ThreadImpl::yieldImpl()
{
sched_yield();
sched_yield();
}
inline int ThreadImpl::getStackSizeImpl() const
{
return static_cast<int>(_pData->stackSize);
return static_cast<int>(_pData->stackSize);
}
inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
{
return _pData->thread;
return _pData->thread;
}

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

@ -36,95 +36,95 @@ namespace Poco {
class Foundation_API ThreadImpl
{
public:
typedef int TIDImpl;
typedef void (*Callable)(void*);
typedef int TIDImpl;
typedef void (*Callable)(void*);
enum Priority
{
PRIO_LOWEST_IMPL,
PRIO_LOW_IMPL,
PRIO_NORMAL_IMPL,
PRIO_HIGH_IMPL,
PRIO_HIGHEST_IMPL
};
enum Priority
{
PRIO_LOWEST_IMPL,
PRIO_LOW_IMPL,
PRIO_NORMAL_IMPL,
PRIO_HIGH_IMPL,
PRIO_HIGHEST_IMPL
};
enum Policy
{
POLICY_DEFAULT_IMPL = 0
};
enum Policy
{
POLICY_DEFAULT_IMPL = 0
};
enum
{
DEFAULT_THREAD_STACK_SIZE = 65536
};
enum
{
DEFAULT_THREAD_STACK_SIZE = 65536
};
struct CallbackData: public RefCountedObject
{
CallbackData(): callback(0), pData(0)
{
}
struct CallbackData: public RefCountedObject
{
CallbackData(): callback(0), pData(0)
{
}
Callable callback;
void* pData;
};
Callable callback;
void* pData;
};
ThreadImpl();
~ThreadImpl();
ThreadImpl();
~ThreadImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = 0);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = 0);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void startImpl(Runnable& target);
void startImpl(Callable target, void* pData = 0);
void startImpl(Runnable& target);
void startImpl(Callable target, void* pData = 0);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
protected:
static void runnableEntry(void* pThread, int, int, int, int, int, int, int, int, int);
static void callableEntry(void* pThread, int, int, int, int, int, int, int, int, int);
static int mapPrio(int prio);
static int reverseMapPrio(int osPrio);
static void runnableEntry(void* pThread, int, int, int, int, int, int, int, int, int);
static void callableEntry(void* pThread, int, int, int, int, int, int, int, int, int);
static int mapPrio(int prio);
static int reverseMapPrio(int osPrio);
struct ThreadData: public RefCountedObject
{
ThreadData():
pRunnableTarget(0),
pCallbackTarget(0),
task(0),
prio(PRIO_NORMAL_IMPL),
osPrio(127),
done(false),
stackSize(POCO_THREAD_STACK_SIZE)
{
}
struct ThreadData: public RefCountedObject
{
ThreadData():
pRunnableTarget(0),
pCallbackTarget(0),
task(0),
prio(PRIO_NORMAL_IMPL),
osPrio(127),
done(false),
stackSize(POCO_THREAD_STACK_SIZE)
{
}
Runnable* pRunnableTarget;
AutoPtr<CallbackData> pCallbackTarget;
int task;
int prio;
int osPrio;
Event done;
int stackSize;
};
Runnable* pRunnableTarget;
AutoPtr<CallbackData> pCallbackTarget;
int task;
int prio;
int osPrio;
Event done;
int stackSize;
};
private:
AutoPtr<ThreadData> _pData;
static ThreadImpl* _pCurrent;
AutoPtr<ThreadData> _pData;
static ThreadImpl* _pCurrent;
};
@ -133,48 +133,48 @@ private:
//
inline int ThreadImpl::getPriorityImpl() const
{
return _pData->prio;
return _pData->prio;
}
inline int ThreadImpl::getOSPriorityImpl() const
{
return _pData->osPrio;
return _pData->osPrio;
}
inline void ThreadImpl::setAffinityImpl(unsigned cpu)
{
(void)cpu;
throw Poco::NotImplementedException("Thread affinity not supported on this system");
(void)cpu;
throw Poco::NotImplementedException("Thread affinity not supported on this system");
}
inline unsigned ThreadImpl::getAffinityImpl()
{
throw Poco::NotImplementedException("Thread affinity not supported on this system");
throw Poco::NotImplementedException("Thread affinity not supported on this system");
}
inline bool ThreadImpl::isRunningImpl() const
{
return _pData->pRunnableTarget != 0 ||
(_pData->pCallbackTarget.get() != 0 && _pData->pCallbackTarget->callback != 0);
return _pData->pRunnableTarget != 0 ||
(_pData->pCallbackTarget.get() != 0 && _pData->pCallbackTarget->callback != 0);
}
inline void ThreadImpl::yieldImpl()
{
taskDelay(0);
taskDelay(0);
}
inline int ThreadImpl::getStackSizeImpl() const
{
return _pData->stackSize;
return _pData->stackSize;
}
inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
{
return _pData->task;
return _pData->task;
}

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

@ -32,95 +32,95 @@ namespace Poco {
class Foundation_API ThreadImpl
{
public:
typedef DWORD TIDImpl;
typedef void (*Callable)(void*);
typedef DWORD TIDImpl;
typedef void (*Callable)(void*);
#if defined(_DLL)
typedef DWORD (WINAPI* Entry)(LPVOID);
typedef DWORD (WINAPI* Entry)(LPVOID);
#else
typedef unsigned (__stdcall* Entry)(void*);
typedef unsigned (__stdcall* Entry)(void*);
#endif
enum Priority
{
PRIO_LOWEST_IMPL = THREAD_PRIORITY_LOWEST,
PRIO_LOW_IMPL = THREAD_PRIORITY_BELOW_NORMAL,
PRIO_NORMAL_IMPL = THREAD_PRIORITY_NORMAL,
PRIO_HIGH_IMPL = THREAD_PRIORITY_ABOVE_NORMAL,
PRIO_HIGHEST_IMPL = THREAD_PRIORITY_HIGHEST
};
enum Priority
{
PRIO_LOWEST_IMPL = THREAD_PRIORITY_LOWEST,
PRIO_LOW_IMPL = THREAD_PRIORITY_BELOW_NORMAL,
PRIO_NORMAL_IMPL = THREAD_PRIORITY_NORMAL,
PRIO_HIGH_IMPL = THREAD_PRIORITY_ABOVE_NORMAL,
PRIO_HIGHEST_IMPL = THREAD_PRIORITY_HIGHEST
};
enum Policy
{
POLICY_DEFAULT_IMPL = 0
};
enum Policy
{
POLICY_DEFAULT_IMPL = 0
};
ThreadImpl();
~ThreadImpl();
ThreadImpl();
~ThreadImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = 0);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
int getStackSizeImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = 0);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
int getStackSizeImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
protected:
#if defined(_DLL)
static DWORD WINAPI runnableEntry(LPVOID pThread);
static DWORD WINAPI runnableEntry(LPVOID pThread);
#else
static unsigned __stdcall runnableEntry(void* pThread);
static unsigned __stdcall runnableEntry(void* pThread);
#endif
void createImpl(Entry ent, void* pData);
void threadCleanup();
void createImpl(Entry ent, void* pData);
void threadCleanup();
private:
class CurrentThreadHolder
{
public:
CurrentThreadHolder(): _slot(TlsAlloc())
{
if (_slot == TLS_OUT_OF_INDEXES)
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
TlsFree(_slot);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(TlsGetValue(_slot));
}
void set(ThreadImpl* pThread)
{
TlsSetValue(_slot, pThread);
}
class CurrentThreadHolder
{
public:
CurrentThreadHolder(): _slot(TlsAlloc())
{
if (_slot == TLS_OUT_OF_INDEXES)
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
TlsFree(_slot);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(TlsGetValue(_slot));
}
void set(ThreadImpl* pThread)
{
TlsSetValue(_slot, pThread);
}
private:
DWORD _slot;
};
private:
DWORD _slot;
};
SharedPtr<Runnable> _pRunnableTarget;
HANDLE _thread;
DWORD _threadId;
int _prio;
int _stackSize;
SharedPtr<Runnable> _pRunnableTarget;
HANDLE _thread;
DWORD _threadId;
int _prio;
int _stackSize;
static CurrentThreadHolder _currentThreadHolder;
static CurrentThreadHolder _currentThreadHolder;
};
@ -129,55 +129,55 @@ private:
//
inline int ThreadImpl::getPriorityImpl() const
{
return _prio;
return _prio;
}
inline int ThreadImpl::getOSPriorityImpl() const
{
return _prio;
return _prio;
}
inline int ThreadImpl::getMinOSPriorityImpl(int /* policy */)
{
return PRIO_LOWEST_IMPL;
return PRIO_LOWEST_IMPL;
}
inline int ThreadImpl::getMaxOSPriorityImpl(int /* policy */)
{
return PRIO_HIGHEST_IMPL;
return PRIO_HIGHEST_IMPL;
}
inline void ThreadImpl::sleepImpl(long milliseconds)
{
Sleep(DWORD(milliseconds));
Sleep(DWORD(milliseconds));
}
inline void ThreadImpl::yieldImpl()
{
Sleep(0);
Sleep(0);
}
inline void ThreadImpl::setStackSizeImpl(int size)
{
_stackSize = size;
_stackSize = size;
}
inline int ThreadImpl::getStackSizeImpl() const
{
return _stackSize;
return _stackSize;
}
inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
{
return _threadId;
return _threadId;
}

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

@ -37,86 +37,86 @@ namespace Poco {
class Foundation_API ThreadImpl
{
public:
typedef DWORD TIDImpl;
typedef void (*Callable)(void*);
typedef DWORD (WINAPI* Entry)(LPVOID);
typedef DWORD TIDImpl;
typedef void (*Callable)(void*);
typedef DWORD (WINAPI* Entry)(LPVOID);
enum Priority
{
PRIO_LOWEST_IMPL = THREAD_PRIORITY_LOWEST,
PRIO_LOW_IMPL = THREAD_PRIORITY_BELOW_NORMAL,
PRIO_NORMAL_IMPL = THREAD_PRIORITY_NORMAL,
PRIO_HIGH_IMPL = THREAD_PRIORITY_ABOVE_NORMAL,
PRIO_HIGHEST_IMPL = THREAD_PRIORITY_HIGHEST
};
enum Priority
{
PRIO_LOWEST_IMPL = THREAD_PRIORITY_LOWEST,
PRIO_LOW_IMPL = THREAD_PRIORITY_BELOW_NORMAL,
PRIO_NORMAL_IMPL = THREAD_PRIORITY_NORMAL,
PRIO_HIGH_IMPL = THREAD_PRIORITY_ABOVE_NORMAL,
PRIO_HIGHEST_IMPL = THREAD_PRIORITY_HIGHEST
};
enum Policy
{
POLICY_DEFAULT_IMPL = 0
};
enum Policy
{
POLICY_DEFAULT_IMPL = 0
};
ThreadImpl();
~ThreadImpl();
ThreadImpl();
~ThreadImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = 0);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
TIDImpl tidImpl() const;
void setPriorityImpl(int prio);
int getPriorityImpl() const;
void setOSPriorityImpl(int prio, int policy = 0);
int getOSPriorityImpl() const;
static int getMinOSPriorityImpl(int policy);
static int getMaxOSPriorityImpl(int policy);
void setStackSizeImpl(int size);
int getStackSizeImpl() const;
void setAffinityImpl(unsigned cpu);
unsigned getAffinityImpl() const;
void startImpl(SharedPtr<Runnable> pTarget);
void joinImpl();
bool joinImpl(long milliseconds);
bool isRunningImpl() const;
static void sleepImpl(long milliseconds);
static void yieldImpl();
static ThreadImpl* currentImpl();
static TIDImpl currentTidImpl();
protected:
static DWORD WINAPI runnableEntry(LPVOID pThread);
static DWORD WINAPI runnableEntry(LPVOID pThread);
void createImpl(Entry ent, void* pData);
void threadCleanup();
void createImpl(Entry ent, void* pData);
void threadCleanup();
private:
class CurrentThreadHolder
{
public:
CurrentThreadHolder(): _slot(TlsAlloc())
{
if (_slot == TLS_OUT_OF_INDEXES)
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
TlsFree(_slot);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(TlsGetValue(_slot));
}
void set(ThreadImpl* pThread)
{
TlsSetValue(_slot, pThread);
}
class CurrentThreadHolder
{
public:
CurrentThreadHolder(): _slot(TlsAlloc())
{
if (_slot == TLS_OUT_OF_INDEXES)
throw SystemException("cannot allocate thread context key");
}
~CurrentThreadHolder()
{
TlsFree(_slot);
}
ThreadImpl* get() const
{
return reinterpret_cast<ThreadImpl*>(TlsGetValue(_slot));
}
void set(ThreadImpl* pThread)
{
TlsSetValue(_slot, pThread);
}
private:
DWORD _slot;
};
private:
DWORD _slot;
};
SharedPtr<Runnable> _pRunnableTarget;
HANDLE _thread;
DWORD _threadId;
int _prio;
int _stackSize;
SharedPtr<Runnable> _pRunnableTarget;
HANDLE _thread;
DWORD _threadId;
int _prio;
int _stackSize;
static CurrentThreadHolder _currentThreadHolder;
static CurrentThreadHolder _currentThreadHolder;
};
@ -125,65 +125,65 @@ private:
//
inline int ThreadImpl::getPriorityImpl() const
{
return _prio;
return _prio;
}
inline int ThreadImpl::getOSPriorityImpl() const
{
return _prio;
return _prio;
}
inline int ThreadImpl::getMinOSPriorityImpl(int /* policy */)
{
return PRIO_LOWEST_IMPL;
return PRIO_LOWEST_IMPL;
}
inline int ThreadImpl::getMaxOSPriorityImpl(int /* policy */)
{
return PRIO_HIGHEST_IMPL;
return PRIO_HIGHEST_IMPL;
}
inline void ThreadImpl::setAffinityImpl(unsigned cpu)
{
(void)cpu;
throw Poco::NotImplementedException("Thread affinity not supported on this system");
(void)cpu;
throw Poco::NotImplementedException("Thread affinity not supported on this system");
}
inline unsigned ThreadImpl::getAffinityImpl()
{
throw Poco::NotImplementedException("Thread affinity not supported on this system");
throw Poco::NotImplementedException("Thread affinity not supported on this system");
}
inline void ThreadImpl::sleepImpl(long milliseconds)
{
Sleep(DWORD(milliseconds));
Sleep(DWORD(milliseconds));
}
inline void ThreadImpl::yieldImpl()
{
Sleep(0);
Sleep(0);
}
inline void ThreadImpl::setStackSizeImpl(int size)
{
_stackSize = size;
_stackSize = size;
}
inline int ThreadImpl::getStackSizeImpl() const
{
return _stackSize;
return _stackSize;
}
inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
{
return _threadId;
return _threadId;
}

564
Foundation/src/Thread_POSIX.cpp
View File

@ -43,16 +43,16 @@ namespace {
class SignalBlocker
{
public:
SignalBlocker()
{
sigset_t sset;
sigemptyset(&sset);
sigaddset(&sset, SIGPIPE);
pthread_sigmask(SIG_BLOCK, &sset, 0);
}
~SignalBlocker()
{
}
SignalBlocker()
{
sigset_t sset;
sigemptyset(&sset);
sigaddset(&sset, SIGPIPE);
pthread_sigmask(SIG_BLOCK, &sset, 0);
}
~SignalBlocker()
{
}
};
static SignalBlocker signalBlocker;
@ -67,9 +67,9 @@ namespace {
void setThreadName(pthread_t thread, const char* threadName)
{
# if (POCO_OS == POCO_OS_MAC_OS_X)
pthread_setname_np(threadName); // __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
pthread_setname_np(threadName); // __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
# else
pthread_setname_np(thread, threadName);
pthread_setname_np(thread, threadName);
# endif
}
}
@ -85,67 +85,67 @@ ThreadImpl::CurrentThreadHolder ThreadImpl::_currentThreadHolder;
ThreadImpl::ThreadImpl():
_pData(new ThreadData)
_pData(new ThreadData)
{
}
ThreadImpl::~ThreadImpl()
{
if (_pData->started && !_pData->joined)
{
pthread_detach(_pData->thread);
}
if (_pData->started && !_pData->joined)
{
pthread_detach(_pData->thread);
}
}
void ThreadImpl::setPriorityImpl(int prio)
{
if (prio != _pData->prio)
{
_pData->prio = prio;
_pData->policy = SCHED_OTHER;
if (isRunningImpl())
{
struct sched_param par;
struct MyStruct
{
if (prio != _pData->prio)
{
_pData->prio = prio;
_pData->policy = SCHED_OTHER;
if (isRunningImpl())
{
struct sched_param par;
struct MyStruct
{
};
par.sched_priority = mapPrio(_pData->prio, SCHED_OTHER);
if (pthread_setschedparam(_pData->thread, SCHED_OTHER, &par))
throw SystemException("cannot set thread priority");
}
}
};
par.sched_priority = mapPrio(_pData->prio, SCHED_OTHER);
if (pthread_setschedparam(_pData->thread, SCHED_OTHER, &par))
throw SystemException("cannot set thread priority");
}
}
}
void ThreadImpl::setOSPriorityImpl(int prio, int policy)
{
if (prio != _pData->osPrio || policy != _pData->policy)
{
if (_pData->pRunnableTarget)
{
struct sched_param par;
par.sched_priority = prio;
if (pthread_setschedparam(_pData->thread, policy, &par))
throw SystemException("cannot set thread priority");
}
_pData->prio = reverseMapPrio(prio, policy);
_pData->osPrio = prio;
_pData->policy = policy;
}
if (prio != _pData->osPrio || policy != _pData->policy)
{
if (_pData->pRunnableTarget)
{
struct sched_param par;
par.sched_priority = prio;
if (pthread_setschedparam(_pData->thread, policy, &par))
throw SystemException("cannot set thread priority");
}
_pData->prio = reverseMapPrio(prio, policy);
_pData->osPrio = prio;
_pData->policy = policy;
}
}
int ThreadImpl::getMinOSPriorityImpl(int policy)
{
#if defined(POCO_THREAD_PRIORITY_MIN)
return POCO_THREAD_PRIORITY_MIN;
return POCO_THREAD_PRIORITY_MIN;
#elif defined(__VMS) || defined(__digital__)
return PRI_OTHER_MIN;
return PRI_OTHER_MIN;
#else
return sched_get_priority_min(policy);
return sched_get_priority_min(policy);
#endif
}
@ -153,11 +153,11 @@ int ThreadImpl::getMinOSPriorityImpl(int policy)
int ThreadImpl::getMaxOSPriorityImpl(int policy)
{
#if defined(POCO_THREAD_PRIORITY_MAX)
return POCO_THREAD_PRIORITY_MAX;
return POCO_THREAD_PRIORITY_MAX;
#elif defined(__VMS) || defined(__digital__)
return PRI_OTHER_MAX;
return PRI_OTHER_MAX;
#else
return sched_get_priority_max(policy);
return sched_get_priority_max(policy);
#endif
}
@ -165,21 +165,21 @@ int ThreadImpl::getMaxOSPriorityImpl(int policy)
void ThreadImpl::setStackSizeImpl(int size)
{
#ifndef PTHREAD_STACK_MIN
_pData->stackSize = 0;
_pData->stackSize = 0;
#else
if (size != 0)
{
if (size != 0)
{
#if defined(POCO_OS_FAMILY_BSD)
// we must round up to a multiple of the memory page size
const int STACK_PAGE_SIZE = 4096;
size = ((size + STACK_PAGE_SIZE - 1) / STACK_PAGE_SIZE) * STACK_PAGE_SIZE;
// we must round up to a multiple of the memory page size
const int STACK_PAGE_SIZE = 4096;
size = ((size + STACK_PAGE_SIZE - 1) / STACK_PAGE_SIZE) * STACK_PAGE_SIZE;
#endif
#if !defined(POCO_ANDROID)
if (size < PTHREAD_STACK_MIN)
size = PTHREAD_STACK_MIN;
if (size < PTHREAD_STACK_MIN)
size = PTHREAD_STACK_MIN;
#endif
}
_pData->stackSize = size;
}
_pData->stackSize = size;
#endif
}
@ -187,313 +187,313 @@ void ThreadImpl::setAffinityImpl(unsigned cpu)
{
#if defined (POCO_OS_FAMILY_UNIX) && POCO_OS != POCO_OS_MAC_OS_X
#ifdef HAVE_PTHREAD_SETAFFINITY_NP
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpu, &cpuset);
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpu, &cpuset);
#ifdef HAVE_THREE_PARAM_SCHED_SETAFFINITY
if (pthread_setaffinity_np(_pData->thread, sizeof(cpuset), &cpuset) != 0)
throw SystemException("Failed to set affinity");
if (pthread_setaffinity_np(_pData->thread, sizeof(cpuset), &cpuset) != 0)
throw SystemException("Failed to set affinity");
#else
if (pthread_setaffinity_np(_pData->thread, &cpuset) != 0)
throw SystemException("Failed to set affinity");
if (pthread_setaffinity_np(_pData->thread, &cpuset) != 0)
throw SystemException("Failed to set affinity");
#endif
#else
throw Poco::NotImplementedException("Thread affinity not supported on this system");
throw Poco::NotImplementedException("Thread affinity not supported on this system");
#endif
#endif // defined unix & !defined mac os x
#if POCO_OS == POCO_OS_MAC_OS_X
kern_return_t ret;
thread_affinity_policy policy;
policy.affinity_tag = cpu;
kern_return_t ret;
thread_affinity_policy policy;
policy.affinity_tag = cpu;
ret = thread_policy_set(pthread_mach_thread_np(_pData->thread),
THREAD_AFFINITY_POLICY,
(thread_policy_t) &policy,
THREAD_AFFINITY_POLICY_COUNT);
if (ret != KERN_SUCCESS)
{
throw SystemException("Failed to set affinity");
}
ret = thread_policy_set(pthread_mach_thread_np(_pData->thread),
THREAD_AFFINITY_POLICY,
(thread_policy_t) &policy,
THREAD_AFFINITY_POLICY_COUNT);
if (ret != KERN_SUCCESS)
{
throw SystemException("Failed to set affinity");
}
#endif
yieldImpl();
yieldImpl();
}
unsigned ThreadImpl::getAffinityImpl() const
{
unsigned cpuSet = 0;
unsigned cpuCount = Environment::processorCount();
unsigned cpuSet = 0;
unsigned 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;
CPU_ZERO(&cpuset);
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
#ifdef HAVE_THREE_PARAM_SCHED_SETAFFINITY
if (pthread_getaffinity_np(_pData->thread, sizeof(cpuset), &cpuset) != 0)
throw SystemException("Failed to get affinity", errno);
if (pthread_getaffinity_np(_pData->thread, sizeof(cpuset), &cpuset) != 0)
throw SystemException("Failed to get affinity", errno);
#else
if (pthread_getaffinity_np(_pData->thread, &cpuset) != 0)
throw SystemException("Failed to get affinity", errno);
if (pthread_getaffinity_np(_pData->thread, &cpuset) != 0)
throw SystemException("Failed to get affinity", errno);
#endif
for (unsigned i = 0; i < cpuCount; i++)
{
if (CPU_ISSET(i, &cpuset))
{
cpuSet = i;
break;
}
}
for (unsigned i = 0; i < cpuCount; i++)
{
if (CPU_ISSET(i, &cpuset))
{
cpuSet = i;
break;
}
}
#else
throw Poco::NotImplementedException("Thread affinity not supported on this system");
throw Poco::NotImplementedException("Thread affinity not supported on this system");
#endif
#endif // defined unix & !defined mac os x
#if POCO_OS == POCO_OS_MAC_OS_X
kern_return_t ret;
thread_affinity_policy policy;
mach_msg_type_number_t count = THREAD_AFFINITY_POLICY_COUNT;
boolean_t get_default = FALSE;
ret = thread_policy_get(pthread_mach_thread_np(_pData->thread),
THREAD_AFFINITY_POLICY,
(thread_policy_t)&policy,
&count,
&get_default);
if (ret != KERN_SUCCESS)
{
throw SystemException("Failed to get affinity", errno);
}
cpuSet = policy.affinity_tag;
if (cpuSet >= cpuCount)
cpuSet = 0;
kern_return_t ret;
thread_affinity_policy policy;
mach_msg_type_number_t count = THREAD_AFFINITY_POLICY_COUNT;
boolean_t get_default = FALSE;
ret = thread_policy_get(pthread_mach_thread_np(_pData->thread),
THREAD_AFFINITY_POLICY,
(thread_policy_t)&policy,
&count,
&get_default);
if (ret != KERN_SUCCESS)
{
throw SystemException("Failed to get affinity", errno);
}
cpuSet = policy.affinity_tag;
if (cpuSet >= cpuCount)
cpuSet = 0;
#endif
return cpuSet;
return cpuSet;
}
void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
{
if (_pData->pRunnableTarget)
throw SystemException("thread already running");
if (_pData->pRunnableTarget)
throw SystemException("thread already running");
pthread_attr_t attributes;
pthread_attr_init(&attributes);
pthread_attr_t attributes;
pthread_attr_init(&attributes);
if (_pData->stackSize != 0)
{
if (0 != pthread_attr_setstacksize(&attributes, _pData->stackSize))
{
pthread_attr_destroy(&attributes);
throw SystemException("cannot set thread stack size");
}
}
if (_pData->stackSize != 0)
{
if (0 != pthread_attr_setstacksize(&attributes, _pData->stackSize))
{
pthread_attr_destroy(&attributes);
throw SystemException("cannot set thread stack size");
}
}
_pData->pRunnableTarget = pTarget;
if (pthread_create(&_pData->thread, &attributes, runnableEntry, this))
{
_pData->pRunnableTarget = 0;
pthread_attr_destroy(&attributes);
throw SystemException("cannot start thread");
}
_pData->started = true;
pthread_attr_destroy(&attributes);
_pData->pRunnableTarget = pTarget;
if (pthread_create(&_pData->thread, &attributes, runnableEntry, this))
{
_pData->pRunnableTarget = 0;
pthread_attr_destroy(&attributes);
throw SystemException("cannot start thread");
}
_pData->started = true;
pthread_attr_destroy(&attributes);
if (_pData->policy == SCHED_OTHER)
{
if (_pData->prio != PRIO_NORMAL_IMPL)
{
struct sched_param par;
par.sched_priority = mapPrio(_pData->prio, SCHED_OTHER);
if (pthread_setschedparam(_pData->thread, SCHED_OTHER, &par))
throw SystemException("cannot set thread priority");
}
}
else
{
struct sched_param par;
par.sched_priority = _pData->osPrio;
if (pthread_setschedparam(_pData->thread, _pData->policy, &par))
throw SystemException("cannot set thread priority");
}
if (_pData->policy == SCHED_OTHER)
{
if (_pData->prio != PRIO_NORMAL_IMPL)
{
struct sched_param par;
par.sched_priority = mapPrio(_pData->prio, SCHED_OTHER);
if (pthread_setschedparam(_pData->thread, SCHED_OTHER, &par))
throw SystemException("cannot set thread priority");
}
}
else
{
struct sched_param par;
par.sched_priority = _pData->osPrio;
if (pthread_setschedparam(_pData->thread, _pData->policy, &par))
throw SystemException("cannot set thread priority");
}
}
void ThreadImpl::joinImpl()
{
if (!_pData->started) return;
_pData->done.wait();
void* result;
if (pthread_join(_pData->thread, &result))
throw SystemException("cannot join thread");
_pData->joined = true;
if (!_pData->started) return;
_pData->done.wait();
void* result;
if (pthread_join(_pData->thread, &result))
throw SystemException("cannot join thread");
_pData->joined = true;
}
bool ThreadImpl::joinImpl(long milliseconds)
{
if (_pData->started && _pData->done.tryWait(milliseconds))
{
void* result;
if (pthread_join(_pData->thread, &result))
throw SystemException("cannot join thread");
_pData->joined = true;
return true;
}
else if (_pData->started) return false;
else return true;
if (_pData->started && _pData->done.tryWait(milliseconds))
{
void* result;
if (pthread_join(_pData->thread, &result))
throw SystemException("cannot join thread");
_pData->joined = true;
return true;
}
else if (_pData->started) return false;
else return true;
}
ThreadImpl* ThreadImpl::currentImpl()
{
return _currentThreadHolder.get();
return _currentThreadHolder.get();
}
ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
{
return pthread_self();
return pthread_self();
}
void ThreadImpl::sleepImpl(long milliseconds)
{
#if defined(__VMS) || defined(__digital__)
// This is specific to DECThreads
struct timespec interval;
interval.tv_sec = milliseconds / 1000;
interval.tv_nsec = (milliseconds % 1000) * 1000000;
pthread_delay_np(&interval);
// This is specific to DECThreads
struct timespec interval;
interval.tv_sec = milliseconds / 1000;
interval.tv_nsec = (milliseconds % 1000) * 1000000;
pthread_delay_np(&interval);
#elif POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_QNX || POCO_OS == POCO_OS_VXWORKS
Poco::Timespan remainingTime(1000 * Poco::Timespan::TimeDiff(milliseconds));
int rc;
do
{
struct timespec ts;
ts.tv_sec = (long) remainingTime.totalSeconds();
ts.tv_nsec = (long) remainingTime.useconds() * 1000;
Poco::Timestamp start;
rc = ::nanosleep(&ts, 0);
if (rc < 0 && errno == EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): nanosleep() failed");
Poco::Timespan remainingTime(1000 * Poco::Timespan::TimeDiff(milliseconds));
int rc;
do
{
struct timespec ts;
ts.tv_sec = (long) remainingTime.totalSeconds();
ts.tv_nsec = (long) remainingTime.useconds() * 1000;
Poco::Timestamp start;
rc = ::nanosleep(&ts, 0);
if (rc < 0 && errno == EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): nanosleep() failed");
#else
Poco::Timespan remainingTime(1000 * Poco::Timespan::TimeDiff(milliseconds));
int rc;
do
{
struct timeval tv;
tv.tv_sec = (long) remainingTime.totalSeconds();
tv.tv_usec = (long) remainingTime.useconds();
Poco::Timestamp start;
rc = ::select(0, NULL, NULL, NULL, &tv);
if (rc < 0 && errno == EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): select() failed");
Poco::Timespan remainingTime(1000 * Poco::Timespan::TimeDiff(milliseconds));
int rc;
do
{
struct timeval tv;
tv.tv_sec = (long) remainingTime.totalSeconds();
tv.tv_usec = (long) remainingTime.useconds();
Poco::Timestamp start;
rc = ::select(0, NULL, NULL, NULL, &tv);
if (rc < 0 && errno == EINTR)
{
Poco::Timestamp end;
Poco::Timespan waited = start.elapsed();
if (waited < remainingTime)
remainingTime -= waited;
else
remainingTime = 0;
}
}
while (remainingTime > 0 && rc < 0 && errno == EINTR);
if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): select() failed");
#endif
}
void* ThreadImpl::runnableEntry(void* pThread)
{
_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
#if defined(POCO_OS_FAMILY_UNIX)
sigset_t sset;
sigemptyset(&sset);
sigaddset(&sset, SIGQUIT);
sigaddset(&sset, SIGTERM);
sigaddset(&sset, SIGPIPE);
pthread_sigmask(SIG_BLOCK, &sset, 0);
sigset_t sset;
sigemptyset(&sset);
sigaddset(&sset, SIGQUIT);
sigaddset(&sset, SIGTERM);
sigaddset(&sset, SIGPIPE);
pthread_sigmask(SIG_BLOCK, &sset, 0);
#endif
ThreadImpl* pThreadImpl = reinterpret_cast<ThreadImpl*>(pThread);
ThreadImpl* pThreadImpl = reinterpret_cast<ThreadImpl*>(pThread);
#if defined(POCO_POSIX_DEBUGGER_THREAD_NAMES)
setThreadName(pThreadImpl->_pData->thread, reinterpret_cast<Thread*>(pThread)->getName().c_str());
setThreadName(pThreadImpl->_pData->thread, reinterpret_cast<Thread*>(pThread)->getName().c_str());
#endif
AutoPtr<ThreadData> pData = pThreadImpl->_pData;
try
{
pData->pRunnableTarget->run();
}
catch (Exception& exc)
{
ErrorHandler::handle(exc);
}
catch (std::exception& exc)
{
ErrorHandler::handle(exc);
}
catch (...)
{
ErrorHandler::handle();
}
AutoPtr<ThreadData> pData = pThreadImpl->_pData;
try
{
pData->pRunnableTarget->run();
}
catch (Exception& exc)
{
ErrorHandler::handle(exc);
}
catch (std::exception& exc)
{
ErrorHandler::handle(exc);
}
catch (...)
{
ErrorHandler::handle();
}
pData->pRunnableTarget = 0;
pData->done.set();
return 0;
pData->pRunnableTarget = 0;
pData->done.set();
return 0;
}
int ThreadImpl::mapPrio(int prio, int policy)
{
int pmin = getMinOSPriorityImpl(policy);
int pmax = getMaxOSPriorityImpl(policy);
int pmin = getMinOSPriorityImpl(policy);
int pmax = getMaxOSPriorityImpl(policy);
switch (prio)
{
case PRIO_LOWEST_IMPL:
return pmin;
case PRIO_LOW_IMPL:
return pmin + (pmax - pmin) / 4;
case PRIO_NORMAL_IMPL:
return pmin + (pmax - pmin) / 2;
case PRIO_HIGH_IMPL:
return pmin + 3 * (pmax - pmin) / 4;
case PRIO_HIGHEST_IMPL:
return pmax;
default:
poco_bugcheck_msg("invalid thread priority");
}
return -1; // just to satisfy compiler - we'll never get here anyway
switch (prio)
{
case PRIO_LOWEST_IMPL:
return pmin;
case PRIO_LOW_IMPL:
return pmin + (pmax - pmin) / 4;
case PRIO_NORMAL_IMPL:
return pmin + (pmax - pmin) / 2;
case PRIO_HIGH_IMPL:
return pmin + 3 * (pmax - pmin) / 4;
case PRIO_HIGHEST_IMPL:
return pmax;
default:
poco_bugcheck_msg("invalid thread priority");
}
return -1; // just to satisfy compiler - we'll never get here anyway
}
int ThreadImpl::reverseMapPrio(int prio, int policy)
{
if (policy == SCHED_OTHER)
{
int pmin = getMinOSPriorityImpl(policy);
int pmax = getMaxOSPriorityImpl(policy);
int normal = pmin + (pmax - pmin) / 2;
if (prio == pmax)
return PRIO_HIGHEST_IMPL;
if (prio > normal)
return PRIO_HIGH_IMPL;
else if (prio == normal)
return PRIO_NORMAL_IMPL;
else if (prio > pmin)
return PRIO_LOW_IMPL;
else
return PRIO_LOWEST_IMPL;
}
else return PRIO_HIGHEST_IMPL;
if (policy == SCHED_OTHER)
{
int pmin = getMinOSPriorityImpl(policy);
int pmax = getMaxOSPriorityImpl(policy);
int normal = pmin + (pmax - pmin) / 2;
if (prio == pmax)
return PRIO_HIGHEST_IMPL;
if (prio > normal)
return PRIO_HIGH_IMPL;
else if (prio == normal)
return PRIO_NORMAL_IMPL;
else if (prio > pmin)
return PRIO_LOW_IMPL;
else
return PRIO_LOWEST_IMPL;
}
else return PRIO_HIGHEST_IMPL;
}

146
Foundation/src/Thread_WINCE.cpp
View File

@ -26,145 +26,145 @@ ThreadImpl::CurrentThreadHolder ThreadImpl::_currentThreadHolder;
ThreadImpl::ThreadImpl():
_pRunnableTarget(0),
_thread(0),
_threadId(0),
_prio(PRIO_NORMAL_IMPL),
_stackSize(POCO_THREAD_STACK_SIZE)
_pRunnableTarget(0),
_thread(0),
_threadId(0),
_prio(PRIO_NORMAL_IMPL),
_stackSize(POCO_THREAD_STACK_SIZE)
{
}
ThreadImpl::~ThreadImpl()
{
if (_thread) CloseHandle(_thread);
if (_thread) CloseHandle(_thread);
}
void ThreadImpl::setPriorityImpl(int prio)
{
if (prio != _prio)
{
_prio = prio;
if (_thread)
{
if (SetThreadPriority(_thread, _prio) == 0)
throw SystemException("cannot set thread priority");
}
}
if (prio != _prio)
{
_prio = prio;
if (_thread)
{
if (SetThreadPriority(_thread, _prio) == 0)
throw SystemException("cannot set thread priority");
}
}
}
void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
{
setPriorityImpl(prio);
setPriorityImpl(prio);
}
void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
{
if (isRunningImpl())
throw SystemException("thread already running");
if (isRunningImpl())
throw SystemException("thread already running");
_pRunnableTarget = pTarget;
_pRunnableTarget = pTarget;
createImpl(runnableEntry, this);
createImpl(runnableEntry, this);
}
void ThreadImpl::createImpl(Entry ent, void* pData)
{
_thread = CreateThread(NULL, _stackSize, ent, pData, 0, &_threadId);
_thread = CreateThread(NULL, _stackSize, ent, pData, 0, &_threadId);
if (!_thread)
throw SystemException("cannot create thread");
if (_prio != PRIO_NORMAL_IMPL && !SetThreadPriority(_thread, _prio))
throw SystemException("cannot set thread priority");
if (!_thread)
throw SystemException("cannot create thread");
if (_prio != PRIO_NORMAL_IMPL && !SetThreadPriority(_thread, _prio))
throw SystemException("cannot set thread priority");
}
void ThreadImpl::joinImpl()
{
if (!_thread) return;
if (!_thread) return;
switch (WaitForSingleObject(_thread, INFINITE))
{
case WAIT_OBJECT_0:
threadCleanup();
return;
default:
throw SystemException("cannot join thread");
}
switch (WaitForSingleObject(_thread, INFINITE))
{
case WAIT_OBJECT_0:
threadCleanup();
return;
default:
throw SystemException("cannot join thread");
}
}
bool ThreadImpl::joinImpl(long milliseconds)
{
if (!_thread) return true;
if (!_thread) return true;
switch (WaitForSingleObject(_thread, milliseconds + 1))
{
case WAIT_TIMEOUT:
return false;
case WAIT_OBJECT_0:
threadCleanup();
return true;
default:
throw SystemException("cannot join thread");
}
switch (WaitForSingleObject(_thread, milliseconds + 1))
{
case WAIT_TIMEOUT:
return false;
case WAIT_OBJECT_0:
threadCleanup();
return true;
default:
throw SystemException("cannot join thread");
}
}
bool ThreadImpl::isRunningImpl() const
{
if (_thread)
{
DWORD ec = 0;
return GetExitCodeThread(_thread, &ec) && ec == STILL_ACTIVE;
}
return false;
if (_thread)
{
DWORD ec = 0;
return GetExitCodeThread(_thread, &ec) && ec == STILL_ACTIVE;
}
return false;
}
void ThreadImpl::threadCleanup()
{
if (!_thread) return;
if (CloseHandle(_thread)) _thread = 0;
if (!_thread) return;
if (CloseHandle(_thread)) _thread = 0;
}
ThreadImpl* ThreadImpl::currentImpl()
{
return _currentThreadHolder.get();
return _currentThreadHolder.get();
}
ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
{
return GetCurrentThreadId();
return GetCurrentThreadId();
}
DWORD WINAPI ThreadImpl::runnableEntry(LPVOID pThread)
{
_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
try
{
reinterpret_cast<ThreadImpl*>(pThread)->_pRunnableTarget->run();
}
catch (Exception& exc)
{
ErrorHandler::handle(exc);
}
catch (std::exception& exc)
{
ErrorHandler::handle(exc);
}
catch (...)
{
ErrorHandler::handle();
}
return 0;
_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
try
{
reinterpret_cast<ThreadImpl*>(pThread)->_pRunnableTarget->run();
}
catch (Exception& exc)
{
ErrorHandler::handle(exc);
}
catch (std::exception& exc)
{
ErrorHandler::handle(exc);
}
catch (...)
{
ErrorHandler::handle();
}
return 0;
}

655
Foundation/testsuite/src/ThreadTest.cpp
View File

@ -36,45 +36,45 @@ using Poco::Event;
class MyRunnable: public Runnable
{
public:
MyRunnable(): _ran(false)
{
}
MyRunnable(): _ran(false)
{
}
void run()
{
Thread* pThread = Thread::current();
if (pThread)
_threadName = pThread->name();
_ran = true;
_event.wait();
}
void run()
{
Thread* pThread = Thread::current();
if (pThread)
_threadName = pThread->name();
_ran = true;
_event.wait();
}
bool ran() const
{
return _ran;
}
bool ran() const
{
return _ran;
}
const std::string& threadName() const
{
return _threadName;
}
const std::string& threadName() const
{
return _threadName;
}
void notify()
{
_event.set();
}
void notify()
{
_event.set();
}
static void staticFunc()
{
++_staticVar;
}
static void staticFunc()
{
++_staticVar;
}
static int _staticVar;
static int _staticVar;
private:
bool _ran;
std::string _threadName;
Event _event;
bool _ran;
std::string _threadName;
Event _event;
};
@ -83,68 +83,68 @@ int MyRunnable::_staticVar = 0;
void freeFunc()
{
++MyRunnable::_staticVar;
++MyRunnable::_staticVar;
}
void freeFunc(void* pData)
{
MyRunnable::_staticVar += *reinterpret_cast<int*>(pData);
MyRunnable::_staticVar += *reinterpret_cast<int*>(pData);
}
class NonJoinRunnable : public Runnable
{
public:
NonJoinRunnable() : _finished(false)
{
}
NonJoinRunnable() : _finished(false)
{
}
void run()
{
_finished = true;
}
void run()
{
_finished = true;
}
bool finished() const
{
return _finished;
}
bool finished() const
{
return _finished;
}
private:
bool _finished;
bool _finished;
};
class TrySleepRunnable : public Runnable
{
public:
TrySleepRunnable() : _counter(0), _sleepy(true)
{
}
TrySleepRunnable() : _counter(0), _sleepy(true)
{
}
void run()
{
_sleepy = !Thread::trySleep(300000);
++_counter;
_sleepy = !Thread::trySleep(300000);
++_counter;
_sleepy = !Thread::trySleep(100);
++_counter;
}
void run()
{
_sleepy = !Thread::trySleep(300000);
++_counter;
_sleepy = !Thread::trySleep(300000);
++_counter;
_sleepy = !Thread::trySleep(100);
++_counter;
}
int counter() const
{
return _counter;
}
int counter() const
{
return _counter;
}
bool isSleepy() const
{
return _sleepy;
}
bool isSleepy() const
{
return _sleepy;
}
private:
int _counter;
bool _sleepy;
int _counter;
bool _sleepy;
};
@ -160,244 +160,249 @@ ThreadTest::~ThreadTest()
void ThreadTest::testThread()
{
Thread thread;
MyRunnable r;
assert (!thread.isRunning());
thread.start(r);
Thread::sleep(200);
assert (thread.isRunning());
r.notify();
thread.join();
assert (!thread.isRunning());
assert (r.ran());
assert (!r.threadName().empty());
Thread thread;
MyRunnable r;
assert (!thread.isRunning());
thread.start(r);
Thread::sleep(200);
assert (thread.isRunning());
r.notify();
thread.join();
assert (!thread.isRunning());
assert (r.ran());
assert (!r.threadName().empty());
}
void ThreadTest::testNamedThread()
{
Thread thread("MyThread");
MyRunnable r;
thread.start(r);
r.notify();
thread.join();
assert (r.ran());
assert (r.threadName() == "MyThread");
Thread thread("MyThread");
MyRunnable r;
thread.start(r);
r.notify();
thread.join();
assert (r.ran());
assert (r.threadName() == "MyThread");
}
void ThreadTest::testCurrent()
{
assertNullPtr (Thread::current());
assertNullPtr (Thread::current());
}
void ThreadTest::testThreads()
{
Thread thread1("Thread1");
Thread thread2("Thread2");
Thread thread3("Thread3");
Thread thread4("Thread4");
Thread thread1("Thread1");
Thread thread2("Thread2");
Thread thread3("Thread3");
Thread thread4("Thread4");
MyRunnable r1;
MyRunnable r2;
MyRunnable r3;
MyRunnable r4;
assert (!thread1.isRunning());
assert (!thread2.isRunning());
assert (!thread3.isRunning());
assert (!thread4.isRunning());
thread1.start(r1);
Thread::sleep(200);
assert (thread1.isRunning());
assert (!thread2.isRunning());
assert (!thread3.isRunning());
assert (!thread4.isRunning());
thread2.start(r2);
thread3.start(r3);
thread4.start(r4);
Thread::sleep(200);
assert (thread1.isRunning());
assert (thread2.isRunning());
assert (thread3.isRunning());
assert (thread4.isRunning());
r4.notify();
thread4.join();
assert (!thread4.isRunning());
assert (thread1.isRunning());
assert (thread2.isRunning());
assert (thread3.isRunning());
r3.notify();
thread3.join();
assert (!thread3.isRunning());
r2.notify();
thread2.join();
assert (!thread2.isRunning());
r1.notify();
thread1.join();
assert (!thread1.isRunning());
assert (r1.ran());
assert (r1.threadName() == "Thread1");
assert (r2.ran());
assert (r2.threadName() == "Thread2");
assert (r3.ran());
assert (r3.threadName() == "Thread3");
assert (r4.ran());
assert (r4.threadName() == "Thread4");
MyRunnable r1;
MyRunnable r2;
MyRunnable r3;
MyRunnable r4;
assert (!thread1.isRunning());
assert (!thread2.isRunning());
assert (!thread3.isRunning());
assert (!thread4.isRunning());
thread1.start(r1);
Thread::sleep(200);
assert (thread1.isRunning());
assert (!thread2.isRunning());
assert (!thread3.isRunning());
assert (!thread4.isRunning());
thread2.start(r2);
thread3.start(r3);
thread4.start(r4);
Thread::sleep(200);
assert (thread1.isRunning());
assert (thread2.isRunning());
assert (thread3.isRunning());
assert (thread4.isRunning());
r4.notify();
thread4.join();
assert (!thread4.isRunning());
assert (thread1.isRunning());
assert (thread2.isRunning());
assert (thread3.isRunning());
r3.notify();
thread3.join();
assert (!thread3.isRunning());
r2.notify();
thread2.join();
assert (!thread2.isRunning());
r1.notify();
thread1.join();
assert (!thread1.isRunning());
assert (r1.ran());
assert (r1.threadName() == "Thread1");
assert (r2.ran());
assert (r2.threadName() == "Thread2");
assert (r3.ran());
assert (r3.threadName() == "Thread3");
assert (r4.ran());
assert (r4.threadName() == "Thread4");
}
void ThreadTest::testJoin()
{
Thread thread;
MyRunnable r;
assert (!thread.isRunning());
thread.start(r);
Thread::sleep(200);
assert (thread.isRunning());
assert (!thread.tryJoin(100));
r.notify();
assert (thread.tryJoin(500));
assert (!thread.isRunning());
Thread thread;
MyRunnable r;
assert (!thread.isRunning());
thread.start(r);
Thread::sleep(200);
assert (thread.isRunning());
assert (!thread.tryJoin(100));
r.notify();
assert (thread.tryJoin(500));
assert (!thread.isRunning());
}
void ThreadTest::testNotJoin()
{
Thread thread;
NonJoinRunnable r;
thread.start(r);
Thread thread;
NonJoinRunnable r;
thread.start(r);
while (!r.finished())
{
Thread::sleep(10);
}
while (!r.finished())
{
Thread::sleep(10);
}
Thread::sleep(100);
assert (!thread.isRunning());
Thread::sleep(100);
assert (!thread.isRunning());
}
void ThreadTest::testTrySleep()
{
Thread thread;
TrySleepRunnable r;
assert(r.isSleepy());
assert(!thread.isRunning());
assert(r.counter() == 0);
thread.start(r);
assert(thread.isRunning());
assert(r.counter() == 0);
assert(r.isSleepy());
Thread::sleep(100);
assert(r.counter() == 0);
assert(r.isSleepy());
thread.wakeUp(); Thread::sleep(10);
assert(r.counter() == 1);
assert(r.isSleepy());
Thread::sleep(100);
assert(r.counter() == 1);
thread.wakeUp(); Thread::sleep(10);
assert(r.counter() == 2);
assert(r.isSleepy());
Thread::sleep(200);
assert(r.counter() == 3);
assert(!r.isSleepy());
assert(!thread.isRunning());
thread.wakeUp();
assert(!thread.isRunning());
Thread thread;
TrySleepRunnable r;
assert(r.isSleepy());
assert(!thread.isRunning());
assert(r.counter() == 0);
thread.start(r);
assert(thread.isRunning());
assert(r.counter() == 0);
assert(r.isSleepy());
Thread::sleep(100);
assert(r.counter() == 0);
assert(r.isSleepy());
thread.wakeUp();
Thread::sleep(10);
assert(r.counter() == 1);
assert(r.isSleepy());
Thread::sleep(100);
assert(r.counter() == 1);
thread.wakeUp();
Thread::sleep(10);
assert(r.counter() == 2);
assert(r.isSleepy());
Thread::sleep(200);
assert(r.counter() == 3);
assert(!r.isSleepy());
assert(!thread.isRunning());
thread.wakeUp();
assert(!thread.isRunning());
}
void ThreadTest::testNotRun()
{
Thread thread;
Thread thread;
}
void ThreadTest::testNotRunJoin()
{
Thread thread;
thread.join();
Thread thread;
thread.join();
}
void ThreadTest::testThreadTarget()
{
ThreadTarget te(&MyRunnable::staticFunc);
Thread thread;
ThreadTarget te(&MyRunnable::staticFunc);
Thread thread;
assert (!thread.isRunning());
assert (!thread.isRunning());
int tmp = MyRunnable::_staticVar;
thread.start(te);
thread.join();
assert (tmp + 1 == MyRunnable::_staticVar);
int tmp = MyRunnable::_staticVar;
thread.start(te);
thread.join();
assert (tmp + 1 == MyRunnable::_staticVar);
ThreadTarget te1(freeFunc);
assert (!thread.isRunning());
ThreadTarget te1(freeFunc);
assert (!thread.isRunning());
tmp = MyRunnable::_staticVar;
thread.start(te1);
thread.join();
assert (tmp + 1 == MyRunnable::_staticVar);
tmp = MyRunnable::_staticVar;
thread.start(te1);
thread.join();
assert (tmp + 1 == MyRunnable::_staticVar);
}
void ThreadTest::testThreadFunction()
{
Thread thread;
Thread thread;
assert (!thread.isRunning());
assert (!thread.isRunning());
int tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
int tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
assert (!thread.isRunning());
assert (!thread.isRunning());
tmp = MyRunnable::_staticVar = 0;
thread.start(freeFunc, &tmp);
thread.join();
assert (0 == MyRunnable::_staticVar);
tmp = MyRunnable::_staticVar = 0;
thread.start(freeFunc, &tmp);
thread.join();
assert (0 == MyRunnable::_staticVar);
}
struct Functor
{
void operator () ()
{
++MyRunnable::_staticVar;
}
void operator () ()
{
++MyRunnable::_staticVar;
}
};
void ThreadTest::testThreadFunctor()
{
Thread thread;
Thread thread;
assert (!thread.isRunning());
assert (!thread.isRunning());
MyRunnable::_staticVar = 0;
thread.startFunc(Functor());
thread.join();
assert (1 == MyRunnable::_staticVar);
MyRunnable::_staticVar = 0;
thread.startFunc(Functor());
thread.join();
assert (1 == MyRunnable::_staticVar);
assert (!thread.isRunning());
assert (!thread.isRunning());
#if __cplusplus >= 201103L
Thread thread2;
Thread thread2;
assert (!thread2.isRunning());
assert (!thread2.isRunning());
MyRunnable::_staticVar = 0;
thread.startFunc([] () {MyRunnable::_staticVar++;});
thread.join();
assert (1 == MyRunnable::_staticVar);
MyRunnable::_staticVar = 0;
thread.startFunc([] ()
{
MyRunnable::_staticVar++;
});
thread.join();
assert (1 == MyRunnable::_staticVar);
assert (!thread2.isRunning());
assert (!thread2.isRunning());
#endif
}
@ -405,110 +410,110 @@ void ThreadTest::testThreadFunctor()
void ThreadTest::testThreadStackSize()
{
int stackSize = 50000000;
int stackSize = 50000000;
Thread thread;
Thread thread;
assert (0 == thread.getStackSize());
thread.setStackSize(stackSize);
assert (stackSize <= thread.getStackSize());
int tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
assert (0 == thread.getStackSize());
thread.setStackSize(stackSize);
assert (stackSize <= thread.getStackSize());
int tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
stackSize = 1;
thread.setStackSize(stackSize);
stackSize = 1;
thread.setStackSize(stackSize);
#if !defined(POCO_OS_FAMILY_BSD) // on BSD family, stack size is rounded
#ifdef PTHREAD_STACK_MIN
assert (PTHREAD_STACK_MIN == thread.getStackSize());
#else
assert (stackSize >= thread.getStackSize());
#endif
#ifdef PTHREAD_STACK_MIN
assert (PTHREAD_STACK_MIN == thread.getStackSize());
#else
assert (stackSize >= thread.getStackSize());
#endif
#endif
tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
thread.setStackSize(0);
assert (0 == thread.getStackSize());
tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
thread.setStackSize(0);
assert (0 == thread.getStackSize());
tmp = MyRunnable::_staticVar;
thread.start(freeFunc, &tmp);
thread.join();
assert (tmp * 2 == MyRunnable::_staticVar);
}
void ThreadTest::testSleep()
{
Poco::Timestamp start;
Thread::sleep(200);
Poco::Timespan elapsed = start.elapsed();
assert (elapsed.totalMilliseconds() >= 190 && elapsed.totalMilliseconds() < 250);
Poco::Timestamp start;
Thread::sleep(200);
Poco::Timespan elapsed = start.elapsed();
assert (elapsed.totalMilliseconds() >= 190 && elapsed.totalMilliseconds() < 250);
}
void ThreadTest::testAffinity()
{
std::stringstream ss;
unsigned cpuCount = Poco::Environment::processorCount();
unsigned usedCpu = 0;
bool notImplemented = false;
std::vector<Thread *> threadList;
Thread *thread = NULL;
std::vector<MyRunnable *> runnableList;
MyRunnable *runbl = NULL;
std::stringstream ss;
unsigned cpuCount = Poco::Environment::processorCount();
unsigned usedCpu = 0;
bool notImplemented = false;
std::vector<Thread*> threadList;
Thread* thread = NULL;
std::vector<MyRunnable*> runnableList;
MyRunnable* runbl = NULL;
for (unsigned i = 0; i < cpuCount; i++)
{
ss.str("");
ss << "Thread" << i;
thread = new Thread(ss.str());
threadList.push_back(thread);
runbl = new MyRunnable();
runnableList.push_back(runbl);
}
for (unsigned i = 0; i < cpuCount; i++)
{
ss.str("");
ss << "Thread" << i;
thread = new Thread(ss.str());
threadList.push_back(thread);
runbl = new MyRunnable();
runnableList.push_back(runbl);
}
for (int i = 0; i < cpuCount; i++)
{
assert (!threadList[i]->isRunning());
}
for (int i = 0; i < cpuCount; i++)
{
assert (!threadList[i]->isRunning());
}
for (int i = 0; i < cpuCount; i++)
{
threadList[i]->start(*runnableList[i]);
try
{
threadList[i]->setAffinity(i);
}
catch (Poco::NotImplementedException &niex)
{
notImplemented = true;
}
Thread::sleep(100);
try
{
usedCpu = threadList[i]->getAffinity();
}
catch (Poco::NotImplementedException &niex)
{
notImplemented = true;
}
if (!notImplemented)
{
assert (usedCpu == i);
}
}
for (int i = 0; i < cpuCount; i++)
{
threadList[i]->start(*runnableList[i]);
try
{
threadList[i]->setAffinity(i);
}
catch (Poco::NotImplementedException& niex)
{
notImplemented = true;
}
Thread::sleep(100);
try
{
usedCpu = threadList[i]->getAffinity();
}
catch (Poco::NotImplementedException& niex)
{
notImplemented = true;
}
if (!notImplemented)
{
assert (usedCpu == i);
}
}
for (int i = 0; i < cpuCount; i++)
{
runnableList[i]->notify();
threadList[i]->join();
delete runnableList[i];
delete threadList[i];
}
for (int i = 0; i < cpuCount; i++)
{
runnableList[i]->notify();
threadList[i]->join();
delete runnableList[i];
delete threadList[i];
}
}
@ -524,23 +529,23 @@ void ThreadTest::tearDown()
CppUnit::Test* ThreadTest::suite()
{
CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("ThreadTest");
CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("ThreadTest");
CppUnit_addTest(pSuite, ThreadTest, testThread);
CppUnit_addTest(pSuite, ThreadTest, testNamedThread);
CppUnit_addTest(pSuite, ThreadTest, testCurrent);
CppUnit_addTest(pSuite, ThreadTest, testThreads);
CppUnit_addTest(pSuite, ThreadTest, testJoin);
CppUnit_addTest(pSuite, ThreadTest, testNotJoin);
CppUnit_addTest(pSuite, ThreadTest, testNotRun);
CppUnit_addTest(pSuite, ThreadTest, testNotRunJoin);
CppUnit_addTest(pSuite, ThreadTest, testTrySleep);
CppUnit_addTest(pSuite, ThreadTest, testThreadTarget);
CppUnit_addTest(pSuite, ThreadTest, testThreadFunction);
CppUnit_addTest(pSuite, ThreadTest, testThreadFunctor);
CppUnit_addTest(pSuite, ThreadTest, testThreadStackSize);
CppUnit_addTest(pSuite, ThreadTest, testSleep);
CppUnit_addTest(pSuite, ThreadTest, testAffinity);
CppUnit_addTest(pSuite, ThreadTest, testThread);
CppUnit_addTest(pSuite, ThreadTest, testNamedThread);
CppUnit_addTest(pSuite, ThreadTest, testCurrent);
CppUnit_addTest(pSuite, ThreadTest, testThreads);
CppUnit_addTest(pSuite, ThreadTest, testJoin);
CppUnit_addTest(pSuite, ThreadTest, testNotJoin);
CppUnit_addTest(pSuite, ThreadTest, testNotRun);
CppUnit_addTest(pSuite, ThreadTest, testNotRunJoin);
CppUnit_addTest(pSuite, ThreadTest, testTrySleep);
CppUnit_addTest(pSuite, ThreadTest, testThreadTarget);
CppUnit_addTest(pSuite, ThreadTest, testThreadFunction);
CppUnit_addTest(pSuite, ThreadTest, testThreadFunctor);
CppUnit_addTest(pSuite, ThreadTest, testThreadStackSize);
CppUnit_addTest(pSuite, ThreadTest, testSleep);
CppUnit_addTest(pSuite, ThreadTest, testAffinity);
return pSuite;
return pSuite;
}