tests and fixes for subgraph implementation

Author: raphael-s-steiner

include/osp/graph_algorithms/specialised_graph_algorithms/subgraph_algorithms.hpp

@@ -18,6 +18,8 @@ limitations under the License.
 
 #pragma once
 
+#include "osp/concepts/graph_traits.hpp"
+#include "osp/graph_algorithms/directed_graph_top_sort.hpp"
 #include "osp/graph_algorithms/subgraph_algorithms.hpp"
 #include "osp/graph_implementations/adj_list_impl/compact_sparse_graph.hpp"
 
@@ -32,13 +34,13 @@ std::unordered_map<vertex_idx_t<Graph_t_in>, vertex_idx_t<Graph_t_in>> create_in
     static_assert(std::is_same_v<vertex_idx_t<Graph_t_in>, vertex_idx_t<Graph_t_out>>,
                   "Graph_t_in and out must have the same vertex_idx types");
 
-    const std::vector<vertex_idx_t<Graph_t_in>> topOrder = GetTopOrder(instance.getComputationalDag());
+    const std::vector<vertex_idx_t<Graph_t_in>> topOrder = GetTopOrder(dag);
     std::vector<vertex_idx_t<Graph_t_in>> topOrderPosition(topOrder.size());
-    for (vertex_idx_t<Graph_t_in> pos = 0; pos < dag.numbernum_vertices(); ++pos) {
+    for (vertex_idx_t<Graph_t_in> pos = 0; pos < dag.num_vertices(); ++pos) {
         topOrderPosition[topOrder[pos]] = pos;
     }
 
-    auto topCmp = [&topOrderPosition](const &vertex_idx_t<Graph_t_in> lhs, const &vertex_idx_t<Graph_t_in> rhs) { return topOrderPosition[lhs] < topOrderPosition[rhs]; };
+    auto topCmp = [&topOrderPosition](const vertex_idx_t<Graph_t_in> &lhs, const vertex_idx_t<Graph_t_in> &rhs) { return topOrderPosition[lhs] < topOrderPosition[rhs]; };
 
     std::set<vertex_idx_t<Graph_t_in>, decltype(topCmp)> selectedVerticesOrdered(selected_nodes.begin(), selected_nodes.end(), topCmp);
 
@@ -54,7 +56,7 @@ std::unordered_map<vertex_idx_t<Graph_t_in>, vertex_idx_t<Graph_t_in>> create_in
     for (const auto &node : selectedVerticesOrdered) {
         for (const auto &chld : dag.children(node)) {
             if (selectedVerticesOrdered.find(chld) != selectedVerticesOrdered.end()) {
-                edges.emplace(node, chld);
+                edges.emplace_back(local_idx.at(node), local_idx.at(chld));
             }
         }
     }

tests/CMakeLists.txt

@@ -162,6 +162,8 @@ _add_test( maxbsp_converter_and_hc )
 
 _add_test( cost_evaluation )
 
+_add_test( subgraph )
+
 ## pebbling ILPs
 
 if (COPT_FOUND)

tests/subgraph.cpp

@@ -0,0 +1,103 @@
+/*
+Copyright 2024 Huawei Technologies Co., Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+@author Toni Boehnlein, Pal Andras Papp, Raphael S. Steiner, Christos Konstantinos Matzoros
+*/
+
+#define BOOST_TEST_MODULE SubGraphs
+#include <boost/test/unit_test.hpp>
+
+#include "osp/graph_algorithms/specialised_graph_algorithms/subgraph_algorithms.hpp"
+#include "osp/graph_implementations/adj_list_impl/cdag_vertex_impl.hpp"
+#include "osp/graph_implementations/adj_list_impl/computational_dag_vector_impl.hpp"
+
+using namespace osp;
+
+BOOST_AUTO_TEST_CASE(SubGraphCompactSparseGraph) {
+    const std::vector<std::pair<std::size_t, std::size_t>> edges({{0, 1}, {2, 3}, {6, 10}, {7, 9}, {0, 2}, {4, 6}, {1, 6}, {6, 7}, {5, 6}, {3, 7}, {1, 2}});
+    Compact_Sparse_Graph<true, true, true, true, true> graph(11, edges);
+    Compact_Sparse_Graph<true, true, true, true, true> subGraph;
+
+    unsigned cntr = 0;
+    for (const auto &vert : graph.vertices()) {
+        graph.set_vertex_work_weight(vert, cntr++);
+        graph.set_vertex_comm_weight(vert, cntr++);
+        graph.set_vertex_mem_weight(vert, cntr++);
+        graph.set_vertex_type(vert, cntr++);
+    }
+
+    const std::vector<vertex_idx_t<Compact_Sparse_Graph<true, true, true, true, true>>> selectVert({2, 3, 10, 6, 7});
+    const auto vertCorrespondence = create_induced_subgraph_map(graph, subGraph, selectVert);
+    BOOST_CHECK_EQUAL(subGraph.num_vertices(), selectVert.size());
+    BOOST_CHECK_EQUAL(subGraph.num_edges(), 4);
+
+    for (const auto &vert : selectVert) {
+        BOOST_CHECK_LT(vertCorrespondence.at(vert), selectVert.size());
+
+        for (const auto &otherVert : selectVert) {
+            if (vertCorrespondence.at(vert) == vertCorrespondence.at(otherVert)) {
+                BOOST_CHECK_EQUAL(vert, otherVert);
+            }
+        }
+    }
+
+    for (const auto &vert : selectVert) {
+        BOOST_CHECK_EQUAL(graph.vertex_work_weight(vert), subGraph.vertex_work_weight(vertCorrespondence.at(vert)));
+        BOOST_CHECK_EQUAL(graph.vertex_comm_weight(vert), subGraph.vertex_comm_weight(vertCorrespondence.at(vert)));
+        BOOST_CHECK_EQUAL(graph.vertex_mem_weight(vert), subGraph.vertex_mem_weight(vertCorrespondence.at(vert)));
+        BOOST_CHECK_EQUAL(graph.vertex_type(vert), subGraph.vertex_type(vertCorrespondence.at(vert)));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(SubGraphDagVectorImpl) {
+    using v_impl = cdag_vertex_impl<std::size_t, unsigned, unsigned, unsigned, unsigned>;
+
+    computational_dag_vector_impl<v_impl> graph;
+    computational_dag_vector_impl<v_impl> subGraph;
+
+    const std::size_t numVert = 11;
+    const std::vector<std::pair<std::size_t, std::size_t>> edges({{0, 1}, {2, 3}, {6, 10}, {7, 9}, {0, 2}, {4, 6}, {1, 6}, {6, 7}, {5, 6}, {3, 7}, {1, 2}});
+
+    unsigned cntr = 0;
+    for (std::size_t i = 0U; i < numVert; ++i) {
+        graph.add_vertex(cntr, cntr + 1U, cntr + 2U, cntr + 3U);
+        cntr += 4U;
+    }
+    for (const auto &[src, tgt] : edges) {
+        graph.add_edge(src, tgt);
+    }
+
+    const std::vector<vertex_idx_t<computational_dag_vector_impl<v_impl>>> selectVert({2, 3, 10, 6, 7});
+    const auto vertCorrespondence = create_induced_subgraph_map(graph, subGraph, selectVert);
+    BOOST_CHECK_EQUAL(subGraph.num_vertices(), selectVert.size());
+    BOOST_CHECK_EQUAL(subGraph.num_edges(), 4);
+
+    for (const auto &vert : selectVert) {
+        BOOST_CHECK_LT(vertCorrespondence.at(vert), selectVert.size());
+
+        for (const auto &otherVert : selectVert) {
+            if (vertCorrespondence.at(vert) == vertCorrespondence.at(otherVert)) {
+                BOOST_CHECK_EQUAL(vert, otherVert);
+            }
+        }
+    }
+
+    for (const auto &vert : selectVert) {
+        BOOST_CHECK_EQUAL(graph.vertex_work_weight(vert), subGraph.vertex_work_weight(vertCorrespondence.at(vert)));
+        BOOST_CHECK_EQUAL(graph.vertex_comm_weight(vert), subGraph.vertex_comm_weight(vertCorrespondence.at(vert)));
+        BOOST_CHECK_EQUAL(graph.vertex_mem_weight(vert), subGraph.vertex_mem_weight(vertCorrespondence.at(vert)));
+        BOOST_CHECK_EQUAL(graph.vertex_type(vert), subGraph.vertex_type(vertCorrespondence.at(vert)));
+    }
+}