FM fixes and recursive FM

Author: papp-pal-andras

include/osp/partitioning/model/hypergraph.hpp

@@ -71,6 +71,8 @@ class Hypergraph {
     template<typename Graph_t>
     void convert_from_cdag_as_hyperdag(const Graph_t& dag);
 
+    Hypergraph<index_type, workw_type, memw_type, commw_type> create_induced_hypergraph(const std::vector<bool>& include) const;
+
   private:
     index_type Num_vertices = 0, Num_hyperedges = 0, Num_pins = 0;
 
@@ -247,4 +249,41 @@ void Hypergraph<index_type, workw_type, memw_type, commw_type>::convert_from_cda
     }
 }
 
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
+Hypergraph<index_type, workw_type, memw_type, commw_type> Hypergraph<index_type, workw_type, memw_type, commw_type>::create_induced_hypergraph(const std::vector<bool>& include) const
+{
+    if(include.size() != Num_vertices)
+        throw std::invalid_argument("Invalid Argument while extracting induced hypergraph: input bool array has incorrect size.");
+
+    std::vector<index_type> new_index(Num_vertices);
+    unsigned current_index = 0;
+    for(index_type node = 0; node < Num_vertices; ++node)
+        if(include[node])
+            new_index[node] = current_index++;
+    
+    Hypergraph<index_type, workw_type, memw_type, commw_type> hgraph(current_index, 0);
+    for(index_type node = 0; node < Num_vertices; ++node)
+        if(include[node])
+        {
+            hgraph.set_vertex_work_weight(new_index[node], vertex_work_weights[node]);
+            hgraph.set_vertex_memory_weight(new_index[node], vertex_memory_weights[node]);
+        }
+
+    for(index_type hyperedge = 0; hyperedge < Num_hyperedges; ++hyperedge)
+    {
+        unsigned nr_induced_pins = 0;
+        std::vector<index_type> induced_hyperedge;
+        for(index_type node : vertices_in_hyperedge[hyperedge])
+            if(include[node])
+            {
+                induced_hyperedge.push_back(new_index[node]);
+                ++nr_induced_pins;
+            }
+        
+        if(nr_induced_pins >= 2)
+            hgraph.add_hyperedge(induced_hyperedge, hyperedge_weights[hyperedge]);
+    }
+    return hgraph;
+}
+
 } // namespace osp

include/osp/partitioning/partitioners/generic_FM.hpp

@@ -31,10 +31,15 @@ class GenericFM {
     unsigned max_number_of_passes = 10;
     index_type max_nodes_in_part = 0;
 
+    // auxiliary for RecursiveFM
+    std::vector<index_type> getMaxNodesOnLevel(index_type nr_nodes, unsigned nr_parts) const;
+
   public:
 
     void ImprovePartitioning(Partitioning<index_type, workw_type, memw_type, commw_type>& partition);
 
+    void RecursiveFM(Partitioning<index_type, workw_type, memw_type, commw_type>& partition);
+
     inline unsigned getMaxNumberOfPasses() const { return max_number_of_passes; }
     inline void setMaxNumberOfPasses(unsigned passes_) { max_number_of_passes = passes_; }
     inline index_type getMaxNodesInPart() const { return max_nodes_in_part; }
@@ -81,6 +86,20 @@ void GenericFM<index_type, workw_type, memw_type, commw_type>::ImprovePartitioni
             if(partition.assignedPartition(node) == 0)
                 ++left_side;
 
+        if(left_side > max_nodes_in_part || Hgraph.num_vertices() - left_side > max_nodes_in_part)
+        {
+            if(pass_idx == 0)
+            {
+                std::cout<<"Error: initial partitioning of FM is not balanced."<<std::endl;
+                return;
+            }
+            else
+            {
+                std::cout<<"Error during FM: partitionming somehow became imbalanced."<<std::endl;
+                return;
+            }
+        }
+
         // Initialize gain values
         for(index_type hyperedge = 0; hyperedge < Hgraph.num_hyperedges(); ++hyperedge)
         {
@@ -96,6 +115,11 @@ void GenericFM<index_type, workw_type, memw_type, commw_type>::ImprovePartitioni
                     for(index_type node : Hgraph.get_vertices_in_hyperedge(hyperedge))
                         if(partition.assignedPartition(node) == part)
                             ++gain[node];
+
+                if(nr_nodes_in_hyperedge_on_side[hyperedge][part] == 0)
+                    for(index_type node : Hgraph.get_vertices_in_hyperedge(hyperedge))
+                        if(partition.assignedPartition(node) != part)
+                            --gain[node];
             }
         }
 
@@ -232,10 +256,113 @@ void GenericFM<index_type, workw_type, memw_type, commw_type>::ImprovePartitioni
         if(best_index == 0)
             break;
 
-        for(index_type node_idx = 0; node_idx < best_index; ++node_idx)
+        for(index_type node_idx = 0; node_idx < best_index && node_idx < static_cast<index_type>(moved_nodes.size()); ++node_idx)
             partition.setAssignedPartition(moved_nodes[node_idx], 1U-partition.assignedPartition(moved_nodes[node_idx]));
 
     }
 }
 
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
+void GenericFM<index_type, workw_type, memw_type, commw_type>::RecursiveFM(Partitioning<index_type, workw_type, memw_type, commw_type>& partition)
+{
+    const unsigned& nr_parts = partition.getInstance().getNumberOfPartitions();
+    const index_type& nr_nodes = partition.getInstance().getHypergraph().num_vertices();
+
+    using Hgraph = Hypergraph<index_type, workw_type, memw_type, commw_type>;
+
+    // Note: this is just a simple recursive heuristic for the case when the partitions are a small power of 2
+    if(nr_parts != 4 && nr_parts != 8 && nr_parts != 16 && nr_parts != 32)
+    {
+        std::cout << "Error: Recursive FM can only be used for 4, 8, 16 or 32 partitions currently." << std::endl;
+        return;
+    }
+
+    for(index_type node = 0; node < nr_nodes; ++node)
+        partition.setAssignedPartition(node, static_cast<unsigned>(node % 2));
+
+    if(max_nodes_in_part == 0) // if not initialized
+        max_nodes_in_part = static_cast<index_type>(ceil(static_cast<double>(nr_nodes) * static_cast<double>(partition.getInstance().getMaxWorkWeightPerPartition())
+                                         / static_cast<double>(partition.getInstance().getHypergraph().compute_total_vertex_work_weight()) ));
+
+    const std::vector<index_type> max_nodes_on_level = getMaxNodesOnLevel(nr_nodes, nr_parts);
+    
+    unsigned parts = 1;
+    unsigned level = 0;
+    std::vector<Hgraph> sub_hgraphs({partition.getInstance().getHypergraph()});
+    unsigned start_index = 0;
+
+    std::map<index_type, std::pair<unsigned, index_type> > node_to_new_hgraph_and_id;
+    std::map<std::pair<unsigned, index_type>, index_type> hgraph_and_id_to_old_idx;
+    for(index_type node = 0; node < nr_nodes; ++node)
+    {
+        node_to_new_hgraph_and_id[node] = std::make_pair(0, node);
+        hgraph_and_id_to_old_idx[std::make_pair(0, node)] = node;
+    }
+
+    while(parts < nr_parts)
+    {
+        unsigned end_idx = static_cast<unsigned>(sub_hgraphs.size());
+        for(unsigned sub_hgraph_index = start_index; sub_hgraph_index < end_idx; ++sub_hgraph_index)
+        {
+            const Hgraph& hgraph = sub_hgraphs[sub_hgraph_index];
+            PartitioningProblem instance(hgraph, 2);
+            Partitioning sub_partition(instance);
+            for(index_type node = 0; node < hgraph.num_vertices(); ++node)
+                sub_partition.setAssignedPartition(node, node%2);
+            
+            GenericFM sub_fm;
+            sub_fm.setMaxNodesInPart(max_nodes_on_level[level]);
+            //std::cout<<"Hgraph of size "<<hgraph.num_vertices()<<" split into two parts of at most "<<max_nodes_on_level[level]<<std::endl;
+            sub_fm.ImprovePartitioning(sub_partition);
+
+            std::vector<unsigned> current_idx(2, 0);
+            std::vector<std::vector<bool> > part_indicator(2, std::vector<bool>(hgraph.num_vertices(), false));
+            for(index_type node = 0; node < hgraph.num_vertices(); ++node)
+            {
+                const unsigned part_id = sub_partition.assignedPartition(node);
+                const index_type original_id = hgraph_and_id_to_old_idx[std::make_pair(sub_hgraph_index, node)];
+                node_to_new_hgraph_and_id[original_id] = std::make_pair(sub_hgraphs.size()+part_id, current_idx[part_id]);
+                hgraph_and_id_to_old_idx[std::make_pair(sub_hgraphs.size()+part_id, current_idx[part_id])] = original_id;
+                ++current_idx[part_id];
+                part_indicator[part_id][node] = true;
+            }
+
+            for(unsigned part = 0; part < 2; ++part)
+                sub_hgraphs.push_back(sub_hgraphs[sub_hgraph_index].create_induced_hypergraph(part_indicator[part]));
+
+            ++start_index;
+        }
+
+        parts *= 2;
+        ++level;
+    }
+    
+    for(index_type node = 0; node < nr_nodes; ++node)
+        partition.setAssignedPartition(node, node_to_new_hgraph_and_id[node].first - (static_cast<unsigned>(sub_hgraphs.size())-nr_parts));    
+    
+}
+
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
+std::vector<index_type> GenericFM<index_type, workw_type, memw_type, commw_type>::getMaxNodesOnLevel(index_type nr_nodes, unsigned nr_parts) const
+{
+    std::vector<index_type> max_nodes_on_level;
+    std::vector<index_type> limit_per_level({static_cast<index_type>(ceil(static_cast<double>(nr_nodes) / 2.0))});
+    for(unsigned parts = nr_parts / 4; parts > 0; parts /= 2)
+        limit_per_level.push_back(static_cast<index_type>(ceil(static_cast<double>(limit_per_level.back()) / 2.0)));
+
+    max_nodes_on_level.push_back(max_nodes_in_part);
+    for(unsigned parts = 2; parts < nr_parts; parts *= 2)
+    {
+        index_type next_limit = max_nodes_on_level.back()*2;
+        if(next_limit > limit_per_level.back())
+            --next_limit;
+        
+        limit_per_level.pop_back();
+        max_nodes_on_level.push_back(next_limit);
+    }
+
+    std::reverse(max_nodes_on_level.begin(),max_nodes_on_level.end());
+    return max_nodes_on_level;
+}
+
 } // namespace osp

tests/hypergraph_and_partition.cpp

@@ -184,11 +184,30 @@ BOOST_AUTO_TEST_CASE(Hypergraph_and_Partition_test) {
 
     original_cost = partition_to_improve.computeConnectivityCost();
 
+    fm.setMaxNodesInPart(0);
     fm.ImprovePartitioning(partition_to_improve);
     new_cost = partition_to_improve.computeConnectivityCost();
 
     BOOST_CHECK(partition_to_improve.satisfiesBalanceConstraint());
     BOOST_CHECK(new_cost <= original_cost);
     std::cout<<original_cost<<" --> "<<new_cost<<std::endl;
 
+    // Recursive FM
+    instance.setNumberOfPartitions(16);
+    instance.setMaxWorkWeightViaImbalanceFactor(0.3);
+
+    for(unsigned node = 0; node < instance.getHypergraph().num_vertices(); ++node)
+        partition_to_improve.setAssignedPartition(node, node % 16);
+
+    original_cost = partition_to_improve.computeConnectivityCost();
+
+    fm.setMaxNodesInPart(0);
+    fm.RecursiveFM(partition_to_improve);
+    new_cost = partition_to_improve.computeConnectivityCost();
+
+    BOOST_CHECK(partition_to_improve.satisfiesBalanceConstraint());
+    BOOST_CHECK(new_cost <= original_cost);
+    std::cout<<original_cost<<" --> "<<new_cost<<std::endl;
+
+
 };