[Openmp-commits] [openmp] [OpenMP][NFC] Put ExponentialBackoff in a Utils header (PR #73816)

[via Openmp-commits]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-openmp

Author: Johannes Doerfert (jdoerfert)

<details>
<summary>Changes</summary>

"private.h" will go.

---
Full diff: https://github.com/llvm/llvm-project/pull/73816.diff


3 Files Affected:

- (added) openmp/libomptarget/include/Utils/ExponentialBackoff.h (+52) 
- (modified) openmp/libomptarget/src/interface.cpp (+3-1) 
- (modified) openmp/libomptarget/src/private.h (-29) 


``````````diff
diff --git a/openmp/libomptarget/include/Utils/ExponentialBackoff.h b/openmp/libomptarget/include/Utils/ExponentialBackoff.h
new file mode 100644
index 000000000000000..b500cc37e2a6693
--- /dev/null
+++ b/openmp/libomptarget/include/Utils/ExponentialBackoff.h
@@ -0,0 +1,52 @@
+//===-- Utils/ExponentialBackoff.h - Heuristic helper class ------*- C++ -*===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implement exponential backoff counting.
+// Linearly increments until given maximum, exponentially decrements based on
+// given backoff factor.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OMPTARGET_UTILS_EXPONENTIAL_BACKOFF_H
+#define OMPTARGET_UTILS_EXPONENTIAL_BACKOFF_H
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+
+namespace utils {
+
+class ExponentialBackoff {
+  int64_t Count = 0;
+  const int64_t MaxCount = 0;
+  const int64_t CountThreshold = 0;
+  const float BackoffFactor = 0.0f;
+
+public:
+  ExponentialBackoff(int64_t MaxCount, int64_t CountThreshold,
+                     float BackoffFactor)
+      : MaxCount(MaxCount), CountThreshold(CountThreshold),
+        BackoffFactor(BackoffFactor) {
+    assert(MaxCount >= 0 &&
+           "ExponentialBackoff: maximum count value should be non-negative");
+    assert(CountThreshold >= 0 &&
+           "ExponentialBackoff: count threshold value should be non-negative");
+    assert(BackoffFactor >= 0 && BackoffFactor < 1 &&
+           "ExponentialBackoff: backoff factor should be in [0, 1) interval");
+  }
+
+  void increment() { Count = std::min(Count + 1, MaxCount); }
+
+  void decrement() { Count *= BackoffFactor; }
+
+  bool isAboveThreshold() const { return Count > CountThreshold; }
+};
+
+} // namespace utils
+
+#endif // OMPTARGET_UTILS_EXPONENTIAL_BACKOFF_H
diff --git a/openmp/libomptarget/src/interface.cpp b/openmp/libomptarget/src/interface.cpp
index 73b873870eb689a..3dda2e28e7cb714 100644
--- a/openmp/libomptarget/src/interface.cpp
+++ b/openmp/libomptarget/src/interface.cpp
@@ -21,6 +21,8 @@
 #include "Shared/Profile.h"
 #include "Shared/Utils.h"
 
+#include "Utils/ExponentialBackoff.h"
+
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
@@ -452,7 +454,7 @@ EXTERN void __tgt_target_nowait_query(void **AsyncHandle) {
   // completed (use device side blocking mechanism). This allows the runtime to
   // adapt itself when there are a lot of long-running target regions in-flight.
   using namespace llvm::omp::target;
-  static thread_local ExponentialBackoff QueryCounter(
+  static thread_local utils::ExponentialBackoff QueryCounter(
       Int64Envar("OMPTARGET_QUERY_COUNT_MAX", 10),
       Int64Envar("OMPTARGET_QUERY_COUNT_THRESHOLD", 5),
       Envar<float>("OMPTARGET_QUERY_COUNT_BACKOFF_FACTOR", 0.5f));
diff --git a/openmp/libomptarget/src/private.h b/openmp/libomptarget/src/private.h
index 0730a1ea0fd4b44..339a7da41ab822a 100644
--- a/openmp/libomptarget/src/private.h
+++ b/openmp/libomptarget/src/private.h
@@ -385,33 +385,4 @@ class TaskAsyncInfoWrapperTy {
   operator AsyncInfoTy &() { return *AsyncInfo; }
 };
 
-// Implement exponential backoff counting.
-// Linearly increments until given maximum, exponentially decrements based on
-// given backoff factor.
-class ExponentialBackoff {
-  int64_t Count = 0;
-  const int64_t MaxCount = 0;
-  const int64_t CountThreshold = 0;
-  const float BackoffFactor = 0.0f;
-
-public:
-  ExponentialBackoff(int64_t MaxCount, int64_t CountThreshold,
-                     float BackoffFactor)
-      : MaxCount(MaxCount), CountThreshold(CountThreshold),
-        BackoffFactor(BackoffFactor) {
-    assert(MaxCount >= 0 &&
-           "ExponentialBackoff: maximum count value should be non-negative");
-    assert(CountThreshold >= 0 &&
-           "ExponentialBackoff: count threshold value should be non-negative");
-    assert(BackoffFactor >= 0 && BackoffFactor < 1 &&
-           "ExponentialBackoff: backoff factor should be in [0, 1) interval");
-  }
-
-  void increment() { Count = std::min(Count + 1, MaxCount); }
-
-  void decrement() { Count *= BackoffFactor; }
-
-  bool isAboveThreshold() const { return Count > CountThreshold; }
-};
-
 #endif

``````````

</details>


https://github.com/llvm/llvm-project/pull/73816