Line data    Source code

       1              : // Support for atomic operations -*- C++ -*-
       2              : 
       3              : // Copyright (C) 2004-2023 Free Software Foundation, Inc.
       4              : //
       5              : // This file is part of the GNU ISO C++ Library.  This library is free
       6              : // software; you can redistribute it and/or modify it under the
       7              : // terms of the GNU General Public License as published by the
       8              : // Free Software Foundation; either version 3, or (at your option)
       9              : // any later version.
      10              : 
      11              : // This library is distributed in the hope that it will be useful,
      12              : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13              : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14              : // GNU General Public License for more details.
      15              : 
      16              : // Under Section 7 of GPL version 3, you are granted additional
      17              : // permissions described in the GCC Runtime Library Exception, version
      18              : // 3.1, as published by the Free Software Foundation.
      19              : 
      20              : // You should have received a copy of the GNU General Public License and
      21              : // a copy of the GCC Runtime Library Exception along with this program;
      22              : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23              : // <http://www.gnu.org/licenses/>.
      24              : 
      25              : /** @file ext/atomicity.h
      26              :  *  This file is a GNU extension to the Standard C++ Library.
      27              :  */
      28              : 
      29              : #ifndef _GLIBCXX_ATOMICITY_H
      30              : #define _GLIBCXX_ATOMICITY_H    1
      31              : 
      32              : #pragma GCC system_header
      33              : 
      34              : #include <bits/c++config.h>
      35              : #include <bits/gthr.h>
      36              : #include <bits/atomic_word.h>
      37              : #if __has_include(<sys/single_threaded.h>)
      38              : # include <sys/single_threaded.h>
      39              : #endif
      40              : 
      41              : namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
      42              : {
      43              : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      44              : 
      45              :   __attribute__((__always_inline__))
      46              :   inline bool
      47              :   __is_single_threaded() _GLIBCXX_NOTHROW
      48              :   {
      49              : #ifndef __GTHREADS
      50              :     return true;
      51              : #elif __has_include(<sys/single_threaded.h>)
      52     74550334 :     return ::__libc_single_threaded;
      53              : #else
      54              :     return !__gthread_active_p();
      55              : #endif
      56              :   }
      57              : 
      58              :   // Functions for portable atomic access.
      59              :   // To abstract locking primitives across all thread policies, use:
      60              :   // __exchange_and_add_dispatch
      61              :   // __atomic_add_dispatch
      62              : #ifdef _GLIBCXX_ATOMIC_BUILTINS
      63              :   inline _Atomic_word
      64              :   __attribute__((__always_inline__))
      65              :   __exchange_and_add(volatile _Atomic_word* __mem, int __val)
      66     36925450 :   { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); }
      67              : 
      68              :   inline void
      69              :   __attribute__((__always_inline__))
      70              :   __atomic_add(volatile _Atomic_word* __mem, int __val)
      71     36925448 :   { __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); }
      72              : #else
      73              :   _Atomic_word
      74              :   __exchange_and_add(volatile _Atomic_word*, int) _GLIBCXX_NOTHROW;
      75              : 
      76              :   void
      77              :   __atomic_add(volatile _Atomic_word*, int) _GLIBCXX_NOTHROW;
      78              : #endif
      79              : 
      80              :   inline _Atomic_word
      81              :   __attribute__((__always_inline__))
      82              :   __exchange_and_add_single(_Atomic_word* __mem, int __val)
      83              :   {
      84       699398 :     _Atomic_word __result = *__mem;
      85       699398 :     *__mem += __val;
      86       699398 :     return __result;
      87              :   }
      88              : 
      89              :   inline void
      90              :   __attribute__((__always_inline__))
      91              :   __atomic_add_single(_Atomic_word* __mem, int __val)
      92           38 :   { *__mem += __val; }
      93              : 
      94              :   inline _Atomic_word
      95              :   __attribute__ ((__always_inline__))
      96              :   __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
      97              :   {
      98     37624848 :     if (__is_single_threaded())
      99       699398 :       return __exchange_and_add_single(__mem, __val);
     100              :     else
     101     36925450 :       return __exchange_and_add(__mem, __val);
     102              :   }
     103              : 
     104              :   inline void
     105              :   __attribute__ ((__always_inline__))
     106              :   __atomic_add_dispatch(_Atomic_word* __mem, int __val)
     107              :   {
     108     36925486 :     if (__is_single_threaded())
     109              :       __atomic_add_single(__mem, __val);
     110              :     else
     111              :       __atomic_add(__mem, __val);
     112     36925486 :   }
     113              : 
     114              : _GLIBCXX_END_NAMESPACE_VERSION
     115              : } // namespace
     116              : 
     117              : // Even if the CPU doesn't need a memory barrier, we need to ensure
     118              : // that the compiler doesn't reorder memory accesses across the
     119              : // barriers.
     120              : #ifndef _GLIBCXX_READ_MEM_BARRIER
     121              : #define _GLIBCXX_READ_MEM_BARRIER __atomic_thread_fence (__ATOMIC_ACQUIRE)
     122              : #endif
     123              : #ifndef _GLIBCXX_WRITE_MEM_BARRIER
     124              : #define _GLIBCXX_WRITE_MEM_BARRIER __atomic_thread_fence (__ATOMIC_RELEASE)
     125              : #endif
     126              : 
     127              : #endif