diff options
Diffstat (limited to 'libstdc++-v3/include/parallel/compatibility.h')
| -rw-r--r-- | libstdc++-v3/include/parallel/compatibility.h | 364 |
1 files changed, 364 insertions, 0 deletions
diff --git a/libstdc++-v3/include/parallel/compatibility.h b/libstdc++-v3/include/parallel/compatibility.h new file mode 100644 index 000000000..9fffd8e01 --- /dev/null +++ b/libstdc++-v3/include/parallel/compatibility.h @@ -0,0 +1,364 @@ +// -*- 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 */ |