Line data    Source code

       1              : // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
       2              : // SPDX-License-Identifier: Apache-2.0
       3              : 
       4              : #include "ceed.hpp"
       5              : 
       6              : #include <string_view>
       7              : #include "utils/omp.hpp"
       8              : 
       9              : namespace palace::ceed
      10              : {
      11              : 
      12              : namespace internal
      13              : {
      14              : 
      15              : static std::vector<Ceed> ceeds;
      16              : 
      17       516588 : const std::vector<Ceed> &GetCeedObjects()
      18              : {
      19       516588 :   return ceeds;
      20              : }
      21              : 
      22        33900 : std::size_t NumCeeds()
      23              : {
      24        33900 :   return GetCeedObjects().size();
      25              : }
      26              : 
      27              : }  // namespace internal
      28              : 
      29           66 : void Initialize(const char *resource, const char *jit_source_dir)
      30              : {
      31           66 :   PalacePragmaOmp(parallel)
      32              :   {
      33              :     PalacePragmaOmp(master)
      34              :     {
      35              :       // Only parallelize libCEED operators over threads when not using the GPU.
      36              :       const int nt = !std::string_view(resource).compare(0, 4, "/cpu")
      37              :                          ? utils::GetNumActiveThreads()
      38              :                          : 1;
      39              :       internal::ceeds.resize(nt, nullptr);
      40              :     }
      41              :   }
      42              : 
      43              :   // Master thread initializes all Ceed objects (ineherently sequential anyway due to shared
      44              :   // resources).
      45          198 :   for (std::size_t i = 0; i < internal::ceeds.size(); i++)
      46              :   {
      47          132 :     int ierr = CeedInit(resource, &internal::ceeds[i]);
      48          132 :     MFEM_VERIFY(!ierr, "Failed to initialize libCEED with resource " << resource << "!");
      49          132 :     Ceed ceed = internal::ceeds[i];
      50              : 
      51              :     // Configure error handling (allow errors to be handled by PalaceCeedCallBackend or
      52              :     // PalaceCeedCall).
      53          132 :     PalaceCeedCall(ceed, CeedSetErrorHandler(ceed, CeedErrorStore));
      54              : 
      55              :     // Configure QFunction search path.
      56          132 :     if (jit_source_dir)
      57              :     {
      58          132 :       PalaceCeedCall(ceed, CeedAddJitSourceRoot(ceed, jit_source_dir));
      59              :     }
      60              :   }
      61           66 : }
      62              : 
      63           66 : void Finalize()
      64              : {
      65              :   // Destroy Ceed context(s).
      66          198 :   for (std::size_t i = 0; i < internal::ceeds.size(); i++)
      67              :   {
      68          132 :     int ierr = CeedDestroy(&internal::ceeds[i]);
      69          132 :     MFEM_VERIFY(!ierr, "Failed to finalize libCEED!");
      70              :   }
      71              :   internal::ceeds.clear();
      72           66 : }
      73              : 
      74           66 : std::string Print()
      75              : {
      76           66 :   MFEM_VERIFY(internal::GetCeedObjects().size() > 0,
      77              :               "libCEED must be initialized before querying the active backend!");
      78           66 :   Ceed ceed = internal::GetCeedObjects()[0];
      79              :   const char *ceed_resource;
      80           66 :   PalaceCeedCall(ceed, CeedGetResource(ceed, &ceed_resource));
      81           66 :   return std::string(ceed_resource);
      82              : }
      83              : 
      84       109348 : void InitCeedVector(const mfem::Vector &v, Ceed ceed, CeedVector *cv, bool init)
      85              : {
      86              :   CeedMemType mem;
      87       109348 :   PalaceCeedCall(ceed, CeedGetPreferredMemType(ceed, &mem));
      88       109348 :   if (!mfem::Device::Allows(mfem::Backend::DEVICE_MASK) && mem == CEED_MEM_DEVICE)
      89              :   {
      90            0 :     mem = CEED_MEM_HOST;
      91              :   }
      92       109348 :   const auto *data = v.Read(mem == CEED_MEM_DEVICE);
      93       109348 :   if (init)
      94              :   {
      95       109348 :     PalaceCeedCall(ceed, CeedVectorCreate(ceed, v.Size(), cv));
      96              :   }
      97              :   else
      98              :   {
      99            0 :     PalaceCeedCall(ceed, CeedVectorTakeArray(*cv, mem, nullptr));
     100              :   }
     101       109348 :   PalaceCeedCall(
     102              :       ceed, CeedVectorSetArray(*cv, mem, CEED_USE_POINTER, const_cast<CeedScalar *>(data)));
     103       109348 : }
     104              : 
     105        39551 : CeedElemTopology GetCeedTopology(mfem::Geometry::Type geom)
     106              : {
     107        39551 :   switch (geom)
     108              :   {
     109              :     case mfem::Geometry::SEGMENT:
     110              :       return CEED_TOPOLOGY_LINE;
     111              :     case mfem::Geometry::TRIANGLE:
     112              :       return CEED_TOPOLOGY_TRIANGLE;
     113              :     case mfem::Geometry::SQUARE:
     114              :       return CEED_TOPOLOGY_QUAD;
     115              :     case mfem::Geometry::TETRAHEDRON:
     116              :       return CEED_TOPOLOGY_TET;
     117              :     case mfem::Geometry::CUBE:
     118              :       return CEED_TOPOLOGY_HEX;
     119              :     case mfem::Geometry::PRISM:
     120              :       return CEED_TOPOLOGY_PRISM;
     121              :     case mfem::Geometry::PYRAMID:
     122              :       return CEED_TOPOLOGY_PYRAMID;
     123            0 :     default:
     124            0 :       MFEM_ABORT("This type of element is not supported!");
     125              :       return CEED_TOPOLOGY_LINE;  // Silence compiler warning
     126              :   }
     127              : }
     128              : 
     129            0 : mfem::Geometry::Type GetMfemTopology(CeedElemTopology geom)
     130              : {
     131            0 :   switch (geom)
     132              :   {
     133              :     case CEED_TOPOLOGY_LINE:
     134              :       return mfem::Geometry::SEGMENT;
     135            0 :     case CEED_TOPOLOGY_TRIANGLE:
     136            0 :       return mfem::Geometry::TRIANGLE;
     137            0 :     case CEED_TOPOLOGY_QUAD:
     138            0 :       return mfem::Geometry::SQUARE;
     139            0 :     case CEED_TOPOLOGY_TET:
     140            0 :       return mfem::Geometry::TETRAHEDRON;
     141            0 :     case CEED_TOPOLOGY_HEX:
     142            0 :       return mfem::Geometry::CUBE;
     143            0 :     case CEED_TOPOLOGY_PRISM:
     144            0 :       return mfem::Geometry::PRISM;
     145            0 :     case CEED_TOPOLOGY_PYRAMID:
     146            0 :       return mfem::Geometry::PYRAMID;
     147            0 :     default:
     148            0 :       MFEM_ABORT("This type of element is not supported!");
     149              :       return mfem::Geometry::SEGMENT;  // Silence compiler warning
     150              :   }
     151              : }
     152              : 
     153              : }  // namespace palace::ceed