SmallArray.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* SmallArray.h                                                (C) 2000-2025 */
/*                                                                           */
/* Tableau 1D de données avec buffer pré-alloué.                             */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_STACKARRAY_H
#define ARCANE_UTILS_STACKARRAY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Array.h"
#include "arcane/utils/MemoryAllocator.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::impl
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_UTILS_EXPORT StackMemoryAllocator final
: public IMemoryAllocator3
{
 public:
 
  StackMemoryAllocator(void* buf, size_t size)
  : m_preallocated_buffer(buf)
  , m_preallocated_size(size)
  {}
 
 public:
 
  bool hasRealloc(MemoryAllocationArgs) const final { return true; }
  AllocatedMemoryInfo allocate(MemoryAllocationArgs args, Int64 new_size) final;
  AllocatedMemoryInfo reallocate(MemoryAllocationArgs args, AllocatedMemoryInfo current_ptr, Int64 new_size) final;
  void deallocate(MemoryAllocationArgs args, AllocatedMemoryInfo ptr) final;
  Int64 adjustedCapacity(MemoryAllocationArgs, Int64 wanted_capacity, Int64) const final { return wanted_capacity; }
  size_t guaranteedAlignment(MemoryAllocationArgs) const final { return 0; }
 
 private:
 
  void* m_preallocated_buffer = nullptr;
  Int64 m_preallocated_size = 0;
};
 
} // namespace Arcane::impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename T, Int32 NbElement = 32>
class SmallArray final
: public Array<T>
{
  using BaseClassType = AbstractArray<T>;
  static constexpr Int32 SizeOfType = static_cast<Int32>(sizeof(T));
  static constexpr Int32 nb_element_in_buf = NbElement;
 
 public:
 
  using typename BaseClassType::ConstReferenceType;
  static constexpr Int32 MemorySize = NbElement * SizeOfType;
 
 public:

  SmallArray()
  : m_stack_allocator(m_stack_buffer, MemorySize)
  {
    this->_initFromAllocator(&m_stack_allocator, nb_element_in_buf);
  }

  SmallArray(Int64 req_size, ConstReferenceType value)
  : SmallArray()
  {
    this->_resize(req_size, value);
  }

  explicit SmallArray(Int64 asize)
  : SmallArray()
  {
    this->_resize(asize);
  }

  explicit SmallArray(Int32 asize)
  : SmallArray((Int64)asize)
  {
  }

  explicit SmallArray(size_t asize)
  : SmallArray((Int64)asize)
  {
  }

  SmallArray(const ConstArrayView<T>& aview)
  : SmallArray(Span<const T>(aview))
  {
  }

  SmallArray(const Span<const T>& aview)
  : SmallArray()
  {
    this->_initFromSpan(aview);
  }

  SmallArray(const ArrayView<T>& aview)
  : SmallArray(Span<const T>(aview))
  {
  }

  SmallArray(const Span<T>& aview)
  : SmallArray(Span<const T>(aview))
  {
  }
 
  SmallArray(std::initializer_list<T> alist)
  : SmallArray()
  {
    this->_initFromInitializerList(alist);
  }

  SmallArray(const Array<T>& rhs)
  : SmallArray(rhs.constSpan())
  {
  }

  void operator=(const Array<T>& rhs)
  {
    this->copy(rhs.constSpan());
  }

  void operator=(const ArrayView<T>& rhs)
  {
    this->copy(rhs);
  }

  void operator=(const Span<T>& rhs)
  {
    this->copy(rhs);
  }

  void operator=(const ConstArrayView<T>& rhs)
  {
    this->copy(rhs);
  }

  void operator=(const Span<const T>& rhs)
  {
    this->copy(rhs);
  }

  ~SmallArray() override
  {
    // Il faut détruire explicitement car notre allocateur
    // sera détruit avant la classe de base et ne sera plus valide
    // lors de la désallocation.
    this->_destroy();
    this->_internalDeallocate();
    this->_reset();
  }
 
 public:
 
  template <Int32 N> SmallArray(SmallArray<T, N>&& rhs) = delete;
  template <Int32 N> SmallArray<T, NbElement> operator=(SmallArray<T, N>&& rhs) = delete;
 
 private:
 
  char m_stack_buffer[MemorySize];
  impl::StackMemoryAllocator m_stack_allocator;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif