|
version 1.1.2.10, 2006/08/02 07:26:35
|
version 1.8, 2006/09/19 16:45:54
|
|
|
|
| #define Pegasus_Threads_h | #define Pegasus_Threads_h |
| | |
| #include <cstring> | #include <cstring> |
| |
#include <cstdio> |
| |
#include <cstring> |
| #include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
| #include <Pegasus/Common/Linkage.h> | #include <Pegasus/Common/Linkage.h> |
| | |
|
|
|
| | |
| //============================================================================== | //============================================================================== |
| // | // |
| |
// ThreadId |
| |
// |
| |
//============================================================================== |
| |
|
| |
struct ThreadId |
| |
{ |
| |
// The character representation of a uint64 requires 22 bytes including the |
| |
// null terminator. |
| |
char buffer[22]; |
| |
}; |
| |
|
| |
//============================================================================== |
| |
// |
| // ThreadType | // ThreadType |
| // | // |
| //============================================================================== | //============================================================================== |
|
|
|
| #if defined(PEGASUS_HAVE_PTHREADS) | #if defined(PEGASUS_HAVE_PTHREADS) |
| struct ThreadType | struct ThreadType |
| { | { |
| public: |
|
| |
|
| ThreadType() | ThreadType() |
| { | { |
| memset(this, 0, sizeof(*this)); |
memset(&thread, 0, sizeof(thread)); |
| } |
|
| |
|
| ThreadType(const ThreadType& x) : _thread(x._thread), _id(x._id) |
|
| { |
|
| } |
|
| |
|
| ThreadType(pthread_t thread, Uint32 id) : _thread(thread), _id(id) |
|
| { |
|
| } |
|
| |
|
| ThreadType& operator=(const ThreadType& x) |
|
| { |
|
| if (&x != this) |
|
| { |
|
| _id = x._id; |
|
| _thread = x._thread; |
|
| } |
|
| return *this; |
|
| } | } |
| | |
| pthread_t tt_handle() const |
ThreadType(pthread_t thread_) : thread(thread_) |
| { | { |
| return _thread; |
|
| } | } |
| | |
| void print() const |
pthread_t thread; |
| { |
|
| printf("ThreadType(%lu, %lu)\n", _thread, (unsigned long)_id); |
|
| } |
|
| |
|
| private: |
|
| pthread_t _thread; |
|
| // An id of zero indicates a null object. 1 indicates the main thread. |
|
| Uint32 _id; |
|
| friend class Threads; |
|
| }; | }; |
| #endif /* PEGASUS_HAVE_PTHREADS */ | #endif /* PEGASUS_HAVE_PTHREADS */ |
| | |
| #if defined(PEGASUS_HAVE_WINDOWS_THREADS) | #if defined(PEGASUS_HAVE_WINDOWS_THREADS) |
| struct ThreadType | struct ThreadType |
| { | { |
| ThreadType() : handle(NULL) { } |
ThreadType() : handle(NULL) |
| |
{ |
| |
} |
| |
|
| HANDLE handle; | HANDLE handle; |
| }; | }; |
| #endif /* PEGASUS_HAVE_WINDOWS_THREADS */ | #endif /* PEGASUS_HAVE_WINDOWS_THREADS */ |
|
|
|
| | |
| static void cleanup_pop(int execute); | static void cleanup_pop(int execute); |
| | |
| static Uint32 id(const ThreadType& x = Threads::self()); |
static ThreadId id(const ThreadType& x = Threads::self()); |
| |
|
| |
static bool null(const ThreadType& x = Threads::self()); |
| | |
| static void clear(ThreadType& x); | static void clear(ThreadType& x); |
| }; | }; |
|
|
|
| | |
| inline bool Threads::equal(ThreadType x, ThreadType y) | inline bool Threads::equal(ThreadType x, ThreadType y) |
| { | { |
| return pthread_equal(x.tt_handle(), y.tt_handle()); |
return pthread_equal(x.thread, y.thread); |
| } | } |
| | |
| inline void Threads::exit(ThreadReturnType rc) | inline void Threads::exit(ThreadReturnType rc) |
|
|
|
| | |
| inline void Threads::cancel(ThreadType th, ThreadReturnType rc) | inline void Threads::cancel(ThreadType th, ThreadReturnType rc) |
| { | { |
| pthread_cancel(th.tt_handle()); |
pthread_cancel(th.thread); |
| } | } |
| | |
| inline void Threads::yield() | inline void Threads::yield() |
|
|
|
| defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM) || \ | defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM) || \ |
| defined(PEGASUS_PLATFORM_TRU64_ALPHA_DECCXX) || \ | defined(PEGASUS_PLATFORM_TRU64_ALPHA_DECCXX) || \ |
| defined(PEGASUS_OS_VMS) || \ | defined(PEGASUS_OS_VMS) || \ |
| defined(PEGASUS_OS_ZOS) |
defined(PEGASUS_OS_ZOS) || \ |
| |
defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU) |
| sched_yield(); | sched_yield(); |
| #else | #else |
| pthread_yield(); | pthread_yield(); |
|
|
|
| // ATTN: not implemented. | // ATTN: not implemented. |
| } | } |
| | |
| inline Uint32 Threads::id(const ThreadType& x) |
inline ThreadId Threads::id(const ThreadType& x) |
| { | { |
| return x._id; |
ThreadId tid; |
| |
|
| |
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) |
| |
const char* s = x.thread.__; |
| |
sprintf(tid.buffer, "%X%X%X%X%X%X%X%X", |
| |
s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); |
| |
#else |
| |
sprintf(tid.buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", |
| |
Uint64(x.thread)); |
| |
#endif |
| |
|
| |
return tid; |
| |
} |
| |
|
| |
inline bool Threads::null(const ThreadType& x) |
| |
{ |
| |
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) |
| |
Uint64 tmp; |
| |
memcpy(&tmp, x.thread.__, sizeof(Uint64)); |
| |
return tmp == 0; |
| |
#else |
| |
return x.thread == 0; |
| |
#endif |
| } | } |
| | |
| inline void Threads::clear(ThreadType& x) | inline void Threads::clear(ThreadType& x) |
|
|
|
| inline ThreadType Threads::self() | inline ThreadType Threads::self() |
| { | { |
| ThreadType tt; | ThreadType tt; |
| tt.handle = HANDLE(GetCurrentThreadId()); |
tt.handle = GetCurrentThread(); |
| return tt; | return tt; |
| } | } |
| | |
|
|
|
| // ATTN: Not implemented on Windows. | // ATTN: Not implemented on Windows. |
| } | } |
| | |
| inline Uint32 Threads::id(const ThreadType& x) |
inline ThreadId Threads::id(const ThreadType& x) |
| |
{ |
| |
ThreadId tmp; |
| |
|
| |
sprintf(tmp.buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", |
| |
Uint64(x.handle)); |
| |
|
| |
return tmp; |
| |
} |
| |
|
| |
inline bool Threads::null(const ThreadType& x) |
| { | { |
| return (Uint32)(long)x.handle; |
return x.handle == NULL; |
| } | } |
| | |
| inline void Threads::clear(ThreadType& x) | inline void Threads::clear(ThreadType& x) |
Return to
Threads.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common