generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-25 02:06:04 +02:00
Code Issues Projects Releases Wiki Activity

fix indentation

Browse Source
This commit is contained in:
ale_bychuk
2015-03-08 22:04:29 +03:00
parent 662fbc861a
commit 3af35f548c
13 changed files with 1370 additions and 1367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
Foundation/CMakeLists.txt
View File

@@ -22,14 +22,14 @@ POCO_HEADERS_AUTO( SRCS include/Poco/AndroidLogChannel.h )
# For Windows CE we need to disable these # For Windows CE we need to disable these
if(WINCE) if(WINCE)
POCO_SOURCES_AUTO_PLAT( SRCS OFF POCO_SOURCES_AUTO_PLAT( SRCS OFF
src/WindowsConsoleChannel.cpp src/WindowsConsoleChannel.cpp
src/EventLogChannel.cpp src/EventLogChannel.cpp
) )
else() else()
POCO_SOURCES_AUTO_PLAT( SRCS WIN32 POCO_SOURCES_AUTO_PLAT( SRCS WIN32
src/WindowsConsoleChannel.cpp src/WindowsConsoleChannel.cpp
src/EventLogChannel.cpp src/EventLogChannel.cpp
) )
endif() endif()
# Messages # Messages
@@ -38,70 +38,70 @@ POCO_MESSAGES( SRCS Logging src/pocomsg.mc)
# If POCO_UNBUNDLED is enabled we try to find the required packages # If POCO_UNBUNDLED is enabled we try to find the required packages
# The configuration will fail if the packages are not found # The configuration will fail if the packages are not found
if (POCO_UNBUNDLED) if (POCO_UNBUNDLED)
find_package(PCRE REQUIRED) find_package(PCRE REQUIRED)
set(SYSLIBS ${SYSLIBS} ${PCRE_LIBRARIES}) set(SYSLIBS ${SYSLIBS} ${PCRE_LIBRARIES})
include_directories(${PCRE_INCLUDE_DIRS}) include_directories(${PCRE_INCLUDE_DIRS})
#HACK: Unicode.cpp requires functions from these files. The can't be taken from the library #HACK: Unicode.cpp requires functions from these files. The can't be taken from the library
POCO_SOURCES( SRCS RegExp POCO_SOURCES( SRCS RegExp
src/pcre_ucd.c src/pcre_ucd.c
src/pcre_tables.c src/pcre_tables.c
) )
find_package(ZLIB REQUIRED) find_package(ZLIB REQUIRED)
set(SYSLIBS ${SYSLIBS} ${ZLIB_LIBRARIES}) set(SYSLIBS ${SYSLIBS} ${ZLIB_LIBRARIES})
include_directories(${ZLIB_INCLUDE_DIRS}) include_directories(${ZLIB_INCLUDE_DIRS})
else() else()
# pcre # pcre
POCO_SOURCES( SRCS pcre POCO_SOURCES( SRCS pcre
src/pcre_config.c src/pcre_config.c
src/pcre_byte_order.c src/pcre_byte_order.c
src/pcre_chartables.c src/pcre_chartables.c
src/pcre_compile.c src/pcre_compile.c
src/pcre_exec.c src/pcre_exec.c
src/pcre_fullinfo.c src/pcre_fullinfo.c
src/pcre_globals.c src/pcre_globals.c
src/pcre_maketables.c src/pcre_maketables.c
src/pcre_newline.c src/pcre_newline.c
src/pcre_ord2utf8.c src/pcre_ord2utf8.c
src/pcre_study.c src/pcre_study.c
src/pcre_tables.c src/pcre_tables.c
src/pcre_dfa_exec.c src/pcre_dfa_exec.c
src/pcre_get.c src/pcre_get.c
src/pcre_jit_compile.c src/pcre_jit_compile.c
src/pcre_refcount.c src/pcre_refcount.c
src/pcre_string_utils.c src/pcre_string_utils.c
src/pcre_version.c src/pcre_version.c
src/pcre_ucd.c src/pcre_ucd.c
src/pcre_valid_utf8.c src/pcre_valid_utf8.c
src/pcre_xclass.c src/pcre_xclass.c
) )
# zlib # zlib
POCO_HEADERS( SRCS zlib POCO_HEADERS( SRCS zlib
include/Poco/zconf.h include/Poco/zconf.h
include/Poco/zlib.h include/Poco/zlib.h
) )
POCO_SOURCES( SRCS zlib POCO_SOURCES( SRCS zlib
src/adler32.c src/adler32.c
src/compress.c src/compress.c
src/crc32.c src/crc32.c
src/deflate.c src/deflate.c
src/infback.c src/infback.c
src/inffast.c src/inffast.c
src/inflate.c src/inflate.c
src/inftrees.c src/inftrees.c
src/trees.c src/trees.c
src/zutil.c src/zutil.c
) )
endif (POCO_UNBUNDLED) endif (POCO_UNBUNDLED)
if(WIN32) if(WIN32)
set(SYSLIBS ${SYSLIBS} iphlpapi) set(SYSLIBS ${SYSLIBS} iphlpapi)
endif(WIN32) endif(WIN32)
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro") if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
set_target_properties( "${LIBNAME}" PROPERTIES LINK_FLAGS "-library=stlport4") set_target_properties( "${LIBNAME}" PROPERTIES LINK_FLAGS "-library=stlport4")
endif (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro") endif (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
# TODO: Why is this here? # TODO: Why is this here?
@@ -109,64 +109,64 @@ add_definitions( -DPCRE_STATIC)
# For SetAffinity # For SetAffinity
if(UNIX AND NOT APPLE) if(UNIX AND NOT APPLE)
INCLUDE (CheckFunctionExists) INCLUDE (CheckFunctionExists)
INCLUDE (CheckCXXSourceCompiles) INCLUDE (CheckCXXSourceCompiles)
CHECK_FUNCTION_EXISTS(pthread_setaffinity_np HAVE_PTHREAD_SETAFFINITY_NP) CHECK_FUNCTION_EXISTS(pthread_setaffinity_np HAVE_PTHREAD_SETAFFINITY_NP)
if(HAVE_PTHREAD_SETAFFINITY_NP) if(HAVE_PTHREAD_SETAFFINITY_NP)
message(STATUS "Platform has PTHREAD_SETAFFINITY_NP") message(STATUS "Platform has PTHREAD_SETAFFINITY_NP")
add_definitions(-DHAVE_PTHREAD_SETAFFINITY_NP) add_definitions(-DHAVE_PTHREAD_SETAFFINITY_NP)
else(HAVE_PTHREAD_SETAFFINITY_NP) else(HAVE_PTHREAD_SETAFFINITY_NP)
CHECK_CXX_SOURCE_COMPILES(" CHECK_CXX_SOURCE_COMPILES("
#include <sched.h> #include <sched.h>
int main() { int main() {
cpu_set_t cpumask; cpu_set_t cpumask;
sched_setaffinity( 0, sizeof(cpumask), &cpumask ); sched_setaffinity( 0, sizeof(cpumask), &cpumask );
return 0; return 0;
}" HAVE_THREE_PARAM_SCHED_SETAFFINITY) }" HAVE_THREE_PARAM_SCHED_SETAFFINITY)
if(HAVE_THREE_PARAM_SCHED_SETAFFINITY) if(HAVE_THREE_PARAM_SCHED_SETAFFINITY)
message(STATUS "Platform has THREE PARAM at PTHREAD_SETAFFINITY_NP") message(STATUS "Platform has THREE PARAM at PTHREAD_SETAFFINITY_NP")
add_definitions(-DHAVE_THREE_PARAM_SCHED_SETAFFINITY) add_definitions(-DHAVE_THREE_PARAM_SCHED_SETAFFINITY)
else(HAVE_THREE_PARAM_SCHED_SETAFFINITY) else(HAVE_THREE_PARAM_SCHED_SETAFFINITY)
CHECK_CXX_SOURCE_COMPILES(" CHECK_CXX_SOURCE_COMPILES("
#include <sched.h> #include <sched.h>
int main() { int main() {
cpu_set_t cpumask; cpu_set_t cpumask;
sched_setaffinity( 0, &cpumask ); sched_setaffinity( 0, &cpumask );
return 0; return 0;
}" HAVE_TWO_PARAM_SCHED_SETAFFINITY) }" HAVE_TWO_PARAM_SCHED_SETAFFINITY)
if(HAVE_TWO_PARAM_SCHED_SETAFFINITY) if(HAVE_TWO_PARAM_SCHED_SETAFFINITY)
message(STATUS "Platform has TWO PARAM at PTHREAD_SETAFFINITY_NP") message(STATUS "Platform has TWO PARAM at PTHREAD_SETAFFINITY_NP")
add_definitions(-DHAVE_TWO_PARAM_SCHED_SETAFFINITY) add_definitions(-DHAVE_TWO_PARAM_SCHED_SETAFFINITY)
endif(HAVE_TWO_PARAM_SCHED_SETAFFINITY) endif(HAVE_TWO_PARAM_SCHED_SETAFFINITY)
endif(HAVE_THREE_PARAM_SCHED_SETAFFINITY) endif(HAVE_THREE_PARAM_SCHED_SETAFFINITY)
endif(HAVE_PTHREAD_SETAFFINITY_NP) endif(HAVE_PTHREAD_SETAFFINITY_NP)
endif(UNIX AND NOT APPLE) endif(UNIX AND NOT APPLE)
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS}) add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS})
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}") add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}" set_target_properties( "${LIBNAME}"
PROPERTIES PROPERTIES
VERSION ${PROJECT_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION} VERSION ${PROJECT_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
OUTPUT_NAME ${POCO_LIBNAME} OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Foundation_EXPORTS DEFINE_SYMBOL Foundation_EXPORTS
) )
target_link_libraries( "${LIBNAME}" ${SYSLIBS}) target_link_libraries( "${LIBNAME}" ${SYSLIBS})
target_include_directories( "${LIBNAME}" target_include_directories( "${LIBNAME}"
PUBLIC PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include> $<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
) )
POCO_INSTALL("${LIBNAME}") POCO_INSTALL("${LIBNAME}")
POCO_GENERATE_PACKAGE("${LIBNAME}") POCO_GENERATE_PACKAGE("${LIBNAME}")
if (ENABLE_TESTS) if (ENABLE_TESTS)
add_subdirectory( samples ) add_subdirectory( samples )
add_subdirectory( testsuite ) add_subdirectory( testsuite )
endif () endif ()

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

@@ -46,68 +46,68 @@ class ThreadLocalStorage;
class Foundation_API Thread: private ThreadImpl class Foundation_API Thread: private ThreadImpl
/// This class implements a platform-independent /// This class implements a platform-independent
/// wrapper to an operating system thread. /// wrapper to an operating system thread.
/// ///
/// Every Thread object gets a unique (within /// Every Thread object gets a unique (within
/// its process) numeric thread ID. /// its process) numeric thread ID.
/// Furthermore, a thread can be assigned a name. /// Furthermore, a thread can be assigned a name.
/// The name of a thread can be changed at any time. /// The name of a thread can be changed at any time.
{ {
public: public:
typedef ThreadImpl::TIDImpl TID; typedef ThreadImpl::TIDImpl TID;
using ThreadImpl::Callable; using ThreadImpl::Callable;
enum Priority enum Priority
/// Thread priorities. /// Thread priorities.
{ {
PRIO_LOWEST = PRIO_LOWEST_IMPL, /// The lowest thread priority. PRIO_LOWEST = PRIO_LOWEST_IMPL, /// The lowest thread priority.
PRIO_LOW = PRIO_LOW_IMPL, /// A lower than normal thread priority. PRIO_LOW = PRIO_LOW_IMPL, /// A lower than normal thread priority.
PRIO_NORMAL = PRIO_NORMAL_IMPL, /// The normal thread priority. PRIO_NORMAL = PRIO_NORMAL_IMPL, /// The normal thread priority.
PRIO_HIGH = PRIO_HIGH_IMPL, /// A higher than normal thread priority. PRIO_HIGH = PRIO_HIGH_IMPL, /// A higher than normal thread priority.
PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority. PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority.
}; };
enum Policy enum Policy
{ {
POLICY_DEFAULT = POLICY_DEFAULT_IMPL POLICY_DEFAULT = POLICY_DEFAULT_IMPL
}; };
Thread(); Thread();
/// Creates a thread. Call start() to start it. /// Creates a thread. Call start() to start it.
Thread(const std::string& name); Thread(const std::string& name);
/// Creates a named thread. Call start() to start it. /// Creates a named thread. Call start() to start it.
~Thread(); ~Thread();
/// Destroys the thread. /// Destroys the thread.
int id() const; int id() const;
/// Returns the unique thread ID of the thread. /// Returns the unique thread ID of the thread.
TID tid() const; TID tid() const;
/// Returns the native thread ID of the thread. /// Returns the native thread ID of the thread.
std::string name() const; std::string name() const;
/// Returns the name of the thread. /// Returns the name of the thread.
std::string getName() const; std::string getName() const;
/// Returns the name of the thread. /// Returns the name of the thread.
void setName(const std::string& name); void setName(const std::string& name);
/// Sets the name of the thread. /// Sets the name of the thread.
void setPriority(Priority prio); void setPriority(Priority prio);
/// Sets the thread's priority. /// Sets the thread's priority.
/// ///
/// Some platform only allow changing a thread's priority /// Some platform only allow changing a thread's priority
/// if the process has certain privileges. /// if the process has certain privileges.
Priority getPriority() const; Priority getPriority() const;
/// Returns the thread's priority. /// Returns the thread's priority.
void setOSPriority(int prio, int policy = POLICY_DEFAULT); void setOSPriority(int prio, int policy = POLICY_DEFAULT);
/// Sets the thread's priority, using an operating system specific /// Sets the thread's priority, using an operating system specific
/// priority value. Use getMinOSPriority() and getMaxOSPriority() to /// priority value. Use getMinOSPriority() and getMaxOSPriority() to
/// obtain mininum and maximum priority values. Additionally, /// obtain mininum and maximum priority values. Additionally,
@@ -115,74 +115,74 @@ public:
/// only used on POSIX platforms where the values SCHED_OTHER (default), /// only used on POSIX platforms where the values SCHED_OTHER (default),
/// SCHED_FIFO and SCHED_RR are supported. /// SCHED_FIFO and SCHED_RR are supported.
int getOSPriority() const; int getOSPriority() const;
/// Returns the thread's priority, expressed as an operating system /// Returns the thread's priority, expressed as an operating system
/// specific priority value. /// specific priority value.
/// ///
/// May return 0 if the priority has not been explicitly set. /// May return 0 if the priority has not been explicitly set.
static int getMinOSPriority(int policy = POLICY_DEFAULT); static int getMinOSPriority(int policy = POLICY_DEFAULT);
/// Returns the minimum operating system-specific priority value, /// Returns the minimum operating system-specific priority value,
/// which can be passed to setOSPriority() for the given policy. /// which can be passed to setOSPriority() for the given policy.
static int getMaxOSPriority(int policy = POLICY_DEFAULT); static int getMaxOSPriority(int policy = POLICY_DEFAULT);
/// Returns the maximum operating system-specific priority value, /// Returns the maximum operating system-specific priority value,
/// which can be passed to setOSPriority() for the given policy. /// which can be passed to setOSPriority() for the given policy.
void setStackSize(int size); void setStackSize(int size);
/// Sets the thread's stack size in bytes. /// Sets the thread's stack size in bytes.
/// Setting the stack size to 0 will use the default stack size. /// Setting the stack size to 0 will use the default stack size.
/// Typically, the real stack size is rounded up to the nearest /// Typically, the real stack size is rounded up to the nearest
/// page size multiple. /// page size multiple.
void setAffinity(unsigned int cpu); void setAffinity(unsigned int cpu);
/// Limit specified thread to run only on the processors "cpu" /// Limit specified thread to run only on the processors "cpu"
/// cpu - processor (core) number /// cpu - processor (core) number
/// Method would Throw SystemException if affinity did not setted /// Method would Throw SystemException if affinity did not setted
unsigned getAffinity() const; unsigned getAffinity() const;
/// Returns using cpu (core) number /// Returns using cpu (core) number
int getStackSize() const; int getStackSize() const;
/// Returns the thread's stack size in bytes. /// Returns the thread's stack size in bytes.
/// If the default stack size is used, 0 is returned. /// If the default stack size is used, 0 is returned.
void start(Runnable& target); void start(Runnable& target);
/// Starts the thread with the given target. /// Starts the thread with the given target.
/// ///
/// Note that the given Runnable object must remain /// Note that the given Runnable object must remain
/// valid during the entire lifetime of the thread, as /// valid during the entire lifetime of the thread, as
/// only a reference to it is stored internally. /// only a reference to it is stored internally.
void start(Callable target, void* pData = 0); void start(Callable target, void* pData = 0);
/// Starts the thread with the given target and parameter. /// Starts the thread with the given target and parameter.
template <class Functor> template <class Functor>
void startFunc(Functor fn) void startFunc(Functor fn)
/// Starts the thread with the given functor object or lambda. /// Starts the thread with the given functor object or lambda.
{ {
startImpl(new FunctorRunnable<Functor>(fn)); startImpl(new FunctorRunnable<Functor>(fn));
} }
void join(); void join();
/// Waits until the thread completes execution. /// Waits until the thread completes execution.
/// If multiple threads try to join the same /// If multiple threads try to join the same
/// thread, the result is undefined. /// thread, the result is undefined.
void join(long milliseconds); void join(long milliseconds);
/// Waits for at most the given interval for the thread /// Waits for at most the given interval for the thread
/// to complete. Throws a TimeoutException if the thread /// to complete. Throws a TimeoutException if the thread
/// does not complete within the specified time interval. /// does not complete within the specified time interval.
bool tryJoin(long milliseconds); bool tryJoin(long milliseconds);
/// Waits for at most the given interval for the thread /// Waits for at most the given interval for the thread
/// to complete. Returns true if the thread has finished, /// to complete. Returns true if the thread has finished,
/// false otherwise. /// false otherwise.
bool isRunning() const; bool isRunning() const;
/// Returns true if the thread is running. /// Returns true if the thread is running.
static bool trySleep(long milliseconds); static bool trySleep(long milliseconds);
/// Starts an interruptible sleep. When trySleep() is called, /// Starts an interruptible sleep. When trySleep() is called,
/// the thread will remain suspended until: /// the thread will remain suspended until:
/// - the timeout expires or /// - the timeout expires or
@@ -204,73 +204,73 @@ public:
/// trySleep() call to actually suspend the thread (which, in /// trySleep() call to actually suspend the thread (which, in
/// some scenarios, may be desirable behavior). /// some scenarios, may be desirable behavior).
void wakeUp(); void wakeUp();
/// Wakes up the thread which is in the state of interruptible /// Wakes up the thread which is in the state of interruptible
/// sleep. For threads that are not suspended, calling this /// sleep. For threads that are not suspended, calling this
/// function has the effect of preventing the subsequent /// function has the effect of preventing the subsequent
/// trySleep() call to put thread in a suspended state. /// trySleep() call to put thread in a suspended state.
static void sleep(long milliseconds); static void sleep(long milliseconds);
/// Suspends the current thread for the specified /// Suspends the current thread for the specified
/// amount of time. /// amount of time.
static void yield(); static void yield();
/// Yields cpu to other threads. /// Yields cpu to other threads.
static Thread* current(); static Thread* current();
/// Returns the Thread object for the currently active thread. /// Returns the Thread object for the currently active thread.
/// If the current thread is the main thread, 0 is returned. /// If the current thread is the main thread, 0 is returned.
static TID currentTid(); static TID currentTid();
/// Returns the native thread ID for the current thread. /// Returns the native thread ID for the current thread.
protected: protected:
ThreadLocalStorage& tls(); ThreadLocalStorage& tls();
/// Returns a reference to the thread's local storage. /// Returns a reference to the thread's local storage.
void clearTLS(); void clearTLS();
/// Clears the thread's local storage. /// Clears the thread's local storage.
std::string makeName(); std::string makeName();
/// Creates a unique name for a thread. /// Creates a unique name for a thread.
static int uniqueId(); static int uniqueId();
/// Creates and returns a unique id for a thread. /// Creates and returns a unique id for a thread.
template <class Functor> template <class Functor>
class FunctorRunnable: public Runnable class FunctorRunnable: public Runnable
{
public:
FunctorRunnable(const Functor& functor):
_functor(functor)
{ {
} public:
FunctorRunnable(const Functor& functor):
_functor(functor)
{
}
~FunctorRunnable() ~FunctorRunnable()
{ {
} }
void run() void run()
{ {
_functor(); _functor();
} }
private: private:
Functor _functor; Functor _functor;
}; };
private: private:
Thread(const Thread&); Thread(const Thread&);
Thread& operator = (const Thread&); Thread& operator = (const Thread&);
int _id; int _id;
std::string _name; std::string _name;
ThreadLocalStorage* _pTLS; ThreadLocalStorage* _pTLS;
Event _event; Event _event;
mutable FastMutex _mutex; mutable FastMutex _mutex;
friend class ThreadLocalStorage; friend class ThreadLocalStorage;
friend class PooledThread; friend class PooledThread;
}; };
@@ -279,104 +279,104 @@ private:
// //
inline Thread::TID Thread::tid() const inline Thread::TID Thread::tid() const
{ {
return tidImpl(); return tidImpl();
} }
inline int Thread::id() const inline int Thread::id() const
{ {
return _id; return _id;
} }
inline std::string Thread::name() const inline std::string Thread::name() const
{ {
FastMutex::ScopedLock lock(_mutex); FastMutex::ScopedLock lock(_mutex);
return _name; return _name;
} }
inline std::string Thread::getName() const inline std::string Thread::getName() const
{ {
FastMutex::ScopedLock lock(_mutex); FastMutex::ScopedLock lock(_mutex);
return _name; return _name;
} }
inline bool Thread::isRunning() const inline bool Thread::isRunning() const
{ {
return isRunningImpl(); return isRunningImpl();
} }
inline void Thread::sleep(long milliseconds) inline void Thread::sleep(long milliseconds)
{ {
sleepImpl(milliseconds); sleepImpl(milliseconds);
} }
inline void Thread::yield() inline void Thread::yield()
{ {
yieldImpl(); yieldImpl();
} }
inline Thread* Thread::current() inline Thread* Thread::current()
{ {
return static_cast<Thread*>(currentImpl()); return static_cast<Thread*>(currentImpl());
} }
inline void Thread::setOSPriority(int prio, int policy) inline void Thread::setOSPriority(int prio, int policy)
{ {
setOSPriorityImpl(prio, policy); setOSPriorityImpl(prio, policy);
} }
inline int Thread::getOSPriority() const inline int Thread::getOSPriority() const
{ {
return getOSPriorityImpl(); return getOSPriorityImpl();
} }
inline int Thread::getMinOSPriority(int policy) inline int Thread::getMinOSPriority(int policy)
{ {
return ThreadImpl::getMinOSPriorityImpl(policy); return ThreadImpl::getMinOSPriorityImpl(policy);
} }
inline int Thread::getMaxOSPriority(int policy) inline int Thread::getMaxOSPriority(int policy)
{ {
return ThreadImpl::getMaxOSPriorityImpl(policy); return ThreadImpl::getMaxOSPriorityImpl(policy);
} }
inline void Thread::setStackSize(int size) inline void Thread::setStackSize(int size)
{ {
setStackSizeImpl(size); setStackSizeImpl(size);
} }
inline void Thread::setAffinity(unsigned int cpu) inline void Thread::setAffinity(unsigned int cpu)
{ {
setAffinityImpl(cpu); setAffinityImpl(cpu);
} }
inline unsigned Thread::getAffinity() const inline unsigned Thread::getAffinity() const
{ {
return getAffinityImpl(); return getAffinityImpl();
} }
inline int Thread::getStackSize() const inline int Thread::getStackSize() const
{ {
return getStackSizeImpl(); return getStackSizeImpl();
} }
inline Thread::TID Thread::currentTid() inline Thread::TID Thread::currentTid()
{ {
return currentTidImpl(); return currentTidImpl();
} }

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

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

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

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

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

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

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

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

533
Foundation/src/Thread_POSIX.cpp
View File

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

2
Foundation/src/Thread_VX.cpp
View File

@@ -143,7 +143,7 @@ ThreadImpl* ThreadImpl::currentImpl()
ThreadImpl::TIDImpl ThreadImpl::currentTidImpl() ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
{ {
return taskIdSelf(); return taskIdSelf();
} }

229
Foundation/src/Thread_WIN32.cpp
View File

@@ -23,40 +23,39 @@
#if defined(POCO_WIN32_DEBUGGER_THREAD_NAMES) #if defined(POCO_WIN32_DEBUGGER_THREAD_NAMES)
namespace namespace {
/// See <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx>
/// and <http://blogs.msdn.com/b/stevejs/archive/2005/12/19/505815.aspx> for
/// more information on the code below.
const DWORD MS_VC_EXCEPTION = 0x406D1388;
#pragma pack(push,8)
typedef struct tagTHREADNAME_INFO
{ {
/// See <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx> DWORD dwType; // Must be 0x1000.
/// and <http://blogs.msdn.com/b/stevejs/archive/2005/12/19/505815.aspx> for LPCSTR szName; // Pointer to name (in user addr space).
/// more information on the code below. DWORD dwThreadID; // Thread ID (-1=caller thread).
DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO;
#pragma pack(pop)
const DWORD MS_VC_EXCEPTION = 0x406D1388; void setThreadName(DWORD dwThreadID, const char* threadName)
{
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = threadName;
info.dwThreadID = dwThreadID;
info.dwFlags = 0;
#pragma pack(push,8) __try
typedef struct tagTHREADNAME_INFO {
{ RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
DWORD dwType; // Must be 0x1000. }
LPCSTR szName; // Pointer to name (in user addr space). __except (EXCEPTION_CONTINUE_EXECUTION)
DWORD dwThreadID; // Thread ID (-1=caller thread). {
DWORD dwFlags; // Reserved for future use, must be zero. }
} THREADNAME_INFO; }
#pragma pack(pop)
void setThreadName(DWORD dwThreadID, const char* threadName)
{
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = threadName;
info.dwThreadID = dwThreadID;
info.dwFlags = 0;
__try
{
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
}
__except (EXCEPTION_CONTINUE_EXECUTION)
{
}
}
} }
@@ -70,137 +69,139 @@ ThreadImpl::CurrentThreadHolder ThreadImpl::_currentThreadHolder;
ThreadImpl::ThreadImpl(): ThreadImpl::ThreadImpl():
_thread(0), _thread(0),
_threadId(0), _threadId(0),
_prio(PRIO_NORMAL_IMPL), _prio(PRIO_NORMAL_IMPL),
_stackSize(POCO_THREAD_STACK_SIZE) _stackSize(POCO_THREAD_STACK_SIZE)
{ {
} }
ThreadImpl::~ThreadImpl() ThreadImpl::~ThreadImpl()
{ {
if (_thread) CloseHandle(_thread); if (_thread) CloseHandle(_thread);
} }
void ThreadImpl::setPriorityImpl(int prio) void ThreadImpl::setPriorityImpl(int prio)
{ {
if (prio != _prio) if (prio != _prio)
{ {
_prio = prio; _prio = prio;
if (_thread) if (_thread)
{ {
if (SetThreadPriority(_thread, _prio) == 0) if (SetThreadPriority(_thread, _prio) == 0)
throw SystemException("cannot set thread priority"); throw SystemException("cannot set thread priority");
} }
} }
} }
void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */) void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
{ {
setPriorityImpl(prio); setPriorityImpl(prio);
} }
void ThreadImpl::setAffinityImpl(unsigned cpu) void ThreadImpl::setAffinityImpl(unsigned cpu)
{ {
DWORD mask = 1; DWORD mask = 1;
mask <<= cpu; mask <<= cpu;
if (SetThreadAffinityMask(_thread, mask) == 0) { if (SetThreadAffinityMask(_thread, mask) == 0)
throw SystemException("Failed to set affinity"); {
} throw SystemException("Failed to set affinity");
}
} }
unsigned ThreadImpl::getAffinityImpl() const { unsigned ThreadImpl::getAffinityImpl() const
throw Poco::NotImplementedException("Get thread affinity not supported on this system"); {
throw Poco::NotImplementedException("Get thread affinity not supported on this system");
} }
void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget) void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
{ {
if (isRunningImpl()) if (isRunningImpl())
throw SystemException("thread already running"); throw SystemException("thread already running");
_pRunnableTarget = pTarget; _pRunnableTarget = pTarget;
createImpl(runnableEntry, this); createImpl(runnableEntry, this);
} }
void ThreadImpl::createImpl(Entry ent, void* pData) void ThreadImpl::createImpl(Entry ent, void* pData)
{ {
#if defined(_DLL) #if defined(_DLL)
_thread = CreateThread(NULL, _stackSize, ent, pData, 0, &_threadId); _thread = CreateThread(NULL, _stackSize, ent, pData, 0, &_threadId);
#else #else
unsigned threadId; unsigned threadId;
_thread = (HANDLE) _beginthreadex(NULL, _stackSize, ent, this, 0, &threadId); _thread = (HANDLE) _beginthreadex(NULL, _stackSize, ent, this, 0, &threadId);
_threadId = static_cast<DWORD>(threadId); _threadId = static_cast<DWORD>(threadId);
#endif #endif
if (!_thread) if (!_thread)
throw SystemException("cannot create thread"); throw SystemException("cannot create thread");
if (_prio != PRIO_NORMAL_IMPL && !SetThreadPriority(_thread, _prio)) if (_prio != PRIO_NORMAL_IMPL && !SetThreadPriority(_thread, _prio))
throw SystemException("cannot set thread priority"); throw SystemException("cannot set thread priority");
} }
void ThreadImpl::joinImpl() void ThreadImpl::joinImpl()
{ {
if (!_thread) return; if (!_thread) return;
switch (WaitForSingleObject(_thread, INFINITE)) switch (WaitForSingleObject(_thread, INFINITE))
{ {
case WAIT_OBJECT_0: case WAIT_OBJECT_0:
threadCleanup(); threadCleanup();
return; return;
default: default:
throw SystemException("cannot join thread"); throw SystemException("cannot join thread");
} }
} }
bool ThreadImpl::joinImpl(long milliseconds) bool ThreadImpl::joinImpl(long milliseconds)
{ {
if (!_thread) return true; if (!_thread) return true;
switch (WaitForSingleObject(_thread, milliseconds + 1)) switch (WaitForSingleObject(_thread, milliseconds + 1))
{ {
case WAIT_TIMEOUT: case WAIT_TIMEOUT:
return false; return false;
case WAIT_OBJECT_0: case WAIT_OBJECT_0:
threadCleanup(); threadCleanup();
return true; return true;
default: default:
throw SystemException("cannot join thread"); throw SystemException("cannot join thread");
} }
} }
bool ThreadImpl::isRunningImpl() const bool ThreadImpl::isRunningImpl() const
{ {
if (_thread) if (_thread)
{ {
DWORD ec = 0; DWORD ec = 0;
return GetExitCodeThread(_thread, &ec) && ec == STILL_ACTIVE; return GetExitCodeThread(_thread, &ec) && ec == STILL_ACTIVE;
} }
return false; return false;
} }
void ThreadImpl::threadCleanup() void ThreadImpl::threadCleanup()
{ {
if (!_thread) return; if (!_thread) return;
if (CloseHandle(_thread)) _thread = 0; if (CloseHandle(_thread)) _thread = 0;
} }
ThreadImpl* ThreadImpl::currentImpl() ThreadImpl* ThreadImpl::currentImpl()
{ {
return _currentThreadHolder.get(); return _currentThreadHolder.get();
} }
ThreadImpl::TIDImpl ThreadImpl::currentTidImpl() ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
{ {
return GetCurrentThreadId(); return GetCurrentThreadId();
} }
@@ -210,27 +211,27 @@ DWORD WINAPI ThreadImpl::runnableEntry(LPVOID pThread)
unsigned __stdcall ThreadImpl::runnableEntry(void* pThread) unsigned __stdcall ThreadImpl::runnableEntry(void* pThread)
#endif #endif
{ {
_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread)); _currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
#if defined(POCO_WIN32_DEBUGGER_THREAD_NAMES) #if defined(POCO_WIN32_DEBUGGER_THREAD_NAMES)
setThreadName(-1, reinterpret_cast<Thread*>(pThread)->getName().c_str()); setThreadName(-1, reinterpret_cast<Thread*>(pThread)->getName().c_str());
#endif #endif
try try
{ {
reinterpret_cast<ThreadImpl*>(pThread)->_pRunnableTarget->run(); reinterpret_cast<ThreadImpl*>(pThread)->_pRunnableTarget->run();
} }
catch (Exception& exc) catch (Exception& exc)
{ {
ErrorHandler::handle(exc); ErrorHandler::handle(exc);
} }
catch (std::exception& exc) catch (std::exception& exc)
{ {
ErrorHandler::handle(exc); ErrorHandler::handle(exc);
} }
catch (...) catch (...)
{ {
ErrorHandler::handle(); ErrorHandler::handle();
} }
return 0; return 0;
} }

144
Foundation/src/Thread_WINCE.cpp
View File

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

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

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

40
Foundation/testsuite/src/ThreadTest.h
View File

@@ -23,29 +23,29 @@
class ThreadTest: public CppUnit::TestCase class ThreadTest: public CppUnit::TestCase
{ {
public: public:
ThreadTest(const std::string& name); ThreadTest(const std::string& name);
~ThreadTest(); ~ThreadTest();
void testThread(); void testThread();
void testNamedThread(); void testNamedThread();
void testCurrent(); void testCurrent();
void testThreads(); void testThreads();
void testJoin(); void testJoin();
void testNotJoin(); void testNotJoin();
void testNotRun(); void testNotRun();
void testNotRunJoin(); void testNotRunJoin();
void testTrySleep(); void testTrySleep();
void testThreadTarget(); void testThreadTarget();
void testThreadFunction(); void testThreadFunction();
void testThreadFunctor(); void testThreadFunctor();
void testThreadStackSize(); void testThreadStackSize();
void testSleep(); void testSleep();
void testAffinity(); void testAffinity();
void setUp(); void setUp();
void tearDown(); void tearDown();
static CppUnit::Test* suite(); static CppUnit::Test* suite();
private: private:
}; };

14
build_cmake.sh
View File

@@ -8,15 +8,15 @@ rm -rf cmake-build
mkdir cmake-build mkdir cmake-build
cd cmake-build cd cmake-build
cmake ../. -DCMAKE_BUILD_TYPE=Debug $1 $2 $3 $4 $5 cmake ../. -DCMAKE_INSTALL_PREFIX=/opt/devel -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTS=ON -G "Sublime Text 2 - Unix Makefiles" $1 $2 $3 $4 $5
make -j3 make -j8
make install sudo make install
rm -rf CMakeCache.txt #rm -rf CMakeCache.txt
cmake ../. -DCMAKE_BUILD_TYPE=Release $1 $2 $3 $4 $5 #cmake ../. -DCMAKE_INSTALL_PREFIX=/opt/devel -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTS=ON $1 $2 $3 $4 $5
make -j3 #make -j8
make install #sudo make install
cd .. cd ..