revision trim reverse

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/IsomorphicSubgraphScheduler.hpp

@@ -71,8 +71,6 @@ class IsomorphicSubgraphScheduler {
 
     std::vector<vertex_idx_t<Graph_t>> compute_partition(const BspInstance<Graph_t>& instance) {
         OrbitGraphProcessor<Graph_t, Constr_Graph_t> orbit_processor(symmetry_);
-        orbit_processor.set_work_threshold(work_threshold_);
-        orbit_processor.setMergeDifferentNodeTypes(merge_different_node_types);
 
         std::unique_ptr<HashComputer<vertex_idx_t<Graph_t>>> local_hasher;      
         if (!hash_computer_) {
@@ -84,26 +82,37 @@ class IsomorphicSubgraphScheduler {
 
         auto isomorphic_groups = orbit_processor.get_final_groups();
 
-        trim_subgraph_groups(isomorphic_groups, instance); // Apply trimming based on dynamic min_proc_type_count
+        if (plot_dot_graphs_) {
+            DotFileWriter writer;
+            writer.write_colored_graph("isomorphic_groups.dot", instance.getComputationalDag(), orbit_processor.get_final_contraction_map());
+            writer.write_colored_graph("orbits_colored.dot", instance.getComputationalDag(), orbit_processor.get_contraction_map());
+        }
+
+        const unsigned min_proc_type_count = use_max_group_size_ ? max_group_size_ : instance.getArchitecture().getMinProcessorTypeCount();
+        trim_subgraph_groups(isomorphic_groups, min_proc_type_count);
 
         auto input = prepare_subgraph_scheduling_input(instance, isomorphic_groups);
 
+        if (plot_dot_graphs_) {
+            DotFileWriter writer;
+            writer.write_graph("iso_groups_contracted.dot", input.instance.getComputationalDag());
+        }
+
         EftSubgraphScheduler<Constr_Graph_t> etf_scheduler;
         SubgraphSchedule subgraph_schedule = etf_scheduler.run(input.instance, input.multiplicities, input.required_proc_types);
 
         std::vector<vertex_idx_t<Graph_t>> partition(instance.numberOfVertices(), 0);
+
         schedule_isomorphic_group(instance, isomorphic_groups, subgraph_schedule, partition);
 
         if (plot_dot_graphs_) {
             DotFileWriter writer;
-            writer.write_colored_graph("isomorphic_groups.dot", instance.getComputationalDag(), orbit_processor.get_final_contraction_map());
-            writer.write_colored_graph("orbits_colored.dot", instance.getComputationalDag(), orbit_processor.get_contraction_map());
-            writer.write_graph("iso_groups_contracted.dot", input.instance.getComputationalDag());
             writer.write_colored_graph("graph_partition.dot", instance.getComputationalDag(), partition);
             Constr_Graph_t corase_graph;
             coarser_util::construct_coarse_dag(instance.getComputationalDag(), corase_graph, partition);
             writer.write_graph("block_graph.dot", corase_graph);
         }
+
         return partition;
     }
 
@@ -117,125 +126,35 @@ class IsomorphicSubgraphScheduler {
     };
 
     void trim_subgraph_groups(std::vector<typename OrbitGraphProcessor<Graph_t, Constr_Graph_t>::Group>& isomorphic_groups,
-                              const BspInstance<Graph_t>& instance) {
-        if constexpr (verbose) {
-            std::cout << "\n--- Trimming Isomorphic Subgraph Groups ---" << std::endl;
-        }
-        size_t group_idx_debug = 0;
-        for (auto& group : isomorphic_groups) {
-            const unsigned group_size = static_cast<unsigned>(group.size());
-            if (group_size <= 1)
-                continue;
-
-            unsigned effective_min_proc_type_count = 0;
+                              const unsigned min_proc_type_count) {
+        if (min_proc_type_count <= 1) return;
 
-            if (use_max_group_size_) {
-                if constexpr (verbose) {
-                    std::cout << "Group " << group_idx_debug << " (size " << group_size << "): Using fixed max_group_size_ = " << max_group_size_ << " for trimming." << std::endl;
-                }
-                effective_min_proc_type_count = max_group_size_;
-            } else {
-                // Determine if the group consists of a single node type
-                bool is_single_type_group = true;
-                v_type_t<Graph_t> common_node_type = 0;
-
-                if constexpr (has_typed_vertices_v<Graph_t>) {
-                    if (!group.subgraphs.empty() && !group.subgraphs[0].empty()) {
-                        common_node_type = instance.getComputationalDag().vertex_type(group.subgraphs[0][0]);
-                        const auto& rep_subgraph = group.subgraphs[0];   
-                        for (const auto& vertex : rep_subgraph) {
-                            if (instance.getComputationalDag().vertex_type(vertex) != common_node_type) {
-                                is_single_type_group = false;
-                                break;
-                            }
-                        }
-                    } else {
-                        is_single_type_group = false; 
-                    }
-                } else {
-                    is_single_type_group = false; 
-                }
-
-                if (is_single_type_group) {
-                    // Dynamically determine min_proc_type_count based on compatible processors for this type
-                    unsigned min_compatible_processors = std::numeric_limits<unsigned>::max();
-                    const auto& proc_type_counts = instance.getArchitecture().getProcessorTypeCount();
-
-                    bool found_compatible_processor = false;
-                    for (unsigned proc_type_idx = 0; proc_type_idx < proc_type_counts.size(); ++proc_type_idx) {
-                        if (instance.isCompatibleType(common_node_type, proc_type_idx)) {
-                            min_compatible_processors = std::min(min_compatible_processors, proc_type_counts[proc_type_idx]);
-                            found_compatible_processor = true;
-                        }
-                    }
-                    if (found_compatible_processor) {
-                        if constexpr (verbose) {
-                            std::cout << "Group " << group_idx_debug << " (size " << group_size << "): Single node type (" << common_node_type 
-                                      << "). Min compatible processors: " << min_compatible_processors << "." << std::endl;
-                        }
-                        effective_min_proc_type_count = min_compatible_processors;
-                    } else {
-                        if constexpr (verbose) {
-                            std::cout << "Group " << group_idx_debug << " (size " << group_size << "): Single node type (" << common_node_type 
-                                      << ") but no compatible processors found. Disabling trimming." << std::endl;
-                        }
-                        // If no compatible processors found for this type, effectively disable trimming for this group.
-                        effective_min_proc_type_count = 1;
-                    }
-                } else {
-                    // Fallback to a default min_proc_type_count if not a single-type group or no typed vertices.
-                    effective_min_proc_type_count = instance.getArchitecture().getMinProcessorTypeCount();
-                    if constexpr (verbose) {
-                        std::cout << "Group " << group_idx_debug << " (size " << group_size << "): Multi-type or untyped group. Using default min_proc_type_count: " << effective_min_proc_type_count << "." << std::endl;
-                    }
-                }
-            }
-
-            // Ensure effective_min_proc_type_count is at least 1 for valid GCD calculation.
-            if (effective_min_proc_type_count == 0) {
-                effective_min_proc_type_count = 1;
-            }
-
-            // If effective_min_proc_type_count is 1, no trimming is needed as gcd(X, 1) = 1.
-            if (effective_min_proc_type_count <= 1) {
+        for (auto& group : isomorphic_groups) {
+            const unsigned group_size = static_cast<unsigned>(group.subgraphs.size());
+            if (group_size == 0)
                 continue;
-            }
-
-            const unsigned gcd = std::gcd(group_size, effective_min_proc_type_count);
+            const unsigned gcd = std::gcd(group_size, min_proc_type_count);
 
             if (gcd < group_size) {
-                if constexpr (verbose) {
-                    std::cout << "  -> Trimming group " << group_idx_debug << ". GCD(" << group_size << ", " << effective_min_proc_type_count 
-                              << ") = " << gcd << ". Merging " << group_size / gcd << " subgraphs at a time." << std::endl;
-                }
-
                 const unsigned merge_size = group_size / gcd;
                 std::vector<std::vector<vertex_idx_t<Graph_t>>> new_subgraphs;
                 new_subgraphs.reserve(gcd);
 
                 size_t original_sg_cursor = 0;
 
                 for (unsigned j = 0; j < gcd; ++j) {
-                    std::vector<vertex_idx_t<Graph_t>> merged_sg_vertices;
-                    // Estimate capacity for efficiency. Assuming subgraphs have similar sizes.
-                    if (!group.subgraphs.empty()) {
-                        merged_sg_vertices.reserve(group.subgraphs[0].size() * merge_size);
-                    }
+                    std::vector<vertex_idx_t<Graph_t>> merged_sg_vertices = group.subgraphs[original_sg_cursor];
+                    original_sg_cursor++;
 
-                    for (unsigned k = 0; k < merge_size; ++k) {
+                    for (unsigned k = 1; k < merge_size; ++k) {
                         const auto& sg_to_merge_vertices = group.subgraphs[original_sg_cursor];
                         original_sg_cursor++;
                         merged_sg_vertices.insert(merged_sg_vertices.end(), sg_to_merge_vertices.begin(), sg_to_merge_vertices.end());
                     }
                     new_subgraphs.push_back(std::move(merged_sg_vertices));
                 }
                 group.subgraphs = std::move(new_subgraphs);
-            } else {
-                if constexpr (verbose) {
-                    std::cout << "  -> No trim needed for group " << group_idx_debug << "." << std::endl;
-                }
             }
-            group_idx_debug++;
        }
     }
 

include/osp/dag_divider/isomorphism_divider/OrbitGraphProcessor.hpp

@@ -511,14 +511,6 @@ class OrbitGraphProcessor {
 
         Constr_Graph_t induced_subgraph;
 
-        // create_induced_subgraph(original_dag, induced_subgraph, all_nodes);
-        // std::vector<VertexType> components; // local -> component_id
-        // size_t num_components = compute_weakly_connected_components(induced_subgraph, components);
-        // out_new_subgraphs.assign(num_components, std::vector<VertexType>());
-        // for (VertexType i = 0; i < induced_subgraph.num_vertices(); ++i) {
-        //     out_new_subgraphs[components[i]].push_back(all_nodes[i]);
-        // }
-
         auto map = create_induced_subgraph_map(original_dag, induced_subgraph, all_nodes);
         std::vector<VertexType> components; // local -> component_id
         size_t num_components = compute_weakly_connected_components(induced_subgraph, components);

tests/isomorphic_subgraph_scheduler.cpp

@@ -41,8 +41,8 @@ class IsomorphicSubgraphSchedulerTester : public IsomorphicSubgraphScheduler<Gra
     using IsomorphicSubgraphScheduler<Graph_t, Constr_Graph_t>::IsomorphicSubgraphScheduler;
 
     void test_trim_subgraph_groups(std::vector<group_t>& isomorphic_groups,
-                                   const BspInstance<Graph_t>& instance) {
-        this->trim_subgraph_groups(isomorphic_groups, instance);
+                                   const unsigned min_proc_type_count) {
+        this->trim_subgraph_groups(isomorphic_groups, min_proc_type_count);
     }
 
     void test_schedule_isomorphic_group(const BspInstance<Graph_t> &instance,
@@ -71,20 +71,11 @@ BOOST_AUTO_TEST_CASE(TrimSubgraphGroupsTest_NoTrim) {
     GreedyBspScheduler<constr_graph_t> greedy_scheduler;
     IsomorphicSubgraphSchedulerTester<graph_t, constr_graph_t> tester(greedy_scheduler);
 
-    BspInstance<graph_t> instance;
-    auto& dag = instance.getComputationalDag();
-    dag.add_vertex(1, 1, 1, 0); // 0
-    dag.add_vertex(1, 1, 1, 0); // 1
-    dag.add_vertex(1, 1, 1, 0); // 2
-    dag.add_vertex(1, 1, 1, 0); // 3
-    instance.getArchitecture().setProcessorsWithTypes({0,0,0,0,0,0,0,0}); // 8 processors of type 0
-    instance.setDiagonalCompatibilityMatrix(1);
-
     // A single group with 4 subgraphs, each with 1 node.
     std::vector<group_t> iso_groups = { group_t{ { {0}, {1}, {2}, {3} } } };
 
-    // Group size (4) is a divisor of processor count for type 0 (8), so no trim.
-    tester.test_trim_subgraph_groups(iso_groups, instance);
+    // Group size (4) is a divisor of min_proc_type_count (8), so no trim.
+    tester.test_trim_subgraph_groups(iso_groups, 8);
 
     BOOST_CHECK_EQUAL(iso_groups.size(), 1);
     BOOST_CHECK_EQUAL(iso_groups[0].subgraphs.size(), 4); // Still 4 subgraphs in the group
@@ -94,25 +85,14 @@ BOOST_AUTO_TEST_CASE(TrimSubgraphGroupsTest_WithTrim) {
     GreedyBspScheduler<constr_graph_t> greedy_scheduler;
     IsomorphicSubgraphSchedulerTester<graph_t, constr_graph_t> tester(greedy_scheduler);
 
-    BspInstance<graph_t> instance;
-    auto& dag = instance.getComputationalDag();
-    dag.add_vertex(10, 1, 1, 0); // 0
-    dag.add_vertex(10, 1, 1, 0); // 1
-    dag.add_vertex(10, 1, 1, 0); // 2
-    dag.add_vertex(10, 1, 1, 0); // 3
-    dag.add_vertex(10, 1, 1, 0); // 4
-    dag.add_vertex(10, 1, 1, 0); // 5
-    instance.getArchitecture().setProcessorsWithTypes({0,0,0,0,0,0,0,0}); // 8 processors of type 0
-    instance.setDiagonalCompatibilityMatrix(1);
-
     // 6 subgraphs, each with 1 node and work weight 10.
     std::vector<group_t> iso_groups = { group_t{ { {0}, {1}, {2}, {3}, {4}, {5} } } };
 
-    // Group size (6) is not a divisor of processor count for type 0 (8).
+    // Group size (6) is not a divisor of min_proc_type_count (8).
     // gcd(6, 8) = 2.
     // merge_size = 6 / 2 = 3.
     // The 6 subgraphs should be merged into 2 new subgraphs, each containing 3 old ones.
-    tester.test_trim_subgraph_groups(iso_groups, instance);
+    tester.test_trim_subgraph_groups(iso_groups, 8);
 
     BOOST_CHECK_EQUAL(iso_groups.size(), 1);
     BOOST_REQUIRE_EQUAL(iso_groups[0].subgraphs.size(), 2); // Group now contains 2 merged subgraphs
@@ -134,20 +114,6 @@ BOOST_AUTO_TEST_CASE(TrimSubgraphGroupsTest_MultipleGroups) {
     GreedyBspScheduler<constr_graph_t> greedy_scheduler;
     IsomorphicSubgraphSchedulerTester<graph_t, constr_graph_t> tester(greedy_scheduler);
 
-    BspInstance<graph_t> instance;
-    auto& dag = instance.getComputationalDag();
-    for (int i = 0; i < 6; ++i) dag.add_vertex(1,1,1,0); // 0-5
-    for (int i = 0; i < 3; ++i) dag.add_vertex(1,1,1,0); // 6-8, but we will use 10-12 in test
-    for (int i = 0; i < 2; ++i) dag.add_vertex(1,1,1,0); // 9-10
-    for (int i = 0; i < 2; ++i) dag.add_vertex(1,1,1,0); // 11-12
-    for (int i = 0; i < 8; ++i) dag.add_vertex(1,1,1,0); // 13-20
-    for (int i = 0; i < 5; ++i) dag.add_vertex(1,1,1,0); // 21-25
-    // Make sure all vertices used in iso_groups exist.
-    // All are type 0.
-
-    instance.getArchitecture().setProcessorsWithTypes({0,0,0,0,0,0,0,0,0}); // 9 processors of type 0
-    instance.setDiagonalCompatibilityMatrix(1);
-
     // Group 1: size 6. gcd(6, 9) = 3. merge_size = 6/3 = 2. -> 3 subgraphs of size 2.
     // Group 2: size 3. gcd(3, 9) = 3. merge_size = 3/3 = 1. -> no trim.
     // Group 3: size 5. gcd(5, 9) = 1. merge_size = 5/1 = 5. -> 1 subgraph of size 5.
@@ -157,7 +123,7 @@ BOOST_AUTO_TEST_CASE(TrimSubgraphGroupsTest_MultipleGroups) {
         group_t{ { {20}, {21}, {22}, {23}, {24} } }  // Group 3
     };
 
-    tester.test_trim_subgraph_groups(iso_groups, instance);
+    tester.test_trim_subgraph_groups(iso_groups, 9);
 
     BOOST_REQUIRE_EQUAL(iso_groups.size(), 3);