[arcane,tests] Ajoute test pour les 'RUNCOMMAND_MAT_ENUMERATE' sur les MatCell.

Author: grospelliergilles

arcane/ceapart/src/arcane/tests/CMakeLists.txt

@@ -8,6 +8,7 @@ if (ARCANE_HAS_ACCELERATOR_API)
     AdiProjectionModule.cc
     CartesianMeshTestUtils.cc
     MeshMaterialSyncUnitTest.cc
+    MaterialHeatTestModule.cc
   )
   arcane_accelerator_add_source_files(${ARCANE_ACCELERATOR_SOURCES})
 endif()

arcane/ceapart/src/arcane/tests/MaterialHeatTestModule.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
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* MaterialHeatTestModule.cc                                   (C) 2000-2023 */
+/* MaterialHeatTestModule.cc                                   (C) 2000-2024 */
 /*                                                                           */
 /* Module de test des matériaux.                                             */
 /*---------------------------------------------------------------------------*/
@@ -29,6 +29,13 @@
 #include "arcane/materials/MeshMaterialModifier.h"
 #include "arcane/materials/ComponentItemVectorView.h"
 
+#include "arcane/accelerator/core/IAcceleratorMng.h"
+#include "arcane/accelerator/core/RunCommand.h"
+#include "arcane/accelerator/core/RunQueue.h"
+#include "arcane/accelerator/VariableViews.h"
+#include "arcane/accelerator/MaterialVariableViews.h"
+#include "arcane/accelerator/RunCommandMaterialEnumerate.h"
+
 #include "arcane/tests/ArcaneTestGlobal.h"
 #include "arcane/tests/MaterialHeatTest_axl.h"
 
@@ -49,7 +56,7 @@ using namespace Arcane::Materials;
 class MaterialHeatTestModule
 : public ArcaneMaterialHeatTestObject
 {
- private:
+ public:
 
   //! Caractéristiques de l'objet qui chauffe (disque ou sphère)
   struct HeatObject
@@ -120,7 +127,9 @@ class MaterialHeatTestModule
   void _computeGlobalTemperature();
   void _computeCellsToAdd(const HeatObject& heat_object, MaterialWorkArray& wa);
   void _computeCellsToRemove(const HeatObject& heat_object, MaterialWorkArray& wa);
+ public:
   void _addHeat(const HeatObject& heat_object);
+ private:
   void _addCold(const HeatObject& heat_object);
   void _initNewCells(const HeatObject& heat_object, MaterialWorkArray& wa);
   void _compute();
@@ -157,9 +166,11 @@ MaterialHeatTestModule::
 void MaterialHeatTestModule::
 buildInit()
 {
+  ProfilingRegistry::setProfilingLevel(2);
+
   // La création des milieux et des matériaux doit se faire dans un point
   // d'entrée de type 'build' pour que la liste des variables créés par les
-  // milieux et les matériaux soit accessible dans le post-traitement.
+  // milieux et les matériaux soit accessibles dans le post-traitement.
   info() << "MaterialHeatTestModule::buildInit()";
 
   Materials::IMeshMaterialMng* mm = IMeshMaterialMng::getReference(defaultMesh());
@@ -378,18 +389,23 @@ _addHeat(const HeatObject& heat_object)
   const Real heat_radius_norm = heat_object.radius * heat_object.radius;
 
   IMeshMaterial* current_mat = heat_object.material;
+  RunQueue* queue = this->acceleratorMng()->defaultQueue();
+  auto command = makeCommand(queue);
+
+  auto in_cell_center = viewIn(command, m_cell_center);
+  auto inout_mat_temperature = viewInOut(command, m_mat_temperature);
 
   //! Chauffe les mailles déjà présentes dans le matériau
-  ENUMERATE_MATCELL (imatcell, current_mat) {
-    MatCell mc = *imatcell;
-    Cell cell = mc.globalCell();
-    Real3 center = m_cell_center[cell];
+  command << RUNCOMMAND_MAT_ENUMERATE(MatAndGlobalCell, iter, current_mat)
+  {
+    auto [matcell, cell] = iter();
+    Real3 center = in_cell_center[cell];
     Real distance2 = (center - heat_center).squareNormL2();
     if (distance2 < heat_radius_norm) {
       Real to_add = heat_value / (1.0 + distance2);
-      m_mat_temperature[mc] += to_add;
+      inout_mat_temperature[matcell] += to_add;
     }
-  }
+  };
 }
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/tests/accelerator/MeshMaterialAcceleratorUnitTest.cc

@@ -113,7 +113,7 @@ class MeshMaterialAcceleratorUnitTest
   UniqueArray<Int32> m_env1_partial_value_index;
   CellGroup m_sub_env_group1;
 
-  void _initializeVariables();
+  void _initializeVariables(ComponentItemVectorView component);
 
  public:
 
@@ -124,7 +124,9 @@ class MeshMaterialAcceleratorUnitTest
   void _executeTest2(Integer nb_z);
   void _executeTest3(Integer nb_z);
   void _executeTest4(Integer nb_z);
-  void _checkValues();
+  void _executeTest5(Integer nb_z,MatCellVectorView mat);
+  void _checkEnvValues1();
+  void _checkMatValues1();
   void _checkEnvironmentValues();
 };
 
@@ -322,7 +324,7 @@ executeTest()
          << " nb_unknown=" << nb_unknown
          << " nb_z=" << nb_z << " nb_z2=" << nb_z2;
 
-  _initializeVariables();
+  _initializeVariables(m_env1->envView());
   EnvCellVector sub_ev1(m_sub_env_group1,m_env1);
   {
     _executeTest1(nb_z,m_env1->envView());
@@ -337,13 +339,18 @@ executeTest()
   {
     _executeTest4(nb_z);
   }
+  {
+    IMeshEnvironment* env2 = m_mm_mng->environments()[1];
+    IMeshMaterial* mat2 = env2->materials()[1];
+    _executeTest5(nb_z,mat2->matView());
+  }
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
 void MeshMaterialAcceleratorUnitTest::
-_initializeVariables()
+_initializeVariables(ComponentItemVectorView component)
 {
   MaterialVariableCellReal& a_ref(m_mat_a_ref);
   MaterialVariableCellReal& b_ref(m_mat_b_ref);
@@ -356,8 +363,9 @@ _initializeVariables()
   MaterialVariableCellReal& c(m_mat_c);
   MaterialVariableCellReal& d(m_mat_d);
   MaterialVariableCellReal& e(m_mat_e);
+  bool is_env = component.component()->isEnvironment();
 
-  ENUMERATE_ENVCELL(i,m_env1){
+  ENUMERATE_COMPONENTCELL(i,component){
     Real z = (Real)i.index();
     b_ref[i] = z*2.3;
     c_ref[i] = z*3.1;
@@ -369,23 +377,25 @@ _initializeVariables()
     c[i] = c_ref[i];
     d[i] = d_ref[i];
     e[i] = e_ref[i];
-    m_env_a[i] = a_ref[i];
-    m_env_b[i] = b_ref[i];
-    m_env_c[i] = c_ref[i];
+    if (is_env){
+      m_env_a[i] = a_ref[i];
+      m_env_b[i] = b_ref[i];
+      m_env_c[i] = c_ref[i];
+    }
   }
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 /*!
- * \brief Test du RUNCOMMAND_ENUMERATE(EnvCell, ...
+ * \brief Test du RUNCOMMAND_MAT_ENUMERATE(EnvCell, ...
  * avec en paramètres l'environnement et cherchant à accèder
  * aux variables multimat par l'envcell (i.e. le MatVarIndex en fait)
  */
 void MeshMaterialAcceleratorUnitTest::
 _executeTest1(Integer nb_z,EnvCellVectorView env1)
 {
-  _initializeVariables();
+  _initializeVariables(m_env1->envView());
 
   // Ref CPU
   for (Integer z=0, iz=nb_z; z<iz; ++z) {
@@ -412,7 +422,48 @@ _executeTest1(Integer nb_z,EnvCellVectorView env1)
     }
   }
 
-  _checkValues();
+  _checkEnvValues1();
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+/*!
+ * \brief Test du RUNCOMMAND_MAT_ENUMERATE(MatCell, ...
+ * avec en paramètres l'environnement et cherchant à accèder
+ * aux variables multimat par l'envcell (i.e. le MatVarIndex en fait)
+ */
+void MeshMaterialAcceleratorUnitTest::
+_executeTest5(Integer nb_z,MatCellVectorView mat1)
+{
+  info() << "Execute Test 5";
+  _initializeVariables(mat1);
+
+  // Ref CPU
+  for (Integer z=0, iz=nb_z; z<iz; ++z) {
+    ENUMERATE_MATCELL(i,mat1){
+      m_mat_a_ref[i] = m_mat_b_ref[i] + m_mat_c_ref[i] * m_mat_d_ref[i] + m_mat_e_ref[i];
+    }
+  }
+
+  // GPU
+  {
+    auto queue = makeQueue(m_runner);
+    auto cmd = makeCommand(queue);
+
+    auto out_a = ax::viewOut(cmd, m_mat_a);
+    auto in_b = ax::viewIn(cmd, m_mat_b);
+    auto in_c = ax::viewIn(cmd, m_mat_c);
+    auto in_d = ax::viewIn(cmd, m_mat_d);
+    auto in_e = ax::viewIn(cmd, m_mat_e);  
+
+    for (Integer z=0, iz=nb_z; z<iz; ++z) {
+      cmd << RUNCOMMAND_MAT_ENUMERATE(MatCell, evi, mat1) {
+        out_a[evi] = in_b[evi] + in_c[evi] * in_d[evi] + in_e[evi];
+      };
+    }
+  }
+
+  _checkMatValues1();
 }
 
 /*---------------------------------------------------------------------------*/
@@ -501,7 +552,7 @@ _executeTest2(Integer nb_z)
     }
   }
 
-  _checkValues();
+  _checkEnvValues1();
   _checkEnvironmentValues();
 }
 
@@ -573,7 +624,7 @@ _executeTest3(Integer nb_z)
     }
   }
 
-  _checkValues();
+  _checkEnvValues1();
 }
 
 /*---------------------------------------------------------------------------*/
@@ -648,7 +699,7 @@ _executeTest4(Integer nb_z)
     }
   }
 
-  _checkValues();
+  _checkEnvValues1();
 
     // Some further functions testing, not really usefull here, but it improves cover
   AllCellToAllEnvCell *useless(nullptr);
@@ -746,7 +797,7 @@ _executeTest4(Integer nb_z)
     }
   }
 
-  _checkValues();
+  _checkEnvValues1();
 }
 
 /*---------------------------------------------------------------------------*/
@@ -772,7 +823,7 @@ void _checkOneValue(Real value,Real ref_value,const char* var_name)
 /*---------------------------------------------------------------------------*/
 
 void MeshMaterialAcceleratorUnitTest::
-_checkValues()
+_checkEnvValues1()
 {
   ValueChecker vc(A_FUNCINFO);
   ENUMERATE_ENV(ienv, m_mm_mng) {
@@ -790,6 +841,25 @@ _checkValues()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+void MeshMaterialAcceleratorUnitTest::
+_checkMatValues1()
+{
+  ValueChecker vc(A_FUNCINFO);
+  ENUMERATE_MAT(imat, m_mm_mng) {
+    IMeshMaterial* mat = *imat;
+    ENUMERATE_MATCELL(imat,mat) {
+      _checkOneValue(m_mat_a[imat], m_mat_a_ref[imat],"Test1_mat_a");
+      _checkOneValue(m_mat_b[imat], m_mat_b_ref[imat],"Test1_mat_b");
+      _checkOneValue(m_mat_c[imat], m_mat_c_ref[imat],"Test1_mat_c");
+      _checkOneValue(m_mat_d[imat], m_mat_d_ref[imat],"Test1_mat_d");
+      _checkOneValue(m_mat_e[imat], m_mat_e_ref[imat],"Test1_mat_e");
+    }
+  }
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 void MeshMaterialAcceleratorUnitTest::
 _checkEnvironmentValues()
 {