/*

  *

  *

  * Copyright (c) 1994

  * Hewlett-Packard Company

  *

  * Copyright (c) 1996,1997

  * Silicon Graphics Computer Systems, Inc.

  *

  * Copyright (c) 1997

  * Moscow Center for SPARC Technology

  *

  * Copyright (c) 1999

  * Boris Fomitchev

  *

  * This material is provided "as is", with absolutely no warranty expressed

  * or implied. Any use is at your own risk.

  *

  * Permission to use or copy this software for any purpose is hereby granted

  * without fee, provided the above notices are retained on all copies.

  * Permission to modify the code and to distribute modified code is granted,

  * provided the above notices are retained, and a notice that the code was

  * modified is included with the above copyright notice.

  *

  */

 #ifndef _STLP_THREADS_C

 #define _STLP_THREADS_C

 #ifndef _STLP_INTERNAL_THREADS_H

 #  include <stl/_threads.h>

 #endif

 #if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)

 #if defined (_STLP_SGI_THREADS)

 #  include <time.h>

 #elif defined (_STLP_UNIX)

 #  ifndef _STLP_INTERNAL_CTIME

 #    include <stl/_ctime.h>

 #  endif

 #  if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_VENDOR_GLOBAL_CSTD)

 using _STLP_VENDOR_CSTD::time_t;

 #  endif

 #  include <sys/time.h>

 #endif

 _STLP_BEGIN_NAMESPACE

 #if (_STLP_STATIC_TEMPLATE_DATA > 0)

 #  if defined (_STLP_USE_ATOMIC_SWAP_MUTEX)

 template<int __32bits>

 _STLP_STATIC_MUTEX

 _Atomic_swap_struct<__32bits>::_S_swap_lock _STLP_MUTEX_INITIALIZER;

 #    undef _STLP_USE_ATOMIC_SWAP_MUTEX

 #  endif

 #  if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)

 template <int __inst>

 unsigned _STLP_mutex_spin<__inst>::__max = _STLP_mutex_spin<__inst>::__low_max;

 template <int __inst>

 unsigned _STLP_mutex_spin<__inst>::__last = 0;

 #  endif // _STLP_USE_PTHREAD_SPINLOCK

 #else /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

 #  if defined (_STLP_USE_ATOMIC_SWAP_MUTEX)

 __DECLARE_INSTANCE(_STLP_STATIC_MUTEX, _Atomic_swap_struct<sizeof(__stl_atomic_t) == sizeof(void*)>::_S_swap_lock,

                    _STLP_MUTEX_INITIALIZER  );

 #    undef _STLP_USE_ATOMIC_SWAP_MUTEX

 #  endif /* _STLP_PTHREADS */

 #  if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)

 __DECLARE_INSTANCE(unsigned, _STLP_mutex_spin<0>::__max,  =30);

 __DECLARE_INSTANCE(unsigned, _STLP_mutex_spin<0>::__last, =0);

 #  endif // _STLP_USE_PTHREAD_SPINLOCK

 #endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

 #if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)

 #  if defined (_STLP_SPARC_SOLARIS_THREADS)

 // underground function in libc.so; we do not want dependance on librt

 extern "C" int __nanosleep(const struct timespec*, struct timespec*);

 #    define _STLP_NANOSLEEP __nanosleep

 #  else

 #    define _STLP_NANOSLEEP nanosleep

 #  endif

 template <int __inst>

 void _STLP_CALL

 _STLP_mutex_spin<__inst>::_S_nsec_sleep(int __log_nsec) {

 #  if defined (_STLP_WIN32THREADS)

   if (__log_nsec <= 20) {

     // Note from boost (www.boost.org):

     // Changed to Sleep(1) from Sleep(0).

     // According to MSDN, Sleep(0) will never yield

     // to a lower-priority thread, whereas Sleep(1)

     // will. Performance seems not to be affected.

     Sleep(1);

   } else {

     Sleep(1 << (__log_nsec - 20));

   }

 #  elif defined(_STLP_OS2THREADS)

   if (__log_nsec <= 20) {

     DosSleep(0);

   } else {

     DosSleep(1 << (__log_nsec - 20));

   }

 #  elif defined (_STLP_UNIX)

   timespec __ts;

   /* Max sleep is 2**27nsec ~ 60msec      */

   __ts.tv_sec = 0;

   __ts.tv_nsec = 1 << __log_nsec;

   _STLP_NANOSLEEP(&__ts, 0);

 #  endif

 }

 template <int __inst>

 void  _STLP_CALL

 _STLP_mutex_spin<__inst>::_M_do_lock(volatile __stl_atomic_t* __lock) {

 #  if defined(_STLP_ATOMIC_EXCHANGE)

   if (_Atomic_swap(__lock, 1)) {

     unsigned __my_spin_max = _STLP_mutex_spin<0>::__max;

     unsigned __my_last_spins = _STLP_mutex_spin<0>::__last;

     volatile unsigned __junk = 17;   // Value doesn't matter.

     unsigned  __i;

     for (__i = 0; __i < __my_spin_max; ++__i) {

       if (__i < __my_last_spins/2 || *__lock) {

         __junk *= __junk; __junk *= __junk;

         __junk *= __junk; __junk *= __junk;

       } else {

         if (!_Atomic_swap(__lock, 1)) {

           // got it!

           // Spinning worked.  Thus we're probably not being scheduled

           // against the other process with which we were contending.

           // Thus it makes sense to spin longer the next time.

           _STLP_mutex_spin<0>::__last = __i;

           _STLP_mutex_spin<0>::__max = _STLP_mutex_spin<0>::__high_max;

           return;

         }

       }

     }

     // We are probably being scheduled against the other process.  Sleep.

     _STLP_mutex_spin<0>::__max = _STLP_mutex_spin<0>::__low_max;

     for (__i = 0 ;; ++__i) {

       int __log_nsec = __i + 6;

       if (__log_nsec > 27) __log_nsec = 27;

       if (!_Atomic_swap(__lock, 1)) {

         break;

       }

       _S_nsec_sleep(__log_nsec);

     }

   } /* first _Atomic_swap */

 #  endif

 }

 #endif // _STLP_USE_PTHREAD_SPINLOCK

 _STLP_END_NAMESPACE

 #endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */

 #endif /*  _STLP_THREADS_C */

 // Local Variables:

 // mode:C++

 // End: