Program Listing for File wrap_allocator.hpp

↰ Return to documentation for file (umpire/util/wrap_allocator.hpp)

//////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-20, Lawrence Livermore National Security, LLC and Umpire
// project contributors. See the COPYRIGHT file for details.
//
// SPDX-License-Identifier: (MIT)
//////////////////////////////////////////////////////////////////////////////
#ifndef UMPIRE_wrap_allocator_HPP
#define UMPIRE_wrap_allocator_HPP

#include "umpire/Allocator.hpp"
#include "umpire/strategy/AllocationStrategy.hpp"
#include "umpire/strategy/AllocationTracker.hpp"
#include "umpire/strategy/ZeroByteHandler.hpp"
#include "umpire/util/make_unique.hpp"

namespace umpire {
namespace util {

template <typename Base>
std::unique_ptr<Base> do_wrap(std::unique_ptr<Base>&& allocator)
{
  return std::move(allocator);
}

template <typename Base, typename Strategy, typename... Strategies>
std::unique_ptr<Base> do_wrap(std::unique_ptr<Base>&& allocator)
{
  return std::unique_ptr<Base>(new Strategy(
      umpire::util::do_wrap<Base, Strategies...>(std::move(allocator))));
}

template <typename... Strategies>
std::unique_ptr<strategy::AllocationStrategy> wrap_allocator(
    std::unique_ptr<strategy::AllocationStrategy>&& allocator)
{
  return umpire::util::do_wrap<umpire::strategy::AllocationStrategy,
                               Strategies...>(std::move(allocator));
}

template <typename Strategy>
Strategy* unwrap_allocation_strategy(
    strategy::AllocationStrategy* base_strategy)
{
  umpire::strategy::ZeroByteHandler* zero{nullptr};
  umpire::strategy::AllocationTracker* tracker{nullptr};
  Strategy* strategy{nullptr};

  tracker = dynamic_cast<umpire::strategy::AllocationTracker*>(base_strategy);

  if (tracker) {
    zero = dynamic_cast<umpire::strategy::ZeroByteHandler*>(
        tracker->getAllocationStrategy());
  } else {
    zero = dynamic_cast<umpire::strategy::ZeroByteHandler*>(base_strategy);
  }

  if (zero) {
    strategy = dynamic_cast<Strategy*>(zero->getAllocationStrategy());
  } else {
    if (tracker) {
      strategy = dynamic_cast<Strategy*>(tracker->getAllocationStrategy());
    } else {
      strategy = dynamic_cast<Strategy*>(base_strategy);
    }
  }

  if (!strategy) {
    UMPIRE_ERROR("Couldn't unwrap " << base_strategy->getName() << " to "
                                    << typeid(Strategy).name());
  }

  return strategy;
}

template <typename Strategy>
Strategy* unwrap_allocator(Allocator allocator)
{
  return unwrap_allocation_strategy<Strategy>(
      allocator.getAllocationStrategy());
}

} // end of namespace util
} // end of namespace umpire

#endif // UMPIRE_wrap_allocator_HPP