(file) Return to Threads.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Threads.h between version 1.1.2.10 and 1.15.2.3

version 1.1.2.10, 2006/08/02 07:26:35 version 1.15.2.3, 2008/06/26 12:02:52
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (m.brasher@inovadevelopment.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_Threads_h #ifndef Pegasus_Threads_h
 #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>
  
 // ATTN: can we consolidate these someplace? // ATTN: can we consolidate these someplace?
  
 #if defined(PEGASUS_HAVE_PTHREADS)  #ifdef PEGASUS_OS_ZOS
 # if defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM)  # include <sched.h>
 # define _MULTI_THREADED // Is this really necessary?  
 # endif # endif
   #if defined(PEGASUS_HAVE_PTHREADS)
 # include <pthread.h> # include <pthread.h>
 # include <errno.h> # include <errno.h>
 # include <sys/time.h> # include <sys/time.h>
Line 56 
Line 56 
 # error "<Pegasus/Common/Threads.h>: not implemented" # error "<Pegasus/Common/Threads.h>: not implemented"
 #endif #endif
  
   #if defined(PEGASUS_PLATFORM_SOLARIS_IX86_CC) || \
       defined(PEGASUS_PLATFORM_SOLARIS_X86_64_CC) || \
       defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)
   # include <string.h>
   # include <stdio.h>
   #endif
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 //============================================================================== //==============================================================================
Line 64 
Line 71 
 // //
 //============================================================================== //==============================================================================
  
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  #if defined(PEGASUS_OS_TYPE_WINDOWS)
 # define PEGASUS_THREAD_CDECL __stdcall # define PEGASUS_THREAD_CDECL __stdcall
 #else #else
 # define PEGASUS_THREAD_CDECL /* empty */ # define PEGASUS_THREAD_CDECL /* empty */
Line 72 
Line 79 
  
 //============================================================================== //==============================================================================
 // //
   // ThreadId
   //
   //==============================================================================
   
   struct ThreadId
   {
       // The character representation of a uint64 requires 22 bytes including the
       // null terminator.
       char buffer[22];
   };
   
   //==============================================================================
   //
 // ThreadType // ThreadType
 // //
 //============================================================================== //==============================================================================
Line 79 
Line 99 
 #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  
     {  
         return _thread;  
     }     }
  
     void print() const      ThreadType(pthread_t thread_) : thread(thread_)
     {     {
         printf("ThreadType(%lu, %lu)\n", _thread, (unsigned long)_id);  
     }     }
  
 private:      pthread_t thread;
     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 */
Line 196 
Line 189 
  
     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);
 }; };
Line 211 
Line 206 
  
 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)
 { {
       // NOTE: pthread_exit exhibits unusual behavior on RHEL 3 U2, as
       // documented in Bugzilla 3836.  Where feasible, it may be advantageous
       // to avoid using this function.
     pthread_exit(rc);     pthread_exit(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()
 { {
 #if defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || \ #if defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX) || \
       defined(PEGASUS_PLATFORM_PASE_ISERIES_IBMCXX) || \
     defined(PEGASUS_PLATFORM_HPUX_ACC) || \     defined(PEGASUS_PLATFORM_HPUX_ACC) || \
     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_OS_DARWIN) || \
       defined(PEGASUS_PLATFORM_SOLARIS_IX86_CC) || \
       defined(PEGASUS_PLATFORM_SOLARIS_X86_64_CC) || \
       defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)
     sched_yield();     sched_yield();
 #else #else
     pthread_yield();     pthread_yield();
Line 253 
Line 255 
     // ATTN: not implemented.     // ATTN: not implemented.
 } }
  
 inline Uint32 Threads::id(const ThreadType& x)  inline ThreadId Threads::id(const ThreadType& x)
   {
       ThreadId tid = { { 0 } };
   
   #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)
 { {
     return x._id;  #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)
Line 276 
Line 300 
 inline ThreadType Threads::self() inline ThreadType Threads::self()
 { {
     ThreadType tt;     ThreadType tt;
     tt.handle = HANDLE(GetCurrentThreadId());      tt.handle = GetCurrentThread();
     return tt;     return tt;
 } }
  
Line 310 
Line 334 
     // 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)

Legend:
Removed from v.1.1.2.10  
changed lines
  Added in v.1.15.2.3
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2