From a0e172419f36005c7a24a52a45a7062a1b6bfc18 Mon Sep 17 00:00:00 2001 From: ale_bychuk Date: Sun, 8 Mar 2015 22:54:45 +0300 Subject: [PATCH] fix indentation --- Foundation/include/Poco/Thread.h | 376 +++++++------- Foundation/include/Poco/Thread_POSIX.h | 192 +++---- Foundation/include/Poco/Thread_VX.h | 168 +++--- Foundation/include/Poco/Thread_WIN32.h | 158 +++--- Foundation/include/Poco/Thread_WINCE.h | 160 +++--- Foundation/src/Thread_POSIX.cpp | 564 ++++++++++---------- Foundation/src/Thread_WINCE.cpp | 146 +++--- Foundation/testsuite/src/ThreadTest.cpp | 655 ++++++++++++------------ 8 files changed, 1212 insertions(+), 1207 deletions(-) diff --git a/Foundation/include/Poco/Thread.h b/Foundation/include/Poco/Thread.h index 9e4297a2a..840c78c70 100644 --- a/Foundation/include/Poco/Thread.h +++ b/Foundation/include/Poco/Thread.h @@ -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 - void startFunc(Functor fn) - /// Starts the thread with the given functor object or lambda. - { - startImpl(new FunctorRunnable(fn)); - } + template + void startFunc(Functor fn) + /// Starts the thread with the given functor object or lambda. + { + startImpl(new FunctorRunnable(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 FunctorRunnable: public Runnable - { - public: - FunctorRunnable(const Functor& functor): - _functor(functor) - { - } + template + 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(currentImpl()); + return static_cast(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(); } diff --git a/Foundation/include/Poco/Thread_POSIX.h b/Foundation/include/Poco/Thread_POSIX.h index dee9fc122..6c316a042 100644 --- a/Foundation/include/Poco/Thread_POSIX.h +++ b/Foundation/include/Poco/Thread_POSIX.h @@ -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 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 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(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(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 pRunnableTarget; - pthread_t thread; - int prio; - int osPrio; - int policy; - Event done; - std::size_t stackSize; - bool started; - bool joined; - }; + SharedPtr pRunnableTarget; + pthread_t thread; + int prio; + int osPrio; + int policy; + Event done; + std::size_t stackSize; + bool started; + bool joined; + }; - AutoPtr _pData; + AutoPtr _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(_pData->stackSize); + return static_cast(_pData->stackSize); } inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const { - return _pData->thread; + return _pData->thread; } diff --git a/Foundation/include/Poco/Thread_VX.h b/Foundation/include/Poco/Thread_VX.h index e6228b4b3..fd3614b1f 100644 --- a/Foundation/include/Poco/Thread_VX.h +++ b/Foundation/include/Poco/Thread_VX.h @@ -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 pCallbackTarget; - int task; - int prio; - int osPrio; - Event done; - int stackSize; - }; + Runnable* pRunnableTarget; + AutoPtr pCallbackTarget; + int task; + int prio; + int osPrio; + Event done; + int stackSize; + }; private: - AutoPtr _pData; - static ThreadImpl* _pCurrent; + AutoPtr _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; } diff --git a/Foundation/include/Poco/Thread_WIN32.h b/Foundation/include/Poco/Thread_WIN32.h index 960272534..753f64ee5 100644 --- a/Foundation/include/Poco/Thread_WIN32.h +++ b/Foundation/include/Poco/Thread_WIN32.h @@ -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 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 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(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(TlsGetValue(_slot)); + } + void set(ThreadImpl* pThread) + { + TlsSetValue(_slot, pThread); + } - private: - DWORD _slot; - }; + private: + DWORD _slot; + }; - SharedPtr _pRunnableTarget; - HANDLE _thread; - DWORD _threadId; - int _prio; - int _stackSize; + SharedPtr _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; } diff --git a/Foundation/include/Poco/Thread_WINCE.h b/Foundation/include/Poco/Thread_WINCE.h index 81279f7cf..9b715a50b 100644 --- a/Foundation/include/Poco/Thread_WINCE.h +++ b/Foundation/include/Poco/Thread_WINCE.h @@ -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 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 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(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(TlsGetValue(_slot)); + } + void set(ThreadImpl* pThread) + { + TlsSetValue(_slot, pThread); + } - private: - DWORD _slot; - }; + private: + DWORD _slot; + }; - SharedPtr _pRunnableTarget; - HANDLE _thread; - DWORD _threadId; - int _prio; - int _stackSize; + SharedPtr _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; } diff --git a/Foundation/src/Thread_POSIX.cpp b/Foundation/src/Thread_POSIX.cpp index c5d82ab20..0ff054ea6 100644 --- a/Foundation/src/Thread_POSIX.cpp +++ b/Foundation/src/Thread_POSIX.cpp @@ -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 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(pThread)); + _currentThreadHolder.set(reinterpret_cast(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(pThread); + ThreadImpl* pThreadImpl = reinterpret_cast(pThread); #if defined(POCO_POSIX_DEBUGGER_THREAD_NAMES) - setThreadName(pThreadImpl->_pData->thread, reinterpret_cast(pThread)->getName().c_str()); + setThreadName(pThreadImpl->_pData->thread, reinterpret_cast(pThread)->getName().c_str()); #endif - AutoPtr pData = pThreadImpl->_pData; - try - { - pData->pRunnableTarget->run(); - } - catch (Exception& exc) - { - ErrorHandler::handle(exc); - } - catch (std::exception& exc) - { - ErrorHandler::handle(exc); - } - catch (...) - { - ErrorHandler::handle(); - } + AutoPtr 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; } diff --git a/Foundation/src/Thread_WINCE.cpp b/Foundation/src/Thread_WINCE.cpp index 559baebce..f7c1d2d6d 100644 --- a/Foundation/src/Thread_WINCE.cpp +++ b/Foundation/src/Thread_WINCE.cpp @@ -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 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(pThread)); - try - { - reinterpret_cast(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(pThread)); + try + { + reinterpret_cast(pThread)->_pRunnableTarget->run(); + } + catch (Exception& exc) + { + ErrorHandler::handle(exc); + } + catch (std::exception& exc) + { + ErrorHandler::handle(exc); + } + catch (...) + { + ErrorHandler::handle(); + } + return 0; } diff --git a/Foundation/testsuite/src/ThreadTest.cpp b/Foundation/testsuite/src/ThreadTest.cpp index 3459e583d..98572442b 100644 --- a/Foundation/testsuite/src/ThreadTest.cpp +++ b/Foundation/testsuite/src/ThreadTest.cpp @@ -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(pData); + MyRunnable::_staticVar += *reinterpret_cast(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 threadList; - Thread *thread = NULL; - std::vector runnableList; - MyRunnable *runbl = NULL; + std::stringstream ss; + unsigned cpuCount = Poco::Environment::processorCount(); + unsigned usedCpu = 0; + bool notImplemented = false; + std::vector threadList; + Thread* thread = NULL; + std::vector 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; }