| // -*- C++ -*- |
| |
| // Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
| // |
| // This file is part of the GNU ISO C++ Library. This library is free |
| // software; you can redistribute it and/or modify it under the terms |
| // of the GNU General Public License as published by the Free Software |
| // Foundation; either version 3, or (at your option) any later |
| // version. |
| |
| // This library is distributed in the hope that it will be useful, but |
| // WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| // General Public License for more details. |
| |
| // Under Section 7 of GPL version 3, you are granted additional |
| // permissions described in the GCC Runtime Library Exception, version |
| // 3.1, as published by the Free Software Foundation. |
| |
| // You should have received a copy of the GNU General Public License and |
| // a copy of the GCC Runtime Library Exception along with this program; |
| // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| // <http://www.gnu.org/licenses/>. |
| |
| /** @file parallel/compatibility.h |
| * @brief Compatibility layer, mostly concerned with atomic operations. |
| * This file is a GNU parallel extension to the Standard C++ Library. |
| */ |
| |
| // Written by Felix Putze. |
| |
| #ifndef _GLIBCXX_PARALLEL_COMPATIBILITY_H |
| #define _GLIBCXX_PARALLEL_COMPATIBILITY_H 1 |
| |
| #include <parallel/types.h> |
| #include <parallel/base.h> |
| |
| #if defined(__SUNPRO_CC) && defined(__sparc) |
| #include <sys/atomic.h> |
| #endif |
| |
| #if !defined(_WIN32) || defined (__CYGWIN__) |
| #include <sched.h> |
| #endif |
| |
| #if defined(_MSC_VER) |
| #include <Windows.h> |
| #include <intrin.h> |
| #undef max |
| #undef min |
| #endif |
| |
| #ifdef __MINGW32__ |
| // Including <windows.h> will drag in all the windows32 names. Since |
| // that can cause user code portability problems, we just declare the |
| // one needed function here. |
| extern "C" |
| __attribute((dllimport)) void __attribute__((stdcall)) Sleep (unsigned long); |
| #endif |
| |
| namespace __gnu_parallel |
| { |
| #if defined(__ICC) |
| template<typename _MustBeInt = int> |
| int32_t __faa32(int32_t* __x, int32_t __inc) |
| { |
| asm volatile("lock xadd %0,%1" |
| : "=__r" (__inc), "=__m" (*__x) |
| : "0" (__inc) |
| : "memory"); |
| return __inc; |
| } |
| #if defined(__x86_64) |
| template<typename _MustBeInt = int> |
| int64_t __faa64(int64_t* __x, int64_t __inc) |
| { |
| asm volatile("lock xadd %0,%1" |
| : "=__r" (__inc), "=__m" (*__x) |
| : "0" (__inc) |
| : "memory"); |
| return __inc; |
| } |
| #endif |
| #endif |
| |
| // atomic functions only work on integers |
| |
| /** @brief Add a value to a variable, atomically. |
| * |
| * Implementation is heavily platform-dependent. |
| * @param __ptr Pointer to a 32-bit signed integer. |
| * @param __addend Value to add. |
| */ |
| inline int32_t |
| __fetch_and_add_32(volatile int32_t* __ptr, int32_t __addend) |
| { |
| #if defined(__ICC) //x86 version |
| return _InterlockedExchangeAdd((void*)__ptr, __addend); |
| #elif defined(__ECC) //IA-64 version |
| return _InterlockedExchangeAdd((void*)__ptr, __addend); |
| #elif defined(__ICL) || defined(_MSC_VER) |
| return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(__ptr), |
| __addend); |
| #elif defined(__GNUC__) |
| return __sync_fetch_and_add(__ptr, __addend); |
| #elif defined(__SUNPRO_CC) && defined(__sparc) |
| volatile int32_t __before, __after; |
| do |
| { |
| __before = *__ptr; |
| __after = __before + __addend; |
| } while (atomic_cas_32((volatile unsigned int*)__ptr, __before, |
| __after) != __before); |
| return __before; |
| #else //fallback, slow |
| #pragma message("slow __fetch_and_add_32") |
| int32_t __res; |
| #pragma omp critical |
| { |
| __res = *__ptr; |
| *(__ptr) += __addend; |
| } |
| return __res; |
| #endif |
| } |
| |
| /** @brief Add a value to a variable, atomically. |
| * |
| * Implementation is heavily platform-dependent. |
| * @param __ptr Pointer to a 64-bit signed integer. |
| * @param __addend Value to add. |
| */ |
| inline int64_t |
| __fetch_and_add_64(volatile int64_t* __ptr, int64_t __addend) |
| { |
| #if defined(__ICC) && defined(__x86_64) //x86 version |
| return __faa64<int>((int64_t*)__ptr, __addend); |
| #elif defined(__ECC) //IA-64 version |
| return _InterlockedExchangeAdd64((void*)__ptr, __addend); |
| #elif defined(__ICL) || defined(_MSC_VER) |
| #ifndef _WIN64 |
| _GLIBCXX_PARALLEL_ASSERT(false); //not available in this case |
| return 0; |
| #else |
| return _InterlockedExchangeAdd64(__ptr, __addend); |
| #endif |
| #elif defined(__GNUC__) && defined(__x86_64) |
| return __sync_fetch_and_add(__ptr, __addend); |
| #elif defined(__GNUC__) && defined(__i386) && \ |
| (defined(__i686) || defined(__pentium4) || defined(__athlon) \ |
| || defined(__k8) || defined(__core2)) |
| return __sync_fetch_and_add(__ptr, __addend); |
| #elif defined(__SUNPRO_CC) && defined(__sparc) |
| volatile int64_t __before, __after; |
| do |
| { |
| __before = *__ptr; |
| __after = __before + __addend; |
| } while (atomic_cas_64((volatile unsigned long long*)__ptr, __before, |
| __after) != __before); |
| return __before; |
| #else //fallback, slow |
| #if defined(__GNUC__) && defined(__i386) |
| // XXX doesn'__t work with -march=native |
| //#warning "please compile with -march=i686 or better" |
| #endif |
| #pragma message("slow __fetch_and_add_64") |
| int64_t __res; |
| #pragma omp critical |
| { |
| __res = *__ptr; |
| *(__ptr) += __addend; |
| } |
| return __res; |
| #endif |
| } |
| |
| /** @brief Add a value to a variable, atomically. |
| * |
| * Implementation is heavily platform-dependent. |
| * @param __ptr Pointer to a signed integer. |
| * @param __addend Value to add. |
| */ |
| template<typename _Tp> |
| inline _Tp |
| __fetch_and_add(volatile _Tp* __ptr, _Tp __addend) |
| { |
| if (sizeof(_Tp) == sizeof(int32_t)) |
| return |
| (_Tp)__fetch_and_add_32((volatile int32_t*) __ptr, (int32_t)__addend); |
| else if (sizeof(_Tp) == sizeof(int64_t)) |
| return |
| (_Tp)__fetch_and_add_64((volatile int64_t*) __ptr, (int64_t)__addend); |
| else |
| _GLIBCXX_PARALLEL_ASSERT(false); |
| } |
| |
| |
| #if defined(__ICC) |
| |
| template<typename _MustBeInt = int> |
| inline int32_t |
| __cas32(volatile int32_t* __ptr, int32_t __old, int32_t __nw) |
| { |
| int32_t __before; |
| __asm__ __volatile__("lock; cmpxchgl %1,%2" |
| : "=a"(__before) |
| : "q"(__nw), "__m"(*(volatile long long*)(__ptr)), |
| "0"(__old) |
| : "memory"); |
| return __before; |
| } |
| |
| #if defined(__x86_64) |
| template<typename _MustBeInt = int> |
| inline int64_t |
| __cas64(volatile int64_t *__ptr, int64_t __old, int64_t __nw) |
| { |
| int64_t __before; |
| __asm__ __volatile__("lock; cmpxchgq %1,%2" |
| : "=a"(__before) |
| : "q"(__nw), "__m"(*(volatile long long*)(__ptr)), |
| "0"(__old) |
| : "memory"); |
| return __before; |
| } |
| #endif |
| |
| #endif |
| |
| /** @brief Compare @c *__ptr and @c __comparand. If equal, let @c |
| * *__ptr=__replacement and return @c true, return @c false otherwise. |
| * |
| * Implementation is heavily platform-dependent. |
| * @param __ptr Pointer to 32-bit signed integer. |
| * @param __comparand Compare value. |
| * @param __replacement Replacement value. |
| */ |
| inline bool |
| __compare_and_swap_32(volatile int32_t* __ptr, int32_t __comparand, |
| int32_t __replacement) |
| { |
| #if defined(__ICC) //x86 version |
| return _InterlockedCompareExchange((void*)__ptr, __replacement, |
| __comparand) == __comparand; |
| #elif defined(__ECC) //IA-64 version |
| return _InterlockedCompareExchange((void*)__ptr, __replacement, |
| __comparand) == __comparand; |
| #elif defined(__ICL) || defined(_MSC_VER) |
| return _InterlockedCompareExchange( |
| reinterpret_cast<volatile long*>(__ptr), |
| __replacement, __comparand) |
| == __comparand; |
| #elif defined(__GNUC__) |
| return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement); |
| #elif defined(__SUNPRO_CC) && defined(__sparc) |
| return atomic_cas_32((volatile unsigned int*)__ptr, __comparand, |
| __replacement) == __comparand; |
| #else |
| #pragma message("slow __compare_and_swap_32") |
| bool __res = false; |
| #pragma omp critical |
| { |
| if (*__ptr == __comparand) |
| { |
| *__ptr = __replacement; |
| __res = true; |
| } |
| } |
| return __res; |
| #endif |
| } |
| |
| /** @brief Compare @c *__ptr and @c __comparand. If equal, let @c |
| * *__ptr=__replacement and return @c true, return @c false otherwise. |
| * |
| * Implementation is heavily platform-dependent. |
| * @param __ptr Pointer to 64-bit signed integer. |
| * @param __comparand Compare value. |
| * @param __replacement Replacement value. |
| */ |
| inline bool |
| __compare_and_swap_64(volatile int64_t* __ptr, int64_t __comparand, |
| int64_t __replacement) |
| { |
| #if defined(__ICC) && defined(__x86_64) //x86 version |
| return __cas64<int>(__ptr, __comparand, __replacement) == __comparand; |
| #elif defined(__ECC) //IA-64 version |
| return _InterlockedCompareExchange64((void*)__ptr, __replacement, |
| __comparand) == __comparand; |
| #elif defined(__ICL) || defined(_MSC_VER) |
| #ifndef _WIN64 |
| _GLIBCXX_PARALLEL_ASSERT(false); //not available in this case |
| return 0; |
| #else |
| return _InterlockedCompareExchange64(__ptr, __replacement, |
| __comparand) == __comparand; |
| #endif |
| |
| #elif defined(__GNUC__) && defined(__x86_64) |
| return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement); |
| #elif defined(__GNUC__) && defined(__i386) && \ |
| (defined(__i686) || defined(__pentium4) || defined(__athlon) \ |
| || defined(__k8) || defined(__core2)) |
| return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement); |
| #elif defined(__SUNPRO_CC) && defined(__sparc) |
| return atomic_cas_64((volatile unsigned long long*)__ptr, |
| __comparand, __replacement) == __comparand; |
| #else |
| #if defined(__GNUC__) && defined(__i386) |
| // XXX -march=native |
| //#warning "please compile with -march=i686 or better" |
| #endif |
| #pragma message("slow __compare_and_swap_64") |
| bool __res = false; |
| #pragma omp critical |
| { |
| if (*__ptr == __comparand) |
| { |
| *__ptr = __replacement; |
| __res = true; |
| } |
| } |
| return __res; |
| #endif |
| } |
| |
| /** @brief Compare @c *__ptr and @c __comparand. If equal, let @c |
| * *__ptr=__replacement and return @c true, return @c false otherwise. |
| * |
| * Implementation is heavily platform-dependent. |
| * @param __ptr Pointer to signed integer. |
| * @param __comparand Compare value. |
| * @param __replacement Replacement value. */ |
| template<typename _Tp> |
| inline bool |
| __compare_and_swap(volatile _Tp* __ptr, _Tp __comparand, _Tp __replacement) |
| { |
| if (sizeof(_Tp) == sizeof(int32_t)) |
| return __compare_and_swap_32((volatile int32_t*) __ptr, |
| (int32_t)__comparand, |
| (int32_t)__replacement); |
| else if (sizeof(_Tp) == sizeof(int64_t)) |
| return __compare_and_swap_64((volatile int64_t*) __ptr, |
| (int64_t)__comparand, |
| (int64_t)__replacement); |
| else |
| _GLIBCXX_PARALLEL_ASSERT(false); |
| } |
| |
| /** @brief Yield the control to another thread, without waiting for |
| the end to the time slice. */ |
| inline void |
| __yield() |
| { |
| #if defined (_WIN32) && !defined (__CYGWIN__) |
| Sleep(0); |
| #else |
| sched_yield(); |
| #endif |
| } |
| } // end namespace |
| |
| #endif /* _GLIBCXX_PARALLEL_COMPATIBILITY_H */ |
