env.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// Created by Eduard Valeyev on 5/20/25.
//
 
#ifndef TTG_ENV_H
#define TTG_ENV_H
 
#include <umpire_cxx_allocator.hpp>
 
#include <umpire/strategy/QuickPool.hpp>
#include <umpire/strategy/SizeLimiter.hpp>
 
#include <cassert>
#include <memory>
#include <mutex>
 
namespace ttg {
 
  class Env {
   public:
    ~Env() {
    }
 
    Env(const Env&) = delete;
    Env(Env&&) = delete;
    Env& operator=(const Env&) = delete;
    Env& operator=(Env&&) = delete;
 
    static std::unique_ptr<Env>& instance() {
      if (!instance_accessor()) {
        initialize();
      }
      return instance_accessor();
    }
 
    // clang-format off
    // clang-format on
    static void initialize(const std::uint64_t page_size = (1ul << 25),
                           const std::uint64_t pinned_alloc_limit = (1ul << 40)) {
      static std::mutex mtx;  // to make initialize() reentrant
      std::scoped_lock lock{mtx};
      // only the winner of the lock race gets to initialize
      if (instance_accessor() == nullptr) {
 
        // uncomment to debug umpire ops
        //
        //      umpire::util::Logger::getActiveLogger()->setLoggingMsgLevel(
        //          umpire::util::message::Debug);
 
        auto& rm = umpire::ResourceManager::getInstance();
 
        // turn off Umpire introspection for non-Debug builds
#ifndef NDEBUG
        constexpr auto introspect = true;
#else
        constexpr auto introspect = false;
#endif
 
        // allocate pinned_alloc_limit in pinned memory
        auto pinned_size_limited_alloc =
            rm.makeAllocator<umpire::strategy::SizeLimiter, introspect>(
                "SizeLimited_PINNED", rm.getAllocator("PINNED"),
                pinned_alloc_limit);
        auto pinned_dynamic_pool =
            rm.makeAllocator<umpire::strategy::QuickPool, introspect>(
                "QuickPool_SizeLimited_PINNED", pinned_size_limited_alloc,
                /* first_minimum_pool_allocation_size = */ 0,
                /* next_minimum_pool_allocation_size = */ page_size,
                /* alignment */ 16);
 
        auto env = std::unique_ptr<Env>(new Env(pinned_dynamic_pool));
        instance_accessor() = std::move(env);
      }
    }
 
    auto& pinned_allocator() { return pinned_allocator_; }
 
    // clang-format off
    // clang-format on
    std::size_t pinned_allocator_getActualHighWatermark() {
      assert(dynamic_cast<::umpire::strategy::QuickPool*>(
                    pinned_allocator_.getAllocationStrategy()) != nullptr);
      return dynamic_cast<::umpire::strategy::QuickPool*>(
                 pinned_allocator_.getAllocationStrategy())
          ->getActualHighwaterMark();
    }
 
   protected:
    Env(::umpire::Allocator pinned_alloc)
        : pinned_allocator_(pinned_alloc) {}
 
   private:
    // allocates from a dynamic, size-limited pinned memory pool
    // N.B. not thread safe, so must be wrapped into umpire_based_allocator_impl
    ::umpire::Allocator pinned_allocator_;
 
    inline static std::unique_ptr<Env>& instance_accessor() {
      static std::unique_ptr<Env> instance_{nullptr};
      return instance_;
    }
  };  // class Env
 
  namespace umpire {
 
    struct pinned_allocator_getter {
      inline ::umpire::Allocator& operator()() { return Env::instance()->pinned_allocator(); }
    };
 
  }
 
  template <typename T>
  using pinned_allocator_t = ::umpire::default_init_allocator<
      T, ::umpire::allocator<T, ::umpire::detail::MutexLock<::ttg::Env>,
                             umpire::pinned_allocator_getter>>;
 
}  // namespace ttg
 
#endif  // TTG_ENV_H