Removed memory order argument from atomic_fence.

The code uses memory_order_seq_cst in all call sites of atomic_fence,
so remove the argument and simplifiy the implementation a bit. Also, renamed
the function to make the memory order it implements apparent.

Signed-off-by: Andrey Semashev <andrey.semashev@gmail.com>

include/oneapi/tbb/detail/_machine.h

@@ -76,22 +76,15 @@ using std::this_thread::yield;
 #endif
 
 //--------------------------------------------------------------------------------------------------
-// atomic_fence implementation
+// atomic_fence_seq_cst implementation
 //--------------------------------------------------------------------------------------------------
 
-static inline void atomic_fence(std::memory_order order) {
+static inline void atomic_fence_seq_cst() {
 #if (__TBB_x86_64 || __TBB_x86_32) && defined(__GNUC__) && __GNUC__ < 11
-    if (order == std::memory_order_seq_cst)
-    {
-        unsigned char dummy = 0u;
-        __asm__ __volatile__ ("lock; notb %0" : "+m" (dummy) :: "memory");
-    }
-    else if (order != std::memory_order_relaxed)
-    {
-        __asm__ __volatile__ ("" ::: "memory");
-    }
+    unsigned char dummy = 0u;
+    __asm__ __volatile__ ("lock; notb %0" : "+m" (dummy) :: "memory");
 #else
-    std::atomic_thread_fence(order);
+    std::atomic_thread_fence(std::memory_order_seq_cst);
 #endif
 }
 

src/tbb/arena.h

@@ -494,7 +494,7 @@ void arena::advertise_new_work() {
     };
 
     if( work_type == work_enqueued ) {
-        atomic_fence(std::memory_order_seq_cst);
+        atomic_fence_seq_cst();
 #if __TBB_ENQUEUE_ENFORCED_CONCURRENCY
         if ( my_market->my_num_workers_soft_limit.load(std::memory_order_acquire) == 0 &&
             my_global_concurrency_mode.load(std::memory_order_acquire) == false )
@@ -508,7 +508,7 @@ void arena::advertise_new_work() {
         // Starvation resistant tasks require concurrency, so missed wakeups are unacceptable.
     }
     else if( work_type == wakeup ) {
-        atomic_fence(std::memory_order_seq_cst);
+        atomic_fence_seq_cst();
     }
 
     // Double-check idiom that, in case of spawning, is deliberately sloppy about memory fences.

src/tbb/concurrent_monitor.h

@@ -220,7 +220,7 @@ class concurrent_monitor_base {
 
         // Prepare wait guarantees Write Read memory barrier.
         // In C++ only full fence covers this type of barrier.
-        atomic_fence(std::memory_order_seq_cst);
+        atomic_fence_seq_cst();
     }
 
     //! Commit wait if event count has not changed; otherwise, cancel wait.
@@ -272,7 +272,7 @@ class concurrent_monitor_base {
 
     //! Notify one thread about the event
     void notify_one() {
-        atomic_fence(std::memory_order_seq_cst);
+        atomic_fence_seq_cst();
         notify_one_relaxed();
     }
 
@@ -301,7 +301,7 @@ class concurrent_monitor_base {
 
     //! Notify all waiting threads of the event
     void notify_all() {
-        atomic_fence(std::memory_order_seq_cst);
+        atomic_fence_seq_cst();
         notify_all_relaxed();
     }
 
@@ -337,7 +337,7 @@ class concurrent_monitor_base {
     //! Notify waiting threads of the event that satisfies the given predicate
     template <typename P>
     void notify( const P& predicate ) {
-        atomic_fence(std::memory_order_seq_cst);
+        atomic_fence_seq_cst();
         notify_relaxed( predicate );
     }
 
@@ -409,7 +409,7 @@ class concurrent_monitor_base {
 
     //! Abort any sleeping threads at the time of the call
     void abort_all() {
-        atomic_fence( std::memory_order_seq_cst );
+        atomic_fence_seq_cst();
         abort_all_relaxed();
     }