this constexpr fix (#35)

raphael-s-steiner · web-flow · commit 5c3a2a277f00 · 2025-11-12T16:52:47.000+01:00
diff --git a/include/osp/bsp/scheduler/LocalSearch/KernighanLin_v2/kl_improver.hpp b/include/osp/bsp/scheduler/LocalSearch/KernighanLin_v2/kl_improver.hpp
@@ -201,7 +201,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
     
     inline void process_other_steps_best_move(const unsigned idx, const unsigned node_step, const VertexType& node, const cost_t affinity_current_proc_step, cost_t& max_gain, unsigned& max_proc, unsigned& max_step, const std::vector<std::vector<cost_t>> &affinity_table_node) const {    
         for (const unsigned p : proc_range.compatible_processors_vertex(node)) {
-            if constexpr (active_schedule.use_memory_constraint) {
+            if constexpr (active_schedule_t::use_memory_constraint) {
                 if( not active_schedule.memory_constraint.can_move(node, p, node_step + idx - window_size)) continue;                
             }
 
@@ -236,7 +236,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                 if (proc == node_proc)
                     continue;
 
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if( not active_schedule.memory_constraint.can_move(node, proc, node_step + idx - window_size)) continue;                
                 }
 
@@ -610,7 +610,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                     std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;
                     std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;
                 }
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if ( not active_schedule.memory_constraint.satisfied_memory_constraint())
                         std::cout << "memory constraint not satisfied" << std::endl;
                 }
@@ -647,7 +647,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                     std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;
                     std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;
                 }
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if ( not active_schedule.memory_constraint.satisfied_memory_constraint())
                         std::cout << "memory constraint not satisfied" << std::endl;
                 }
@@ -661,7 +661,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                     std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;
                     std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;
                 }
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if ( not active_schedule.memory_constraint.satisfied_memory_constraint())
                         std::cout << "memory constraint not satisfied" << std::endl;
                 }
@@ -736,7 +736,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                     std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;
                     std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;
                 }
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if ( not active_schedule.memory_constraint.satisfied_memory_constraint())
                         std::cout << "memory constraint not satisfied" << std::endl;
                 }
@@ -774,7 +774,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                 std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;
                 std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;
             }
-            if constexpr (active_schedule.use_memory_constraint) {
+            if constexpr (active_schedule_t::use_memory_constraint) {
                 if ( not active_schedule.memory_constraint.satisfied_memory_constraint())
                     std::cout << "memory constraint not satisfied" << std::endl;
             }
@@ -973,7 +973,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {
                     std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;
                     std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;
                 }
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if ( not active_schedule.memory_constraint.satisfied_memory_constraint())
                      std::cout << "memory constraint not satisfied" << std::endl;
                 }
@@ -1442,7 +1442,7 @@ void kl_improver<Graph_t, comm_cost_function_t, MemoryConstraint_t, window_size,
     if ((max_step == step) && (max_proc == proc)) {
         recompute_node_max_gain(node, affinity_table, thread_data);
     } else {
-        if constexpr (active_schedule.use_memory_constraint) {
+        if constexpr (active_schedule_t::use_memory_constraint) {
             if( not active_schedule.memory_constraint.can_move(node, proc, step)) return;                
         }
         const unsigned idx = rel_step_idx(node_step, step);
@@ -1481,7 +1481,7 @@ void kl_improver<Graph_t, comm_cost_function_t, MemoryConstraint_t, window_size,
         if (node_step != step) {
             const unsigned idx = rel_step_idx(node_step, step);
             for (const unsigned p : proc_range.compatible_processors_vertex(node)) {   
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if( not active_schedule.memory_constraint.can_move(node, p, step)) continue;                
                 }
                 const cost_t gain = affinity_table[node][node_proc][window_size] - affinity_table[node][p][idx];                    
@@ -1495,7 +1495,7 @@ void kl_improver<Graph_t, comm_cost_function_t, MemoryConstraint_t, window_size,
             for (const unsigned proc : proc_range.compatible_processors_vertex(node)) { 
                 if (proc == node_proc)
                     continue;
-                if constexpr (active_schedule.use_memory_constraint) {
+                if constexpr (active_schedule_t::use_memory_constraint) {
                     if( not active_schedule.memory_constraint.can_move(node, proc, step)) continue;                
                 }
                 const cost_t gain = affinity_table[node][node_proc][window_size] - affinity_table[node][proc][window_size];

Original file line number	Diff line number	Diff line change
`@@ -201,7 +201,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`201`	`201`
`202`	`202`	`inline void process_other_steps_best_move(const unsigned idx, const unsigned node_step, const VertexType& node, const cost_t affinity_current_proc_step, cost_t& max_gain, unsigned& max_proc, unsigned& max_step, const std::vector<std::vector<cost_t>> &affinity_table_node) const {`
`203`	`203`	`for (const unsigned p : proc_range.compatible_processors_vertex(node)) {`
`204`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`204`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`205`	`205`	`if( not active_schedule.memory_constraint.can_move(node, p, node_step + idx - window_size)) continue;`
`206`	`206`	`}`
`207`	`207`
`@@ -236,7 +236,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`236`	`236`	`if (proc == node_proc)`
`237`	`237`	`continue;`
`238`	`238`
`239`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`239`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`240`	`240`	`if( not active_schedule.memory_constraint.can_move(node, proc, node_step + idx - window_size)) continue;`
`241`	`241`	`}`
`242`	`242`
`@@ -610,7 +610,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`610`	`610`	`std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;`
`611`	`611`	`std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;`
`612`	`612`	`}`
`613`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`613`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`614`	`614`	`if ( not active_schedule.memory_constraint.satisfied_memory_constraint())`
`615`	`615`	`std::cout << "memory constraint not satisfied" << std::endl;`
`616`	`616`	`}`
`@@ -647,7 +647,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`647`	`647`	`std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;`
`648`	`648`	`std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;`
`649`	`649`	`}`
`650`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`650`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`651`	`651`	`if ( not active_schedule.memory_constraint.satisfied_memory_constraint())`
`652`	`652`	`std::cout << "memory constraint not satisfied" << std::endl;`
`653`	`653`	`}`
`@@ -661,7 +661,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`661`	`661`	`std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;`
`662`	`662`	`std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;`
`663`	`663`	`}`
`664`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`664`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`665`	`665`	`if ( not active_schedule.memory_constraint.satisfied_memory_constraint())`
`666`	`666`	`std::cout << "memory constraint not satisfied" << std::endl;`
`667`	`667`	`}`
`@@ -736,7 +736,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`736`	`736`	`std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;`
`737`	`737`	`std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;`
`738`	`738`	`}`
`739`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`739`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`740`	`740`	`if ( not active_schedule.memory_constraint.satisfied_memory_constraint())`
`741`	`741`	`std::cout << "memory constraint not satisfied" << std::endl;`
`742`	`742`	`}`
`@@ -774,7 +774,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`774`	`774`	`std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;`
`775`	`775`	`std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;`
`776`	`776`	`}`
`777`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`777`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`778`	`778`	`if ( not active_schedule.memory_constraint.satisfied_memory_constraint())`
`779`	`779`	`std::cout << "memory constraint not satisfied" << std::endl;`
`780`	`780`	`}`
`@@ -973,7 +973,7 @@ class kl_improver : public ImprovementScheduler<Graph_t> {`
`973`	`973`	`std::cout << "computed cost: " << comm_cost_f.compute_schedule_cost_test() << ", current cost: " << thread_data.active_schedule_data.cost << std::endl;`
`974`	`974`	`std::cout << ">>>>>>>>>>>>>>>>>>>>>> compute cost not equal to new cost <<<<<<<<<<<<<<<<<<<<" << std::endl;`
`975`	`975`	`}`
`976`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`976`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`977`	`977`	`if ( not active_schedule.memory_constraint.satisfied_memory_constraint())`
`978`	`978`	`std::cout << "memory constraint not satisfied" << std::endl;`
`979`	`979`	`}`
`@@ -1442,7 +1442,7 @@ void kl_improver<Graph_t, comm_cost_function_t, MemoryConstraint_t, window_size,`
`1442`	`1442`	`if ((max_step == step) && (max_proc == proc)) {`
`1443`	`1443`	`recompute_node_max_gain(node, affinity_table, thread_data);`
`1444`	`1444`	`} else {`
`1445`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`1445`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`1446`	`1446`	`if( not active_schedule.memory_constraint.can_move(node, proc, step)) return;`
`1447`	`1447`	`}`
`1448`	`1448`	`const unsigned idx = rel_step_idx(node_step, step);`
`@@ -1481,7 +1481,7 @@ void kl_improver<Graph_t, comm_cost_function_t, MemoryConstraint_t, window_size,`
`1481`	`1481`	`if (node_step != step) {`
`1482`	`1482`	`const unsigned idx = rel_step_idx(node_step, step);`
`1483`	`1483`	`for (const unsigned p : proc_range.compatible_processors_vertex(node)) {`
`1484`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`1484`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`1485`	`1485`	`if( not active_schedule.memory_constraint.can_move(node, p, step)) continue;`
`1486`	`1486`	`}`
`1487`	`1487`	`const cost_t gain = affinity_table[node][node_proc][window_size] - affinity_table[node][p][idx];`
`@@ -1495,7 +1495,7 @@ void kl_improver<Graph_t, comm_cost_function_t, MemoryConstraint_t, window_size,`
`1495`	`1495`	`for (const unsigned proc : proc_range.compatible_processors_vertex(node)) {`
`1496`	`1496`	`if (proc == node_proc)`
`1497`	`1497`	`continue;`
`1498`		`- if constexpr (active_schedule.use_memory_constraint) {`
	`1498`	`+ if constexpr (active_schedule_t::use_memory_constraint) {`
`1499`	`1499`	`if( not active_schedule.memory_constraint.can_move(node, proc, step)) continue;`
`1500`	`1500`	`}`
`1501`	`1501`	`const cost_t gain = affinity_table[node][node_proc][window_size] - affinity_table[node][proc][window_size];`