added const_graph_t template argument to OrbitGraphProcessor

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/IsomorphicSubgraphScheduler.hpp

@@ -26,9 +26,14 @@ limitations under the License.
 
 namespace osp {
 
-
 template<typename Graph_t, typename Constr_Graph_t>
 class IsomorphicSubgraphScheduler {
+    static_assert(is_computational_dag_v<Graph_t>, "Graph must be a computational DAG");
+    static_assert(is_computational_dag_v<Constr_Graph_t>, "Constr_Graph_t must be a computational DAG");
+    static_assert(is_constructable_cdag_v<Constr_Graph_t>,
+                  "Constr_Graph_t must satisfy the constructable_cdag_vertex concept");
+    static_assert(std::is_same_v<vertex_idx_t<Graph_t>, vertex_idx_t<Constr_Graph_t>>,
+                  "Graph_t and Constr_Graph_t must have the same vertex_idx types");
 
     private:
 
@@ -53,7 +58,7 @@ class IsomorphicSubgraphScheduler {
     }
 
     std::vector<vertex_idx_t<Graph_t>> compute_partition(const BspInstance<Graph_t>& instance) {
-        OrbitGraphProcessor<Graph_t> processor(symmetry_);
+        OrbitGraphProcessor<Graph_t, Constr_Graph_t> processor(symmetry_);
         processor.discover_isomorphic_groups(instance.getComputationalDag());
         const auto& orbit_processor_groups = processor.get_final_groups();
 
@@ -68,8 +73,6 @@ class IsomorphicSubgraphScheduler {
             for (const auto& sg_vertices : group.subgraphs) {
                 subgraph<Graph_t> new_sg;
                 new_sg.vertices = sg_vertices;
-                // The following properties are not directly provided by OrbitGraphProcessor
-                // but are needed by downstream logic. We can compute them.
                 new_sg.work_weight = 0;
                 new_sg.memory_weight = 0;
                 for (const auto& v : sg_vertices) {

include/osp/dag_divider/isomorphism_divider/OrbitGraphProcessor.hpp

@@ -38,9 +38,16 @@ namespace osp {
  * It then partitions the DAG by grouping all nodes with the same hash into an "orbit".
  * A coarse graph is constructed where each node represents one such orbit.
  */
-template<typename Graph_t, typename node_hash_func_t = uniform_node_hash_func<vertex_idx_t<Graph_t>>>
+template<typename Graph_t, typename Constr_Graph_t>
 class OrbitGraphProcessor {
 public:
+    static_assert(is_computational_dag_v<Graph_t>, "Graph must be a computational DAG");
+    static_assert(is_computational_dag_v<Constr_Graph_t>, "Constr_Graph_t must be a computational DAG");
+    static_assert(is_constructable_cdag_v<Constr_Graph_t>,
+                  "Constr_Graph_t must satisfy the constructable_cdag_vertex concept");
+    static_assert(std::is_same_v<vertex_idx_t<Graph_t>, vertex_idx_t<Constr_Graph_t>>,
+                  "Graph_t and Constr_Graph_t must have the same vertex_idx types");
+
     using VertexType = vertex_idx_t<Graph_t>;
 
     // Represents a group of isomorphic subgraphs, corresponding to a single node in a coarse graph.
@@ -57,11 +64,11 @@ class OrbitGraphProcessor {
     // using MerkleHashComputer_t = MerkleHashComputer<Graph_t, node_hash_func_t, true>;
 
     // Results from the first (orbit) coarsening step
-    Graph_t coarse_graph_;
+    Constr_Graph_t coarse_graph_;
     std::vector<VertexType> contraction_map_;
 
     // Results from the second (custom) coarsening step
-    Graph_t final_coarse_graph_;
+    Constr_Graph_t final_coarse_graph_;
     std::vector<VertexType> final_contraction_map_;
     std::vector<Group> final_groups_;
 
@@ -86,9 +93,9 @@ class OrbitGraphProcessor {
      * @param dag The input computational DAG.
      */
     void discover_isomorphic_groups(const Graph_t &dag) {
-        coarse_graph_ = Graph_t();
+        coarse_graph_ = Constr_Graph_t();
         contraction_map_.clear();
-        final_coarse_graph_ = Graph_t();
+        final_coarse_graph_ = Constr_Graph_t();
         final_contraction_map_.clear();
         final_groups_.clear();
 
@@ -111,7 +118,7 @@ class OrbitGraphProcessor {
 
         coarser_util::construct_coarse_dag(dag, coarse_graph_, contraction_map_);
 
-        Graph_t transitive_reduction; 
+        Constr_Graph_t transitive_reduction; 
         transitive_reduction_sparse(coarse_graph_, transitive_reduction);
         coarse_graph_ = std::move(transitive_reduction);
 
@@ -123,15 +130,15 @@ class OrbitGraphProcessor {
     /**
      * @brief Greedily merges nodes in the orbit graph based on structural and symmetry constraints.
      */
-    void perform_coarsening(const Graph_t& original_dag, const Graph_t& initial_coarse_graph) {
-        final_coarse_graph_ = Graph_t();
+    void perform_coarsening(const Graph_t& original_dag, const Constr_Graph_t& initial_coarse_graph) {
+        final_coarse_graph_ = Constr_Graph_t();
         final_contraction_map_.clear();
 
         if (initial_coarse_graph.num_vertices() == 0) {
             return;
         }
 
-        Graph_t current_coarse_graph = initial_coarse_graph;
+        Constr_Graph_t current_coarse_graph = initial_coarse_graph;
         std::vector<Group> current_groups(initial_coarse_graph.num_vertices());
         std::vector<VertexType> current_contraction_map = contraction_map_;
 
@@ -166,7 +173,7 @@ class OrbitGraphProcessor {
                 }
 
                 // 2. Acyclicity & Critical Path
-                Graph_t temp_coarse_graph;
+                Constr_Graph_t temp_coarse_graph;
                 std::vector<VertexType> temp_contraction_map(current_coarse_graph.num_vertices());
                 VertexType new_idx = 0;
                 for (VertexType i = 0; i < temp_contraction_map.size(); ++i) {
@@ -276,7 +283,7 @@ class OrbitGraphProcessor {
         std::sort(all_nodes.begin(), all_nodes.end());
 
         // 2. Create an induced subgraph and find its weakly connected components.
-        Graph_t induced_subgraph;
+        Constr_Graph_t induced_subgraph;
         create_induced_subgraph(original_dag, induced_subgraph, all_nodes);
 
         std::vector<VertexType> components; // local -> component_id

…mplementations/eigen_sparse_iterator.hpp …matrix_adapter/eigen_sparse_iterator.hppinclude/osp/graph_implementations/eigen_sparse_iterator.hpp renamed to include/osp/graph_implementations/eigen_matrix_adapter/eigen_sparse_iterator.hpp include/osp/graph_implementations/eigen_sparse_iterator.hpp renamed to include/osp/graph_implementations/eigen_matrix_adapter/eigen_sparse_iterator.hpp

@@ -25,7 +25,7 @@ limitations under the License.
 #include "osp/concepts/directed_graph_edge_desc_concept.hpp"
 #include "osp/concepts/computational_dag_concept.hpp"
 #include "osp/graph_implementations/vertex_iterator.hpp"
-#include "osp/graph_implementations/eigen_sparse_iterator.hpp"
+#include "eigen_sparse_iterator.hpp"
 
 namespace osp {
 

include/osp/graph_implementations/eigen_matrix_adapter/sparse_matrix.hpp

@@ -23,6 +23,7 @@ limitations under the License.
 #include "osp/dag_divider/wavefront_divider/RecursiveWavefrontDivider.hpp"
 #include "osp/graph_algorithms/directed_graph_util.hpp"
 #include "osp/graph_implementations/adj_list_impl/computational_dag_vector_impl.hpp"
+#include "osp/graph_implementations/adj_list_impl/dag_vector_adapter.hpp"
 #include "osp/auxiliary/io/hdag_graph_file_reader.hpp"
 #include "osp/auxiliary/io/dot_graph_file_reader.hpp"
 #include "osp/auxiliary/io/DotFileWriter.hpp"
@@ -42,9 +43,11 @@ using namespace osp;
 BOOST_AUTO_TEST_CASE(BspScheduleRecomp_test)
 {
     using graph_t = computational_dag_vector_impl_def_t;
-
-    BspInstance<graph_t> instance;
-    file_reader::readComputationalDagDotFormat("", instance.getComputationalDag());
+    using graph_t2 = graph_t;
+    //using graph_t2 = dag_vector_adapter<cdag_vertex_impl_unsigned,int>;
+   
+    BspInstance<graph_t2> instance;
+    //file_reader::readComputationalDagDotFormat("", instance.getComputationalDag());
 
     for (const auto& v : instance.vertices()) {
 
@@ -86,7 +89,7 @@ BOOST_AUTO_TEST_CASE(BspScheduleRecomp_test)
 
     // auto schedule = pre_scheduler.run(input.instance, input.multiplicities, input.required_proc_types);
 
-    IsomorphicSubgraphScheduler<graph_t, graph_t> iso_scheduler(combo);
+    IsomorphicSubgraphScheduler<graph_t2, graph_t> iso_scheduler(combo);
     iso_scheduler.set_symmetry(2);
     iso_scheduler.set_plot_dot_graphs(true);
 

tests/merkle_hash_divider.cpp

@@ -36,7 +36,7 @@ using namespace osp;
 using graph_t = computational_dag_vector_impl_def_t;
 
 template <typename Graph_t>
-void check_partitioning(const Graph_t& dag, const OrbitGraphProcessor<Graph_t>& processor) {
+void check_partitioning(const Graph_t& dag, const OrbitGraphProcessor<Graph_t, Graph_t>& processor) {
     const auto& final_coarse_graph = processor.get_final_coarse_graph();
     const auto& final_groups = processor.get_final_groups();
 
@@ -66,7 +66,7 @@ void check_partitioning(const Graph_t& dag, const OrbitGraphProcessor<Graph_t>&
 //     graph_t dag;
 //     file_reader::readComputationalDagDotFormat("", dag);
 
-//     OrbitGraphProcessor<graph_t> processor(2); // Using a symmetry threshold of 2
+//     OrbitGraphProcessor<graph_t, graph_t> processor(2); // Using a symmetry threshold of 2
 //     processor.discover_isomorphic_groups(dag);
 
 //     const auto& coarse_graph = processor.get_coarse_graph();
@@ -118,7 +118,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_SimpleMerge) {
 
     // Initial orbits: {0, 2} and {1, 3}. Coarse graph: 0 -> 1
     // With threshold 2, these should be merged.
-    OrbitGraphProcessor<graph_t> processor(2);
+    OrbitGraphProcessor<graph_t, graph_t> processor(2);
     processor.discover_isomorphic_groups(dag);
 
     const auto& final_coarse_graph = processor.get_final_coarse_graph();
@@ -155,7 +155,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_ForkJoinNoMerge) {
     // Initial orbits: {0}, {1,2}, {3}. Coarse graph: 0 -> 1 -> 2
     // Merging 0 and 1 would result in a group of size 1 ({0,1,2}), which is not viable (threshold 2).
     // Merging 1 and 2 would also result in a group of size 1 ({1,2,3}), not viable.
-    OrbitGraphProcessor<graph_t> processor(2);
+    OrbitGraphProcessor<graph_t, graph_t> processor(2);
     processor.discover_isomorphic_groups(dag);
 
     const auto& final_coarse_graph = processor.get_final_coarse_graph();
@@ -189,7 +189,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_PartitionCheck_MediumGraph) {
     BOOST_REQUIRE_GT(dag.num_vertices(), 0);
 
     // Use a higher threshold to encourage more merging on this larger graph
-    OrbitGraphProcessor<graph_t> processor(4);
+    OrbitGraphProcessor<graph_t, graph_t> processor(4);
     processor.discover_isomorphic_groups(dag);
 
     // The main purpose of this test is to ensure the output is a valid partition.
@@ -203,7 +203,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_MultiPipelineMerge) {
     const auto dag = construct_multi_pipeline_dag<graph_t>(5, 4);
     BOOST_REQUIRE_EQUAL(dag.num_vertices(), 20);
 
-    OrbitGraphProcessor<graph_t> processor(5); // Set threshold to match pipeline count
+    OrbitGraphProcessor<graph_t, graph_t> processor(5); // Set threshold to match pipeline count
     processor.discover_isomorphic_groups(dag);
 
     const auto& final_coarse_graph = processor.get_final_coarse_graph();
@@ -230,7 +230,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_LadderNoMerge) {
     const auto dag = construct_ladder_dag<graph_t>(10);
     BOOST_REQUIRE_EQUAL(dag.num_vertices(), 22);
 
-    OrbitGraphProcessor<graph_t> processor(2);
+    OrbitGraphProcessor<graph_t, graph_t> processor(2);
     processor.discover_isomorphic_groups(dag);
 
     const auto& initial_coarse_graph = processor.get_coarse_graph();
@@ -249,7 +249,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_AsymmetricNoMerge) {
     const auto dag = construct_asymmetric_dag<graph_t>(30);
     BOOST_REQUIRE_EQUAL(dag.num_vertices(), 30);
 
-    OrbitGraphProcessor<graph_t> processor(2);
+    OrbitGraphProcessor<graph_t, graph_t> processor(2);
     processor.discover_isomorphic_groups(dag);
 
     const auto& final_coarse_graph = processor.get_final_coarse_graph();
@@ -270,7 +270,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_BinaryTreeNoMerge) {
     const auto dag = construct_binary_out_tree<graph_t>(4);
     BOOST_REQUIRE_EQUAL(dag.num_vertices(), (1 << 5) - 1);
 
-    OrbitGraphProcessor<graph_t> processor(2);
+    OrbitGraphProcessor<graph_t, graph_t> processor(2);
     processor.discover_isomorphic_groups(dag);
 
     const auto& final_coarse_graph = processor.get_final_coarse_graph();
@@ -289,7 +289,7 @@ BOOST_AUTO_TEST_CASE(OrbitGraphProcessor_ButterflyMerge) {
     const auto dag = construct_butterfly_dag<graph_t>(3);
     BOOST_REQUIRE_EQUAL(dag.num_vertices(), (3 + 1) * 8);
 
-    OrbitGraphProcessor<graph_t> processor(16); // Threshold is larger than any group size
+    OrbitGraphProcessor<graph_t, graph_t> processor(16); // Threshold is larger than any group size
     processor.discover_isomorphic_groups(dag);
 
     const auto& final_coarse_graph = processor.get_final_coarse_graph();