memoryManager.hpp

Go to the documentation of this file.

/*
 *   Copyright 2025 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstring>
#include <lpf/collectives.h>
#include <lpf/core.h>
#include <hicr/core/memoryManager.hpp>
#include <hicr/backends/hwloc/memorySpace.hpp>
#include "localMemorySlot.hpp"
 
namespace HiCR::backend::lpf
{
 
class MemoryManager final : public HiCR::MemoryManager
{
  private:
 
  const lpf_t _lpf;
 
  public:
 
  MemoryManager(lpf_t lpf)
    : HiCR::MemoryManager(),
      _lpf(lpf)
  {}
 
  __INLINE__ std::shared_ptr<HiCR::LocalMemorySlot> registerLocalMemorySlotImpl(std::shared_ptr<HiCR::MemorySpace> memorySpace, void *const ptr, const size_t size) override
  {
    // Getting up-casted pointer for the MPI instance
    auto m = dynamic_pointer_cast<hwloc::MemorySpace>(memorySpace);
 
    // Checking whether the execution unit passed is compatible with this backend
    if (m == nullptr) HICR_THROW_LOGIC("The passed memory space is not supported by this memory manager\n");
 
    lpf_memslot_t lpfSlot = LPF_INVALID_MEMSLOT;
    auto          rc      = lpf_register_local(_lpf, ptr, size, &lpfSlot);
    if (rc != LPF_SUCCESS) HICR_THROW_RUNTIME("LPF Memory Manager: lpf_register_local failed");
 
    // Creating new memory slot object
    auto memorySlot = std::make_shared<lpf::LocalMemorySlot>(lpfSlot, ptr, size, memorySpace);
 
    return memorySlot;
  }
 
  __INLINE__ void deregisterLocalMemorySlotImpl(std::shared_ptr<HiCR::LocalMemorySlot> memorySlot) override
  {
    // Getting up-casted pointer for the memory slot
    auto slot = dynamic_pointer_cast<lpf::LocalMemorySlot>(memorySlot);
 
    // Checking whether the memory slot is compatible with this backend
    if (slot == nullptr) HICR_THROW_LOGIC("The passed memory slot is not supported by this backend\n");
 
    // Deregistering memory slot from the LPF backend
    lpf_deregister(_lpf, slot->getLPFSlot());
  }
 
  __INLINE__ std::shared_ptr<HiCR::LocalMemorySlot> allocateLocalMemorySlotImpl(std::shared_ptr<HiCR::MemorySpace> memorySpace, const size_t size) override
  {
    // Getting up-casted pointer for the LPF instance
    auto m = dynamic_pointer_cast<hwloc::MemorySpace>(memorySpace);
 
    // Checking whether the execution unit passed is compatible with this backend
    if (m == nullptr) HICR_THROW_LOGIC("The passed memory space is not supported by this memory manager\n");
 
    // Storage for the new pointer
    const size_t MIN_BYTES = 32;
    const auto   newSize   = std::max(size, MIN_BYTES);
    void        *ptr       = malloc(newSize);
    if (ptr == nullptr) HICR_THROW_RUNTIME("Could not allocate memory of size %lu", newSize);
 
    // Update the memory usage for the memory space
    memorySpace->increaseUsage(newSize - size);
    // Creating and returning new memory slot
    return registerLocalMemorySlotImpl(memorySpace, ptr, newSize);
  }
 
  __INLINE__ void freeLocalMemorySlotImpl(std::shared_ptr<HiCR::LocalMemorySlot> memorySlot) override
  {
    // Getting up-casted pointer for the memory slot
    auto slot = dynamic_pointer_cast<lpf::LocalMemorySlot>(memorySlot);
 
    // Checking whether the memory slot is compatible with this backend
    if (slot == nullptr) HICR_THROW_LOGIC("The passed memory slot is not supported by this backend\n");
 
    // Getting memory slot pointer
    const auto pointer = slot->getPointer();
 
    // Checking whether the pointer is valid
    if (slot == nullptr) HICR_THROW_RUNTIME("Invalid memory slot(s) provided. It either does not exist or represents a NULL pointer.");
 
    // First, deregistering LPF memory slot
    deregisterLocalMemorySlotImpl(memorySlot);
 
    // Deallocating memory
    free(pointer);
  }
};
 
} // namespace HiCR::backend::lpf