Refactor MemoryUtils

arcane/src/arcane/accelerator/core/ReduceMemoryImpl.cc

@@ -15,7 +15,7 @@
 
 #include "arcane/utils/CheckedConvert.h"
 #include "arcane/utils/PlatformUtils.h"
-#include "arcane/utils/IMemoryRessourceMng.h"
+#include "arcane/utils/MemoryUtils.h"
 
 #include "arcane/accelerator/core/Runner.h"
 #include "arcane/accelerator/core/Memory.h"
@@ -32,7 +32,7 @@
 {
   IMemoryAllocator* _getAllocator(eMemoryRessource r)
   {
-    return platform::getDataMemoryRessourceMng()->getAllocator(r);
+    return MemoryUtils::getAllocator(r);
   }
 } // namespace
 

arcane/src/arcane/impl/VariableSynchronizer.cc

@@ -1,6 +1,6 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
@@ -17,8 +17,8 @@
 #include "arcane/utils/NotSupportedException.h"
 #include "arcane/utils/FatalErrorException.h"
 #include "arcane/utils/ITraceMng.h"
-#include "arcane/utils/IMemoryRessourceMng.h"
 #include "arcane/utils/ValueConvert.h"
+#include "arcane/utils/MemoryUtils.h"
 #include "arcane/utils/internal/MemoryBuffer.h"
 
 #include "arcane/core/VariableSynchronizerEventArgs.h"
@@ -282,7 +282,7 @@
   // implémentations MPI (i.e: BXI) ne le supportent pas.
   if (m_runner) {
     buffer_copier->setRunQueue(internal_pm->defaultQueue());
-    allocator = platform::getDataMemoryRessourceMng()->getAllocator(eMemoryRessource::Device);
+    allocator = MemoryUtils::getAllocator(eMemoryRessource::Device);
   }
 
   // Créé une instance de l'implémentation

arcane/src/arcane/materials/MeshMaterialSynchronizeBuffer.cc

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* MeshMaterialSynchronizeBuffer.cc                            (C) 2000-2023 */
+/* MeshMaterialSynchronizeBuffer.cc                            (C) 2000-2024 */
 /*                                                                           */
 /* Gestion des buffers pour la synchronisation de variables matériaux.       */
 /*---------------------------------------------------------------------------*/
@@ -15,7 +15,7 @@
 
 #include "arcane/utils/UniqueArray.h"
 #include "arcane/utils/PlatformUtils.h"
-#include "arcane/utils/IMemoryRessourceMng.h"
+#include "arcane/utils/MemoryUtils.h"
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
@@ -200,7 +200,7 @@ namespace impl
 extern "C++" ARCANE_MATERIALS_EXPORT Ref<IMeshMaterialSynchronizeBuffer>
 makeMultiBufferMeshMaterialSynchronizeBufferRef(eMemoryRessource memory_ressource)
 {
-  auto* a = platform::getDataMemoryRessourceMng()->getAllocator(memory_ressource);
+  auto* a = MemoryUtils::getAllocator(memory_ressource);
   auto* v = new MultiBufferMeshMaterialSynchronizeBuffer(a);
   return makeRef<IMeshMaterialSynchronizeBuffer>(v);
 }
@@ -214,7 +214,7 @@ makeMultiBufferMeshMaterialSynchronizeBufferRef()
 extern "C++" ARCANE_MATERIALS_EXPORT Ref<IMeshMaterialSynchronizeBuffer>
 makeOneBufferMeshMaterialSynchronizeBufferRef(eMemoryRessource memory_ressource)
 {
-  auto* a = platform::getDataMemoryRessourceMng()->getAllocator(memory_ressource);
+  auto* a = MemoryUtils::getAllocator(memory_ressource);
   auto* v = new OneBufferMeshMaterialSynchronizeBuffer(a);
   return makeRef<IMeshMaterialSynchronizeBuffer>(v);
 }

arcane/src/arcane/materials/internal/IndexSelecter.h

@@ -5,17 +5,19 @@
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* IndexSelecter.h                                              (C) 2000-2024 */
+/* IndexSelecter.h                                             (C) 2000-2024 */
 /*                                                                           */
 /* Selection d'index avec API accélérateur                                   */
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
 
-#include "arcane/accelerator/Filter.h"
-#include "arcane/utils/IMemoryRessourceMng.h"
+#include "arcane/utils/MemoryUtils.h"
+
 #include "arcane/accelerator/core/Memory.h"
+#include "arcane/accelerator/GenericFilterer.h"
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
 
 namespace Arcane::Accelerator
 {
@@ -38,8 +40,8 @@ class IndexSelecter
     m_is_accelerator_policy = isAcceleratorPolicy(runqueue->executionPolicy());
     m_memory_host = eMemoryRessource(m_is_accelerator_policy ? eMemoryRessource::HostPinned : eMemoryRessource::Host);
     m_memory_device = eMemoryRessource(m_is_accelerator_policy ? eMemoryRessource::Device : eMemoryRessource::Host);
-    m_localid_select_device = UniqueArray<Int32>(platform::getDataMemoryRessourceMng()->getAllocator(m_memory_device));
-    m_localid_select_host = UniqueArray<Int32>(platform::getDataMemoryRessourceMng()->getAllocator(m_memory_host));
+    m_localid_select_device = UniqueArray<Int32>(MemoryUtils::getAllocator(m_memory_device));
+    m_localid_select_host = UniqueArray<Int32>(MemoryUtils::getAllocator(m_memory_host));
   }
 
   ~IndexSelecter()

arcane/src/arcane/parallel/thread/SharedMemoryMessageQueue.cc

@@ -18,7 +18,7 @@
 #include "arcane/utils/ITraceMng.h"
 #include "arcane/utils/ValueConvert.h"
 
-#include "arcane/utils/internal/MemoryRessourceMng.h"
+#include "arcane/utils/internal/MemoryResourceMng.h"
 
 #include "arcane/parallel/thread/SharedMemoryMessageQueue.h"
 #include "arcane/parallel/thread/IAsyncQueue.h"
@@ -73,7 +73,7 @@ copyFromSender(SharedMemoryMessageRequest* sender)
     ARCANE_FATAL("Not enough memory for receiving message receive={0} send={1}",
                  receive_size,send_size);
 
-  MemoryRessourceMng::genericCopy(ConstMemoryView(send_span), MutableMemoryView(receive_span));
+  MemoryResourceMng::genericCopy(ConstMemoryView(send_span), MutableMemoryView(receive_span));
 }
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/tests/accelerator/NumArrayUnitTest.cc

@@ -15,6 +15,7 @@
 #include "arcane/utils/PlatformUtils.h"
 #include "arcane/utils/ValueChecker.h"
 #include "arcane/utils/IMemoryRessourceMng.h"
+#include "arcane/utils/MemoryUtils.h"
 
 #include "arcane/core/BasicUnitTest.h"
 #include "arcane/core/ServiceFactory.h"
@@ -608,7 +609,7 @@ _executeTest4(eMemoryRessource mem_kind)
   constexpr int n1 = 1000;
 
   constexpr double expected_sum1 = 999000.0;
-  IMemoryAllocator* allocator = platform::getDataMemoryRessourceMng()->getAllocator(mem_kind);
+  IMemoryAllocator* allocator = MemoryUtils::getAllocator(mem_kind);
 
   {
     SharedArray<double> t1;

arcane/src/arcane/utils/IMemoryRessourceMng.h

@@ -5,16 +5,15 @@
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* IMemoryRessourceMng.h                                       (C) 2000-2024 */
+/* IMemoryResourceMng.h                                        (C) 2000-2024 */
 /*                                                                           */
 /* Gestion des ressources mémoire pour les CPU et accélérateurs.             */
 /*---------------------------------------------------------------------------*/
-#ifndef ARCANE_UTILS_IMEMORYRESSOURCEMNG_H
-#define ARCANE_UTILS_IMEMORYRESSOURCEMNG_H
+#ifndef ARCANE_UTILS_IMEMORYRESOURCEMNG_H
+#define ARCANE_UTILS_IMEMORYRESOURCEMNG_H
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-#include "arcane/utils/MemoryRessource.h"
 #include "arcane/utils/UtilsTypes.h"
 
 /*---------------------------------------------------------------------------*/
@@ -27,13 +26,14 @@ class IMemoryRessourceMngInternal;
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 /*!
+ * \internal
  * \brief Gestion des ressources mémoire pour les CPU et accélérateurs.
  */
-class ARCANE_UTILS_EXPORT IMemoryRessourceMng
+class ARCANE_UTILS_EXPORT IMemoryResourceMng
 {
  public:
 
-  virtual ~IMemoryRessourceMng() = default;
+  virtual ~IMemoryResourceMng() = default;
 
  public:
 
@@ -42,7 +42,7 @@ class ARCANE_UTILS_EXPORT IMemoryRessourceMng
    *
    * Lève une exception si aucun allocateur pour la ressource \a v existe.
    */
-  virtual IMemoryAllocator* getAllocator(eMemoryRessource r) = 0;
+  virtual IMemoryAllocator* getAllocator(eMemoryResource r) = 0;
 
   /*!
    * \brief Allocateur mémoire pour la ressource \a r.
@@ -51,7 +51,7 @@ class ARCANE_UTILS_EXPORT IMemoryRessourceMng
    * exception si \a throw_if_not_found est vrai ou retourne \a nullptr
    * si \a throw_if_not_found est faux.
    */
-  virtual IMemoryAllocator* getAllocator(eMemoryRessource r, bool throw_if_not_found) = 0;
+  virtual IMemoryAllocator* getAllocator(eMemoryResource r, bool throw_if_not_found) = 0;
 
  public:
 

arcane/src/arcane/utils/MemoryRessourceMng.cc → arcane/src/arcane/utils/MemoryResourceMng.cc

@@ -5,19 +5,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* MemoryRessourceMng.cc                                       (C) 2000-2024 */
+/* MemoryResourceMng.cc                                       (C) 2000-2024 */
 /*                                                                           */
 /* Gestion des ressources mémoire pour les CPU et accélérateurs.             */
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-#include "arcane/utils/internal/MemoryRessourceMng.h"
+#include "arcane/utils/internal/MemoryResourceMng.h"
 
 #include "arcane/utils/FatalErrorException.h"
 #include "arcane/utils/PlatformUtils.h"
 #include "arcane/utils/Array.h"
 #include "arcane/utils/MemoryView.h"
 #include "arcane/utils/MemoryAllocator.h"
+#include "arcane/utils/internal/MemoryUtilsInternal.h"
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
@@ -30,42 +31,18 @@
 
 namespace
 {
-  const char* _toName(eMemoryRessource r)
-  {
-    switch (r) {
-    case eMemoryRessource::Unknown:
-      return "Unknown";
-    case eMemoryRessource::Host:
-      return "Host";
-    case eMemoryRessource::HostPinned:
-      return "HostPinned";
-    case eMemoryRessource::Device:
-      return "Device";
-    case eMemoryRessource::UnifiedMemory:
-      return "UnifiedMemory";
-    }
-    return "Invalid";
-  }
-
   inline bool _isHost(eMemoryRessource r)
   {
     // Si on sait pas, considère qu'on est accessible de puis l'hôte.
-    if (r == eMemoryRessource::Unknown)
+    if (r == eMemoryResource::Unknown)
       return true;
-    if (r == eMemoryRessource::Host || r == eMemoryRessource::UnifiedMemory || r == eMemoryRessource::HostPinned)
+    if (r == eMemoryResource::Host || r == eMemoryResource::UnifiedMemory || r == eMemoryResource::HostPinned)
       return true;
     return false;
   }
 
 } // namespace
 
-extern "C++" ARCANE_UTILS_EXPORT std::ostream&
-operator<<(std::ostream& o, eMemoryRessource r)
-{
-  o << _toName(r);
-  return o;
-}
-
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
@@ -74,8 +51,8 @@
 {
  public:
 
-  void copy(ConstMemoryView from, eMemoryRessource from_mem,
-            MutableMemoryView to, eMemoryRessource to_mem,
+  void copy(ConstMemoryView from, eMemoryResource from_mem,
+            MutableMemoryView to, eMemoryResource to_mem,
             [[maybe_unused]] const RunQueue* queue) override
   {
     // Sans support accélérateur, on peut juste faire un 'memcpy' si la mémoire
@@ -96,8 +73,8 @@
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-MemoryRessourceMng::
-MemoryRessourceMng()
+MemoryResourceMng::
+MemoryResourceMng()
 : m_default_memory_copier(new DefaultHostMemoryCopier())
 , m_copier(m_default_memory_copier.get())
 {
@@ -111,22 +88,22 @@
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-int MemoryRessourceMng::
-_checkValidRessource(eMemoryRessource r)
+int MemoryResourceMng::
+_checkValidResource(eMemoryResource r)
 {
   int x = (int)r;
-  if (x <= 0 || x >= NB_MEMORY_RESSOURCE)
-    ARCANE_FATAL("Invalid value '{0}'. Valid range is '1' to '{1}'", x, NB_MEMORY_RESSOURCE - 1);
+  if (x <= 0 || x >= Arccore::ARCCORE_NB_MEMORY_RESOURCE)
+    ARCANE_FATAL("Invalid value '{0}'. Valid range is '1' to '{1}'", x, Arccore::ARCCORE_NB_MEMORY_RESOURCE - 1);
   return x;
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-IMemoryAllocator* MemoryRessourceMng::
-getAllocator(eMemoryRessource r, bool throw_if_not_found)
+IMemoryAllocator* MemoryResourceMng::
+getAllocator(eMemoryResource r, bool throw_if_not_found)
 {
-  int x = _checkValidRessource(r);
+  int x = _checkValidResource(r);
   IMemoryAllocator* a = m_allocators[x];
 
   // Si pas d'allocateur spécifique et qu'on n'est pas sur accélérateur,
@@ -148,28 +125,28 @@
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-IMemoryAllocator* MemoryRessourceMng::
-getAllocator(eMemoryRessource r)
+IMemoryAllocator* MemoryResourceMng::
+getAllocator(eMemoryResource r)
 {
   return getAllocator(r, true);
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-void MemoryRessourceMng::
-setAllocator(eMemoryRessource r, IMemoryAllocator* allocator)
+void MemoryResourceMng::
+setAllocator(eMemoryResource r, IMemoryAllocator* allocator)
 {
-  int x = _checkValidRessource(r);
+  int x = _checkValidResource(r);
   m_allocators[x] = allocator;
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-void MemoryRessourceMng::
-copy(ConstMemoryView from, eMemoryRessource from_mem,
-     MutableMemoryView to, eMemoryRessource to_mem, const RunQueue* queue)
+void MemoryResourceMng::
+copy(ConstMemoryView from, eMemoryResource from_mem,
+     MutableMemoryView to, eMemoryResource to_mem, const RunQueue* queue)
 {
   Int64 from_size = from.bytes().size();
   Int64 to_size = to.bytes().size();
@@ -182,11 +159,11 @@
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-void MemoryRessourceMng::
+void MemoryResourceMng::
 genericCopy(ConstMemoryView from, MutableMemoryView to)
 {
-  IMemoryRessourceMng* mrm = platform::getDataMemoryRessourceMng();
-  eMemoryRessource mem_type = eMemoryRessource::Unknown;
+  IMemoryResourceMng* mrm = MemoryUtils::getDataMemoryResourceMng();
+  eMemoryResource mem_type = eMemoryResource::Unknown;
   mrm->_internal()->copy(from, mem_type, to, mem_type, nullptr);
 }