[OpenMP][libomptarget] Add utility class for reference counting

[kevinsala]

Summary

The AMDGPU NextGen plugin will use this class for counting the references of some device resources.

[kevinsala]

@jdoerfert @jhuber6 @tianshilei1992 do you think this can be useful for libomptarget at some point? If not, I'll move it to the AMDGPU plugin directly

[tianshilei1992]

openmp/libomptarget/include/Utilities.h

151

Maybe memory order can be a template argument as well?

[jhuber6]

We'll probably need something like this in libomptarget if I ever get around to finishing D131089.

[kevinsala]

openmp/libomptarget/include/Utilities.h

151

Sure. I'll set std::memory_order_relaxed by default.

[kevinsala]

Add memory order as class template parameter.

[tianshilei1992]

LGTM with one nit. Not sure if we need an access function (just read the value).

openmp/libomptarget/include/Utilities.h

145

increase or inc sounds better as it is already the member function of RefCountTy.

150

ditto

[kevinsala]

Adding function to get current refcount value.

[kevinsala]

Renaming function names.

openmp/libomptarget/include/Utilities.h

 #ifndef OPENMP_LIBOMPTARGET_INCLUDE_UTILITIES_H
 #define OPENMP_LIBOMPTARGET_INCLUDE_UTILITIES_H
 
 #include "llvm/ADT/STLFunctionalExtras.h"
 
 #include "Debug.h"
 
 #include <algorithm>
+#include <atomic>
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <functional>
 #include <sstream>
 #include <string>
 
 namespace llvm {

 using IntEnvar = Envar<int>;
 using Int32Envar = Envar<int32_t>;
 using Int64Envar = Envar<int64_t>;
 using UInt32Envar = Envar<uint32_t>;
 using UInt64Envar = Envar<uint64_t>;
 using StringEnvar = Envar<std::string>;
 using BoolEnvar = Envar<bool>;
 
+/// Utility class for thread-safe reference counting. Any class that needs
+/// objects' reference counting can inherit from this entity or have it as a
+/// class data member.
+template <typename Ty = uint32_t,
+          std::memory_order MemoryOrder = std::memory_order_relaxed>
+struct RefCountTy {
+  /// Create a refcount object initialized to zero.
+  RefCountTy() : Refs(0) {}
+
+  ~RefCountTy() { assert(Refs == 0 && "Destroying with non-zero refcount"); }
+
+  /// Increase the reference count atomically.
+  void increase() { Refs.fetch_add(1, MemoryOrder); }
+
+  /// Decrease the reference count and return whether it became zero. Decreasing
+  /// the counter in more units than it was previously increased results in
+  /// undefined behavior.
+  bool decrease() {
+    Ty Prev = Refs.fetch_sub(1, MemoryOrder);
+    assert(Prev > 0 && "Invalid refcount");
+    return (Prev == 1);
+  }
+
+  Ty get() const { return Refs.load(MemoryOrder); }
+
+private:
+  /// The atomic reference counter.
+  std::atomic<Ty> Refs;
+};
+
 template <>
 inline bool StringParser::parse(const char *ValueStr, bool &Result) {
   std::string Value(ValueStr);
 
   // Convert the string to lowercase.
   std::transform(Value.begin(), Value.end(), Value.begin(),
                  [](unsigned char c) { return std::tolower(c); });