fix(rocprim): backport atomic ordered block id toggle via env variable (#763)

* fix(rocprim): backport atomic ordered block id toggle via env variable

* fix(rocprim): fix device_run_length_encode failure

* style(rocprim): update style

Author: Naraenda

benchmark/benchmark_block_run_length_decode.cpp

@@ -29,6 +29,7 @@
 #include <rocprim/block/block_run_length_decode.hpp>
 #include <rocprim/block/block_store_func.hpp>
 
+#include <chrono>
 #include <random>
 #include <vector>
 

common/utils.hpp

@@ -25,31 +25,33 @@
 
 #include <rocprim/intrinsics/thread.hpp>
 
-#ifdef USE_GTEST
-    // GoogleTest-compatible HIP_CHECK macro. FAIL is called to log the Google Test trace.
-    // The lambda is invoked immediately as assertions that generate a fatal failure can
-    // only be used in void-returning functions.
-    #define HIP_CHECK(condition)                                                            \
-        {                                                                                   \
-            hipError_t error = condition;                                                   \
-            if(error != hipSuccess)                                                         \
-            {                                                                               \
-                [error]()                                                                   \
-                { FAIL() << "HIP error " << error << ": " << hipGetErrorString(error); }(); \
-                exit(error);                                                                \
-            }                                                                               \
-        }
-#else
-    #define HIP_CHECK(condition)                                                                \
-        {                                                                                       \
-            hipError_t error = condition;                                                       \
-            if(error != hipSuccess)                                                             \
+#ifndef HIP_CHECK
+    #ifdef USE_GTEST
+        // GoogleTest-compatible HIP_CHECK macro. FAIL is called to log the Google Test trace.
+        // The lambda is invoked immediately as assertions that generate a fatal failure can
+        // only be used in void-returning functions.
+        #define HIP_CHECK(condition)                                                            \
             {                                                                                   \
-                std::cout << "HIP error: " << hipGetErrorString(error) << " file: " << __FILE__ \
-                          << " line: " << __LINE__ << std::endl;                                \
-                exit(error);                                                                    \
-            }                                                                                   \
-        }
+                hipError_t error = condition;                                                   \
+                if(error != hipSuccess)                                                         \
+                {                                                                               \
+                    [error]()                                                                   \
+                    { FAIL() << "HIP error " << error << ": " << hipGetErrorString(error); }(); \
+                    exit(error);                                                                \
+                }                                                                               \
+            }
+    #else
+        #define HIP_CHECK(condition)                                                          \
+            {                                                                                 \
+                hipError_t error = condition;                                                 \
+                if(error != hipSuccess)                                                       \
+                {                                                                             \
+                    std::cout << "HIP error: " << hipGetErrorString(error)                    \
+                              << " file: " << __FILE__ << " line: " << __LINE__ << std::endl; \
+                    exit(error);                                                              \
+                }                                                                             \
+            }
+    #endif
 #endif
 
 namespace common

rocprim/include/rocprim/detail/various.hpp

@@ -439,6 +439,36 @@ struct select_max_by_value<T, U, Vs...>
 template<typename... Ts>
 using select_max_by_value_t = typename select_max_by_value<Ts...>::type;
 
+struct lookback_variant_util
+{
+    bool use_sleep;
+    bool use_atomic;
+
+    lookback_variant_util(bool use_sleep, bool use_atomic)
+        : use_sleep(use_sleep), use_atomic(use_atomic)
+    {}
+
+    template<typename Func>
+    auto operator()(Func f /* [](auto use_sleep, auto use_atomic){ ... } */)
+    {
+        using T = std::integral_constant<bool, true>;
+        using F = std::integral_constant<bool, false>;
+        if(use_sleep)
+        {
+            if(use_atomic)
+            {
+                return f(T{}, T{});
+            }
+            return f(T{}, F{});
+        }
+        if(use_atomic)
+        {
+            return f(F{}, T{});
+        }
+        return f(F{}, F{});
+    }
+};
+
 } // end namespace detail
 END_ROCPRIM_NAMESPACE