hacky eft change

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/IsomorphicSubgraphScheduler.hpp

@@ -39,7 +39,7 @@ class IsomorphicSubgraphScheduler {
 
     private:
 
-    static constexpr bool verbose = false;    
+    static constexpr bool verbose = true;    
     const HashComputer<vertex_idx_t<Graph_t>>* hash_computer_;
     size_t symmetry_ = 2;
     Scheduler<Constr_Graph_t> * bsp_scheduler_;
@@ -90,7 +90,7 @@ class IsomorphicSubgraphScheduler {
         std::vector<bool> was_trimmed(isomorphic_groups.size(), false);
         trim_subgraph_groups(isomorphic_groups, instance, was_trimmed); // Apply trimming and record which groups were affected
 
-        auto input = prepare_subgraph_scheduling_input(instance, isomorphic_groups);
+        auto input = prepare_subgraph_scheduling_input(instance, isomorphic_groups, was_trimmed);
 
         EftSubgraphScheduler<Constr_Graph_t> etf_scheduler;
         SubgraphSchedule subgraph_schedule = etf_scheduler.run(input.instance, input.multiplicities, input.required_proc_types, input.max_num_processors);
@@ -208,14 +208,15 @@ class IsomorphicSubgraphScheduler {
                 continue;
             }
 
-            const unsigned gcd = std::gcd(group_size, effective_min_proc_type_count);
+            unsigned gcd = std::gcd(group_size, effective_min_proc_type_count);
 
             if (gcd < group_size) {
                 if constexpr (verbose) {
                     std::cout << "  -> Trimming group " << group_idx << ". GCD(" << group_size << ", " << effective_min_proc_type_count 
                               << ") = " << gcd << ". Merging " << group_size / gcd << " subgraphs at a time." << std::endl;
                 }
 
+                gcd = 1;
                 was_trimmed[group_idx] = true;
                 const unsigned merge_size = group_size / gcd;
                 std::vector<std::vector<vertex_idx_t<Graph_t>>> new_subgraphs;
@@ -249,7 +250,8 @@ class IsomorphicSubgraphScheduler {
 
     subgraph_scheduler_input<Graph_t, Constr_Graph_t> prepare_subgraph_scheduling_input(
         const BspInstance<Graph_t>& original_instance,
-        const std::vector<typename OrbitGraphProcessor<Graph_t, Constr_Graph_t>::Group>& isomorphic_groups) {
+        const std::vector<typename OrbitGraphProcessor<Graph_t, Constr_Graph_t>::Group>& isomorphic_groups,
+        const std::vector<bool>& was_trimmed) {
 
         subgraph_scheduler_input<Graph_t, Constr_Graph_t> result;
         result.instance.setArchitecture(original_instance.getArchitecture());
@@ -264,7 +266,7 @@ class IsomorphicSubgraphScheduler {
         for (const auto &group : isomorphic_groups) {
 
             result.max_num_processors[coarse_node_idx] = static_cast<unsigned>(group.size() * group.subgraphs[0].size());
-            result.multiplicities[coarse_node_idx] = static_cast<unsigned>(group.subgraphs.size());
+            result.multiplicities[coarse_node_idx] = was_trimmed[coarse_node_idx] ? 1 : static_cast<unsigned>(group.subgraphs.size());
             result.required_proc_types[coarse_node_idx].assign(num_proc_types, 0);
 
             for (const auto &subgraph : group.subgraphs) {

include/osp/dag_divider/isomorphism_divider/TrimmedGroupScheduler.hpp

@@ -21,11 +21,14 @@ limitations under the License.
 #include "osp/bsp/scheduler/Scheduler.hpp"
 #include "osp/graph_algorithms/subgraph_algorithms.hpp"
 #include "osp/graph_algorithms/computational_dag_util.hpp"
+#include <iostream>
 #include <numeric>
 
 namespace osp {
 
 /**
+ * @brief A scheduler for a single trimmed group, which consists of multiple isomorphic connected components.
+ *
  * @class TrimmedGroupScheduler
  * @brief A scheduler for a single trimmed group, which consists of multiple isomorphic connected components.
  *
@@ -39,6 +42,8 @@ class TrimmedGroupScheduler : public Scheduler<Constr_Graph_t> {
     Scheduler<Constr_Graph_t> *sub_scheduler;
     unsigned min_non_zero_procs_;
 
+    static constexpr bool verbose = true;
+
   public:
     TrimmedGroupScheduler(Scheduler<Constr_Graph_t> &scheduler, unsigned min_non_zero_procs)
         : sub_scheduler(&scheduler), min_non_zero_procs_(min_non_zero_procs) {}
@@ -59,6 +64,11 @@ class TrimmedGroupScheduler : public Scheduler<Constr_Graph_t> {
             return RETURN_STATUS::OSP_SUCCESS;
         }
 
+        if constexpr (verbose) {
+            std::cout << "  [TrimmedGroupScheduler] min_non_zero_procs: " << min_non_zero_procs_
+                      << ", num_components: " << num_components << std::endl;
+        }
+
         // Group vertices by component.
         std::vector<std::vector<vertex_idx_t<Constr_Graph_t>>> components_vertices(num_components);
         for (vertex_idx_t<Constr_Graph_t> v = 0; v < dag.num_vertices(); ++v) {
@@ -97,6 +107,14 @@ class TrimmedGroupScheduler : public Scheduler<Constr_Graph_t> {
             mem_weights[type_idx] = static_cast<v_memw_t<Constr_Graph_t>>(arch.maxMemoryBoundProcType(type_idx));
         }
 
+        if constexpr (verbose) {
+            std::cout << "  [TrimmedGroupScheduler] Sub-problem processor counts per type: ";
+            for (size_t type_idx = 0; type_idx < sub_proc_counts.size(); ++type_idx) {
+                std::cout << "T" << type_idx << ":" << sub_proc_counts[type_idx] << " ";
+            }
+            std::cout << std::endl;
+        }
+
         // Create the sub-architecture for one sub-problem.
         BspArchitecture<Constr_Graph_t> sub_arch(arch);  
         sub_arch.set_processors_consequ_types(sub_proc_counts, mem_weights);