MemoryAllocator.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MemoryAllocator.cc                                          (C) 2000-2025 */
/*                                                                           */
/* Memory allocators.                                                        */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/base/ArgumentException.h"
#include "arccore/base/NotSupportedException.h"
#include "arccore/base/NotImplementedException.h"
#include "arccore/base/TraceInfo.h"
 
#include "arccore/common/DefaultMemoryAllocator.h"
#include "arccore/common/AlignedMemoryAllocator.h"
#include "arccore/common/AllocatedMemoryInfo.h"
 
#include <cstdlib>
#include <cstring>
#include <errno.h>
 
#if defined(ARCCORE_OS_WIN32)
#include <malloc.h>
#endif
 
#include <iostream>
 
#if defined(ARCCORE_OS_LINUX) || defined(ARCCORE_OS_MACOS)
#define ARCCORE_USE_POSIX_MEMALIGN
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
DefaultMemoryAllocator DefaultMemoryAllocator::shared_null_instance;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
size_t IMemoryAllocator::
guarantedAlignment(MemoryAllocationArgs args) const
{
  return this->guaranteedAlignment(args);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void IMemoryAllocator::
notifyMemoryArgsChanged(MemoryAllocationArgs, MemoryAllocationArgs, AllocatedMemoryInfo)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void IMemoryAllocator::
copyMemory([[maybe_unused]] MemoryAllocationArgs args, AllocatedMemoryInfo destination,
           AllocatedMemoryInfo source)
{
  std::memcpy(destination.baseAddress(), source.baseAddress(), source.size());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool DefaultMemoryAllocator::
hasRealloc(MemoryAllocationArgs) const
{
  return true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AllocatedMemoryInfo DefaultMemoryAllocator::
allocate(MemoryAllocationArgs, Int64 new_size)
{
  return { ::malloc(new_size), new_size };
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AllocatedMemoryInfo DefaultMemoryAllocator::
reallocate(MemoryAllocationArgs, AllocatedMemoryInfo current_ptr, Int64 new_size)
{
  return { ::realloc(current_ptr.baseAddress(), new_size), new_size };
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void DefaultMemoryAllocator::
deallocate(MemoryAllocationArgs, AllocatedMemoryInfo ptr)
{
  ::free(ptr.baseAddress());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Int64 DefaultMemoryAllocator::
adjustedCapacity(MemoryAllocationArgs, Int64 wanted_capacity, Int64) const
{
  return wanted_capacity;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AlignedMemoryAllocator AlignedMemoryAllocator::
SimdAllocator(AlignedMemoryAllocator::simdAlignment());
 
AlignedMemoryAllocator AlignedMemoryAllocator::
CacheLineAllocator(AlignedMemoryAllocator::cacheLineAlignment());
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*!
 * NOTE: Normally the _mm_alloc() and _mm_free() functions allow
 * allocating aligned memory. It should be checked if they are
 * available everywhere.
 */
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AllocatedMemoryInfo AlignedMemoryAllocator::
allocate([[maybe_unused]] MemoryAllocationArgs args, Int64 new_size)
{
#if defined(ARCCORE_USE_POSIX_MEMALIGN)
  void* ptr = nullptr;
  int e = ::posix_memalign(&ptr, m_alignment, new_size);
  if (e == EINVAL)
    throw ArgumentException(A_FUNCINFO, "Invalid argument to posix_memalign");
  if (e == ENOMEM)
    return AllocatedMemoryInfo(nullptr);
  return AllocatedMemoryInfo(ptr, new_size);
#elif defined(ARCCORE_OS_WIN32)
  return AllocatedMemoryInfo(_aligned_malloc(new_size, m_alignment), new_size);
#else
  throw NotImplementedException(A_FUNCINFO);
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AllocatedMemoryInfo AlignedMemoryAllocator::
reallocate([[maybe_unused]] MemoryAllocationArgs args, AllocatedMemoryInfo current_ptr, Int64 new_size)
{
#if defined(ARCCORE_USE_POSIX_MEMALIGN)
  ARCCORE_UNUSED(current_ptr);
  ARCCORE_UNUSED(new_size);
  throw NotSupportedException(A_FUNCINFO);
#elif defined(ARCCORE_OS_WIN32)
  return AllocatedMemoryInfo(_aligned_realloc(current_ptr.baseAddress(), new_size, m_alignment), new_size);
#else
  throw NotImplementedException(A_FUNCINFO);
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void AlignedMemoryAllocator::
deallocate([[maybe_unused]] MemoryAllocationArgs args, AllocatedMemoryInfo ptr)
{
#if defined(ARCCORE_USE_POSIX_MEMALIGN)
  ::free(ptr.baseAddress());
#elif defined(ARCCORE_OS_WIN32)
  return _aligned_free(ptr.baseAddress());
#else
  throw NotImplementedException(A_FUNCINFO);
#endif
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
  bool is_verbose = false;
}
 
size_t
adjustMemoryCapacity(size_t wanted_capacity, size_t element_size, size_t alignment)
{
  if (element_size == 0)
    return wanted_capacity;
  // If \a element_size is smaller than \a m_alignment, consider that
  // the allocated memory must be a multiple of the alignment.
  // (We could be more restrictive depending on the types but it is not in
  // general useful).
  size_t block_size = alignment / element_size;
  if (block_size <= 1)
    return wanted_capacity;
 
  // If the alignment is not a multiple of the element size,
  // it means that the element will not be used for vectorization.
  // Therefore, it is not necessary in this case to modify the capacity.
  size_t nb_element = alignment % element_size;
  if (nb_element != 0)
    return wanted_capacity;
 
  if (is_verbose)
    std::cout << " wanted_capacity=" << wanted_capacity
              << " element_size=" << element_size
              << " block_size=" << block_size << '\n';
 
  // Adds to the capacity what is needed for the modulo to be 0.
  size_t modulo = wanted_capacity % block_size;
  if (modulo != 0)
    wanted_capacity += (block_size - modulo);
  if (is_verbose)
    std::cout << " final_wanted_capacity=" << wanted_capacity
              << " modulo=" << modulo << '\n';
  ARCCORE_ASSERT(((wanted_capacity % block_size) == 0), ("Bad capacity"));
  return wanted_capacity;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Int64 AlignedMemoryAllocator::
adjustedCapacity([[maybe_unused]] MemoryAllocationArgs args, Int64 wanted_capacity, Int64 element_size) const
{
  return adjustMemoryCapacity(wanted_capacity, element_size, m_alignment);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AllocatedMemoryInfo PrintableMemoryAllocator::
allocate(MemoryAllocationArgs args, Int64 new_size)
{
  AllocatedMemoryInfo mem_info = Base::allocate(args, new_size);
  std::cout << "DEF_ARRAY_ALLOCATE new_size=" << new_size << " ptr=" << mem_info.baseAddress() << '\n';
  return mem_info;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
AllocatedMemoryInfo PrintableMemoryAllocator::
reallocate(MemoryAllocationArgs args, AllocatedMemoryInfo current_ptr, Int64 new_size)
{
  AllocatedMemoryInfo mem_info = Base::reallocate(args, current_ptr, new_size);
  std::cout << "DEF_ARRAY_REALLOCATE new_size=" << new_size
            << " current_ptr=" << current_ptr.baseAddress()
            << " new_ptr=" << mem_info.baseAddress() << '\n';
  return mem_info;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void PrintableMemoryAllocator::
deallocate(MemoryAllocationArgs args, AllocatedMemoryInfo ptr)
{
  std::cout << "DEF_ARRAY_DEALLOCATE ptr=" << ptr.baseAddress() << '\n';
  Base::deallocate(args, ptr);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/