Graph Container Interface

libNeonCore/include/Neon/core/types/digraph.h

@@ -32,10 +32,10 @@ struct Empty
 
 /**
  * DiGraph is a directed graph datastructure implemented using an adjacency list.
- * 
+ *
  * Self loops can be represented.
  * Parallel loops cannot be represented.
- * 
+ *
  * @tparam VertexProp Type representing the properties to be stored per-vertex
  * @tparam EdgeProp Type representing the properties to be stored per-edge
  */
@@ -187,6 +187,18 @@ class DiGraph
         }
     }
 
+    /**
+     * Run a function on each vertex in the graph
+     *
+     * @param fn Function that takes in a vertex and does something
+     */
+    void forEachVertex(std::function<void(size_t)> fn) const
+    {
+        for (auto& kv : mAdj) {
+            fn(kv.first);
+        }
+    }
+
     /**
      * Returns a copy of incoming edges from a vertex as pairs of vertex ids
      *
@@ -313,6 +325,21 @@ class DiGraph
         }
     }
 
+    /**
+     * Run a function on each edge
+     *
+     * @param fn Function that takes in an edge and does something
+     */
+    void forEachEdge(std::function<void(const Edge&)> fn) const
+    {
+        for (auto i : mAdj) {
+            size_t src = i.first;
+            for (size_t tgt : i.second) {
+                fn({src, tgt});
+            }
+        }
+    }
+
     /**
      * Get a const-ref to the vertex property
      *
@@ -337,6 +364,7 @@ class DiGraph
         return mVprop.at(v);
     }
 
+
     /**
      * Set the vertex property
      *
@@ -415,9 +443,9 @@ class DiGraph
 
     /**
      * Contract an edge by deleting the source vertex and connecting all its neighbors
-     * with the target vertex. The edge property of the removed vertex is set to all the 
+     * with the target vertex. The edge property of the removed vertex is set to all the
      * new edges.
-     * 
+     *
      * a--->c--->d
      *      ^
      *      |
@@ -449,9 +477,9 @@ class DiGraph
 
     /**
      * Contract an edge by deleting the source vertex and connecting all its neighbors
-     * with the target vertex The edge property of the removed vertex is set to all the 
+     * with the target vertex The edge property of the removed vertex is set to all the
      * new edges.
-     * 
+     *
      * a--->c--->d
      *      ^
      *      |
@@ -504,7 +532,8 @@ class DiGraph
      * @param v Vertex
      * @return Neighboring vertices of v
      */
-    const std::set<size_t> inNeighbors(size_t v) const
+    auto inNeighbors(size_t v) const
+        -> const std::set<size_t>
     {
         std::set<size_t> in;
         forEachInEdge(v, [&](const Edge& e) {

libNeonCore/src/core/types/DataView.e.cpp → libNeonCore/src/core/types/DataView.cpp

@@ -22,7 +22,7 @@ auto DataViewUtil::toString(DataView e) -> std::string
         }
         case DataView::BOUNDARY: {
             return "BOUNDARY";
-        }        
+        }
         default: {
             NEON_THROW_UNSUPPORTED_OPTION("DataViewUtil");
         }
@@ -40,7 +40,7 @@ auto DataViewUtil::fromInt(int val) -> DataView
         }
         case static_cast<int>(DataView::BOUNDARY): {
             return DataView::BOUNDARY;
-        }        
+        }
         default: {
             NEON_THROW_UNSUPPORTED_OPTION("DataViewUtil");
         }
@@ -52,9 +52,9 @@ auto DataViewUtil::toInt(DataView dataView) -> int
     return static_cast<int>(dataView);
 }
 
-}  // namespace Neon
-
 std::ostream& operator<<(std::ostream& os, Neon::DataView const& m)
 {
     return os << std::string(Neon::DataViewUtil::toString(m));
 }
+
+}  // namespace Neon

libNeonCore/src/core/types/DeviceType.cpp

@@ -120,12 +120,12 @@ auto DeviceTypeUtil::Cli::getStringOptions() -> std::string
 
 auto DeviceTypeUtil::Cli::addToReport(Neon::core::Report& report, Neon::core::Report::SubBlock& subBlock) -> void
 {
-    report.addMember("Executor", DeviceTypeUtil::toString(this->getOption()), &subBlock);
+    report.addMember("DeviceType", DeviceTypeUtil::toString(this->getOption()), &subBlock);
 }
 
 auto DeviceTypeUtil::Cli::addToReport(Neon::core::Report& report) -> void
 {
-    report.addMember("Executor", DeviceTypeUtil::toString(this->getOption()));
+    report.addMember("DeviceType", DeviceTypeUtil::toString(this->getOption()));
 }
 
 

libNeonDomain/include/Neon/domain/interface/GridBase.h

@@ -21,15 +21,6 @@ class GridBase
    public:
     GridBase();
 
-    GridBase(const std::string&                gridImplementationName,
-             const Neon::Backend&              backend,
-             const Neon::index_3d&             dim,
-             const Neon::domain::Stencil&      stencil,
-             const Neon::set::DataSet<size_t>& nPartitionElements /**< Number of element per partition */,
-             const Neon::index_3d&             defaultBlockSize,
-             const Vec_3d<double>&             spacingData = Vec_3d<double>(1, 1, 1) /*! Spacing, i.e. size of a voxel */,
-             const Vec_3d<double>&             origin = Vec_3d<double>(0, 0, 0) /*!      Origin  */);
-
     /**
      * Returns the size of the grid
      */
@@ -82,7 +73,6 @@ class GridBase
 
     /**
      * Creates a DataSet object compatible with the number of GPU used by the grid.
-     * TODO - refactor into a create method once all grids are ported
      */
     template <typename T>
     auto newDataSet() const
@@ -106,6 +96,12 @@ class GridBase
     auto getBackend() const
         -> const Backend&;
 
+    /**
+     * Returns the backed used to create the grid
+     */
+    auto getBackend()
+        -> Backend&;
+
     /**
      * Returns the DevSet object used to create the grid.
      */
@@ -118,32 +114,62 @@ class GridBase
     auto toString() const
         -> std::string;
 
+    /**
+     * Returns an UID for the grid
+     * @return
+     */
     auto getGridUID() const
         -> size_t;
 
+    /**
+     * Add the grid information in a Report object
+     */
     virtual auto toReport(Neon::Report& report,
                           bool          addBackendInfo = false) const
         -> void;
 
+    /**
+     * Returns the thread block size used by default by the grid
+     */
     auto getDefaultBlock() const
         -> const Neon::index_3d&;
 
 
 
    protected:
-    auto init(const std::string&                gridImplementationName,
-              const Neon::Backend&              backend,
-              const Neon::index_3d&             dimension,
-              const Neon::domain::Stencil&      stencil,
-              const Neon::set::DataSet<size_t>& nPartitionElements,
-              const Neon::index_3d&             defaultBlockSize,
-              const Vec_3d<double>&             spacingData,
-              const Vec_3d<double>&             origin) -> void;
+    /**
+     * Protected constructor
+     */
+    GridBase(const std::string&                gridImplementationName,
+             const Neon::Backend&              backend,
+             const Neon::index_3d&             dim,
+             const Neon::domain::Stencil&      stencil,
+             const Neon::set::DataSet<size_t>& nPartitionElements /**< Number of element per partition */,
+             const Neon::index_3d&             defaultBlockSize,
+             const Vec_3d<double>&             spacingData = Vec_3d<double>(1, 1, 1) /*! Spacing, i.e. size of a voxel */,
+             const Vec_3d<double>&             origin = Vec_3d<double>(0, 0, 0) /*!      Origin  */);
 
+    /**
+     * Protected initialization function used by derived classes to set some parameters.
+     */
+    auto init(const std::string&                gridImplementationName /**< Name of the implementation, for example dGrid eGrid etc */,
+              const Neon::Backend&              backend /**< Backend used to create the grid */,
+              const Neon::index_3d&             dimension /**< Dimension of the grid */,
+              const Neon::domain::Stencil&      stencil /**< Union of all the stencil that will be used with the grid */,
+              const Neon::set::DataSet<size_t>& nPartitionElements /**< Elements associated to each partition */,
+              const Neon::index_3d&             defaultBlockSize /**< Default thread block size */,
+              const Vec_3d<double>&             spacingData /**< Grid spacing */,
+              const Vec_3d<double>&             origin /**< Position in space of the grid's origin */) -> void;
 
+    /**
+     * Protected method to set the default thread blocks size
+     */
     auto setDefaultBlock(const Neon::index_3d&)
         -> void;
 
+    /**
+     * Protected method to set default thread block size by data view.
+     */
     auto getDefaultLaunchParameters(Neon::DataView)
         -> Neon::set::LaunchParameters&;
 
@@ -164,8 +190,8 @@ class GridBase
         Neon::index_3d             dimension /**<          Dimension of the grid                    */;
         Neon::domain::Stencil      stencil /**<            Stencil used for the grid initialization */;
         Neon::set::DataSet<size_t> nPartitionElements /**< Number of elements per partition         */;
-        Vec_3d<double>             spacing /*!             Spacing, i.e. size of a voxel            */;
-        Vec_3d<double>             origin /*!              Origin                                   */;
+        Vec_3d<double>             spacing /**<            Spacing, i.e. size of a voxel            */;
+        Vec_3d<double>             origin /**<             Position in space of the grid's origin   */;
         Defaults_t                 defaults;
         std::string                gridImplementationName;
     };

libNeonDomain/include/Neon/domain/tools/IODomain.h

@@ -248,7 +248,7 @@ auto IODomain<ExportType, intType_ta>::resetValuesToMasked(ExportType offset,
 template <typename ExportType, typename intType_ta>
 auto IODomain<ExportType, intType_ta>::resetValuesToConst(ExportType offset) -> void
 {
-    mField.forEach([&](const Integer_3d<intType_ta>& idx, int c, ExportType& val) {
+    mField.forEach([&](const Integer_3d<intType_ta>&, int, ExportType& val) {
         val = offset;
     });
 }
@@ -363,9 +363,9 @@ auto IODomain<ExportType, intType_ta>::maxDiff(const IODomain<ExportType, intTyp
     }
 
     a.forEachActive([&](const Integer_3d<intType_ta>& idx,
-                                 int                           c,
-                                 const ExportType&             valA,
-                                 const ExportType&             valB) {
+                        int                           c,
+                        const ExportType&             valA,
+                        const ExportType&             valB) {
         const auto newDiff = std::abs(valA - valB);
         const int  threadId = omp_get_thread_num();
         if (newDiff > std::get<0>(max_diff[threadId])) {
@@ -375,7 +375,7 @@ auto IODomain<ExportType, intType_ta>::maxDiff(const IODomain<ExportType, intTyp
             std::get<2>(md) = c;
         }
     },
-                             b);
+                    b);
 
     int target = 0;
     for (auto i = 1; i < nThreads; i++) {

libNeonDomain/include/Neon/domain/tools/TestData.h

@@ -300,13 +300,13 @@ template <typename G, typename T, int C>
 auto TestData<G, T, C>::axpy(const Type* alpha, IODomain& A, IODomain& B)
     -> void
 {
-    this->template forEachActiveIODomain([&](const Neon::index_3d& idx,
-                                             int                   cardinality,
-                                             Type&                 a,
-                                             Type&                 b) {
+    this->forEachActiveIODomain([&](const Neon::index_3d& /*idx*/,
+                                    int /*cardinality*/,
+                                    Type& a,
+                                    Type& b) {
         b += (*alpha) * a;
     },
-                                         A, B);
+                                A, B);
 }
 
 template <typename G, typename T, int C>
@@ -318,8 +318,8 @@ auto TestData<G, T, C>::laplace(IODomain& A, NEON_IO IODomain& B)
     }
     this->template forEachActiveIODomain([&](const Neon::index_3d& idx,
                                              int                   cardinality,
-                                             Type&                 a,
-                                             Type&                 b) {
+                                             Type& /*a*/,
+                                             Type& b) {
         // Laplacian stencil operates on 6 neighbors (assuming 3D)
         T    res = 0;
         bool isValid = false;
@@ -342,23 +342,24 @@ auto TestData<G, T, C>::laplace(IODomain& A, NEON_IO IODomain& B)
 }
 
 template <typename G, typename T, int C>
-auto TestData<G, T, C>::compare(FieldNames name, T tollerance) -> bool
+auto TestData<G, T, C>::compare(FieldNames         name,
+                                [[maybe_unused]] T tollerance) -> bool
 {
     bool isTheSame = false;
     if constexpr (std::is_integral_v<T>) {
         bool foundAnIssue = false;
-        this->compare(name, [&](const Neon::index_3d& idx,
-                                int                   cardinality,
-                                const T&              golden,
-                                const T&              computed) {
+        this->compare(name, [&](const Neon::index_3d& /*idx*/,
+                                int /*cardinality*/,
+                                const T& golden,
+                                const T& computed) {
             if (golden != computed) {
                 {
 #pragma omp critical
                     {
                         foundAnIssue = true;
-                        //std::stringstream s;
-                        //s << idx.to_string() << " " << golden << " " << computed << std::endl;
-                        //NEON_INFO(s.str());
+                        // std::stringstream s;
+                        // s << idx.to_string() << " " << golden << " " << computed << std::endl;
+                        // NEON_INFO(s.str());
                     }
                 }
             }
@@ -375,7 +376,7 @@ auto TestData<G, T, C>::compare(FieldNames name, T tollerance) -> bool
             T maxAbs = std::max(goldenABS, computedABS);
 
             auto relativeDiff = (maxAbs == 0.0 ? 0.0 : std::abs(golden - computed) / maxAbs);
-            foundAnIssue = relativeDiff >= 0.00001;
+            foundAnIssue = relativeDiff >= tollerance;
         });
         isTheSame = !foundAnIssue;
     }

libNeonDomain/src/domain/interface/GridBase.cpp

@@ -93,6 +93,12 @@ auto GridBase::getBackend() const
     return mStorage->backend;
 }
 
+auto GridBase::getBackend()
+    -> Backend&
+{
+    return mStorage->backend;
+}
+
 auto GridBase::getDevSet() const
     -> const Neon::set::DevSet&
 {

libNeonDomain/src/domain/internal/dGrid/dGrid.cpp

@@ -163,7 +163,7 @@ auto dGrid::getKernelConfig(int            streamIdx,
                                                                     getDefaultBlock(), 0);
 
     kernelConfig.expertSetLaunchParameters(launchInfoSet);
-    kernelConfig.expertSetBackend(getBackend());
+    kernelConfig.expertSetBackend(this->getBackend());
 
     return kernelConfig;
 }

libNeonDomain/tests/unit/CMakeLists.txt

@@ -5,8 +5,8 @@ add_subdirectory("gUt_containers")
 add_subdirectory("gUt_dataView_patterns")
 add_subdirectory("gUt_map")
 add_subdirectory("gUt_patterns_container")
-#add_subdirectory("gUt_periodic")
 add_subdirectory("domainUt_swap")
 add_subdirectory("gUt_tools")
 add_subdirectory("gUt_vtk")
-add_subdirectory("gUt_bGrid")
+add_subdirectory("gUt_bGrid")
+