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

Diff for /pegasus/src/Pegasus/Common/Threads.cpp between version 1.1.2.1 and 1.10.8.1

version 1.1.2.1, 2006/07/27 23:11:52 version 1.10.8.1, 2007/11/09 18:59:30
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (m.brasher@inovadevelopment.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
   #include <errno.h>
 #include "Threads.h" #include "Threads.h"
   #include "IDFactory.h"
   #include "TSDKey.h"
   #include "Once.h"
   
   #if defined(PEGASUS_OS_TYPE_WINDOWS)
   # include <sys/timeb.h>
   #endif
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 41 
Line 47 
 { {
 #if defined(PEGASUS_HAVE_NANOSLEEP) #if defined(PEGASUS_HAVE_NANOSLEEP)
  
     struct timespec wait;      struct timespec wait, remwait;
     wait.tv_sec = msec / 1000;     wait.tv_sec = msec / 1000;
     wait.tv_nsec = (msec % 1000) * 1000000;     wait.tv_nsec = (msec % 1000) * 1000000;
     nanosleep(&wait, NULL);  
   
 #elif defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM)  
   
    int loop;  
    int microsecs = msec * 1000; /* convert from milliseconds to microseconds */  
  
    if (microsecs < 1000000)      while ((nanosleep(&wait, &remwait) == -1) && (errno == EINTR))
        usleep(microsecs);  
    else  
    {    {
        loop = microsecs / 1000000;          wait.tv_sec = remwait.tv_sec;
        for(int i = 0; i < loop; i++)          wait.tv_nsec = remwait.tv_nsec;
            usleep(1000000);  
        if ((loop*1000000) < microsecs)  
            usleep(microsecs - (loop*1000000));  
    }    }
  
 #elif defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  #elif defined(PEGASUS_OS_TYPE_WINDOWS)
  
     if (ms == 0)      if (msec == 0)
     {     {
         Sleep(0);         Sleep(0);
         return;         return;
Line 72 
Line 67 
  
     struct _timeb end, now;     struct _timeb end, now;
     _ftime( &end );     _ftime( &end );
     end.time += (ms / 1000);      end.time += (msec / 1000);
     ms -= (ms / 1000);      msec -= (msec / 1000);
     end.millitm += ms;      end.millitm += msec;
  
     do     do
     {     {
Line 85 
Line 80 
  
 #elif defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) #elif defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
     int seconds;     int seconds;
     int microsecs = msec * 1000;      if (msec < 1000)
   
     if (microsecs < 1000000)  
     {     {
         usleep(microsecs/2);          usleep(msec*1000);
         pthread_testintr();  
         usleep(microsecs/2);  
     }     }
     else     else
     {     {
         // sleep for loop seconds         // sleep for loop seconds
         seconds = microsecs / 1000000;          ::sleep(msec / 1000);
         sleep(seconds);          // Usleep the remaining micro seconds
           usleep( (msec*1000) % 1000000 );
       }
   #endif
   }
   
   //==============================================================================
   //
   // _get_stack_multiplier()
   //
   //==============================================================================
   
   static inline int _get_stack_multiplier()
   {
   #if defined(PEGASUS_OS_VMS)
   
       static int _multiplier = 0;
       static MutexType _multiplier_mutex = PEGASUS_MUTEX_INITIALIZER;
  
         // Usleep the remaining time      //
         if ((seconds*1000000) < microsecs)      // This code uses a, 'hidden' (non-documented), VMS only, logical
             usleep(microsecs - (seconds*1000000));      //  name (environment variable), PEGASUS_VMS_THREAD_STACK_MULTIPLIER,
       //  to allow in the field adjustment of the thread stack size.
       //
       // We only check for the logical name once to not have an
       //  impact on performance.
       //
       // Note:  This code may have problems in a multithreaded environment
       //  with the setting of doneOnce to true.
       //
       // Current code in Cimserver and the clients do some serial thread
       //  creations first so this is not a problem now.
       //
   
       if (_multiplier == 0)
       {
           mutex_lock(&_multiplier_mutex);
   
           if (_multiplier == 0)
           {
               const char *env = getenv("PEGASUS_VMS_THREAD_STACK_MULTIPLIER");
   
               if (env)
                   _multiplier = atoi(env);
   
               if (_multiplier == 0)
                   _multiplier = 2;
     }     }
 #elif defined(PEGASUS_OS_VMS)  
  
     sleep(msec / 1000);          mutex_unlock(&_multiplier_mutex);
       }
  
       return _multiplier;
   #elif defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
       return 2;
   #else
       return 1;
 #endif #endif
 } }
  
   //==============================================================================
   //
   // PEGASUS_HAVE_PTHREADS
   //
   //==============================================================================
   
   #if defined(PEGASUS_HAVE_PTHREADS)
   
   int Threads::create(
       ThreadType& thread,
       Type type,
       void* (*start)(void*),
       void* arg)
   {
       // Initialize thread attributes:
   
       pthread_attr_t attr;
       pthread_attr_init(&attr);
   
       // Detached:
   
       if (type == DETACHED)
       {
   #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
           int ds = 1;
           pthread_attr_setdetachstate(&attr, &ds);
   #else
           pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   #endif
       }
   
       // Stack size:
   
       int multiplier = _get_stack_multiplier();
   
       if (multiplier != 1)
       {
           size_t stacksize;
   
           if (pthread_attr_getstacksize(&attr, &stacksize) == 0)
           {
               int rc = pthread_attr_setstacksize(&attr, stacksize * multiplier);
               PEGASUS_ASSERT(rc == 0);
           }
       }
   
       // Scheduling policy:
   
   #if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_GNU) || \
       defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)
   # if defined SUNOS_5_7
       pthread_attr_setschedpolicy(&attr, SCHED_RR);
   # else
       pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
   # endif
   #endif // PEGASUS_PLATFORM_SOLARIS_SPARC_GNU
   
       // Create thread:
   
       int rc = pthread_create(&thread.thread, &attr, start, arg);
   
       if (rc != 0)
       {
           thread = ThreadType();
           return rc;
       }
   
       // Destroy attributes now.
   
       pthread_attr_destroy(&attr);
   
       // Return:
   
       return 0;
   }
   
   ThreadType Threads::self()
   {
       ThreadType tt;
       tt.thread = pthread_self();
       return tt;
   }
   
   #endif /* PEGASUS_HAVE_PTHREADS */
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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