stl/_threads.c

/*
 *
 *
 * 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: