moving hypergraph utility functions into separate file

Author: papp-pal-andras

apps/ilp_hypergraph_partitioner.cpp

@@ -26,6 +26,7 @@ limitations under the License.
 #include "osp/auxiliary/misc.hpp"
 #include "osp/graph_algorithms/directed_graph_path_util.hpp"
 #include "osp/auxiliary/io/general_file_reader.hpp"
+#include "osp/partitioning/model/hypergraph_utility.hpp"
 #include "osp/partitioning/partitioners/generic_FM.hpp"
 #include "osp/partitioning/partitioners/partitioning_ILP.hpp"
 #include "osp/partitioning/partitioners/partitioning_ILP_replication.hpp"
@@ -86,7 +87,7 @@ int main(int argc, char *argv[]) {
         graph dag;
         file_status = file_reader::readComputationalDagHyperdagFormatDB(filename_hgraph, dag);
         if(file_status)
-            hgraph.convert_from_cdag_as_hyperdag(dag);
+            hgraph = convert_from_cdag_as_hyperdag<size_t, int, int, int, graph>(dag);
     } else if (file_ending == "mtx") {
         file_status = file_reader::readHypergraphMartixMarketFormat(filename_hgraph, hgraph);
     } else {

include/osp/partitioning/model/hypergraph.hpp

@@ -56,22 +56,13 @@ class Hypergraph {
     void set_vertex_memory_weight(index_type vertex_idx, memw_type weight);
     void set_hyperedge_weight(index_type hyperedge_idx, commw_type weight);
 
-    workw_type compute_total_vertex_work_weight() const;
-    memw_type compute_total_vertex_memory_weight() const;
 
     void clear();
     void reset(index_type num_vertices_, index_type num_hyperedges_);
 
     inline const std::vector<index_type> &get_incident_hyperedges(index_type vertex) const { return incident_hyperedges_to_vertex[vertex]; }
     inline const std::vector<index_type> &get_vertices_in_hyperedge(index_type hyperedge) const { return vertices_in_hyperedge[hyperedge]; }
 
-    template<typename Graph_t>
-    void convert_from_cdag_as_dag(const Graph_t& dag);
-
-    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;
@@ -157,23 +148,6 @@ void Hypergraph<index_type, workw_type, memw_type, commw_type>::set_hyperedge_we
         hyperedge_weights[hyperedge_idx] = weight;
 }
 
-template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
-workw_type Hypergraph<index_type, workw_type, memw_type, commw_type>::compute_total_vertex_work_weight() const
-{
-    workw_type total = 0;
-    for(index_type node = 0; node < Num_vertices; ++node)
-        total += vertex_work_weights[node];
-    return total;
-}
-
-template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
-memw_type Hypergraph<index_type, workw_type, memw_type, commw_type>::compute_total_vertex_memory_weight() const
-{
-    memw_type total = 0;
-    for(index_type node = 0; node < Num_vertices; ++node)
-        total += vertex_memory_weights[node];
-    return total;
-}
 
 template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
 void Hypergraph<index_type, workw_type, memw_type, commw_type>::clear()
@@ -204,86 +178,5 @@ void Hypergraph<index_type, workw_type, memw_type, commw_type>::reset(index_type
     vertices_in_hyperedge.resize(num_hyperedges_);
 }
 
-template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
-template<typename Graph_t>
-void Hypergraph<index_type, workw_type, memw_type, commw_type>::convert_from_cdag_as_dag(const Graph_t& dag)
-{
-    static_assert(std::is_same_v<vertex_idx_t<Graph_t>, index_type>, "Index type mismatch, cannot convert DAG to hypergraph.");
-    static_assert(std::is_same_v<v_workw_t<Graph_t>, workw_type>, "Work weight type mismatch, cannot convert DAG to hypergraph.");
-    static_assert(std::is_same_v<v_memw_t<Graph_t>, memw_type>, "Memory weight type mismatch, cannot convert DAG to hypergraph.");
-    static_assert(!has_edge_weights_v<Graph_t> || std::is_same_v<e_commw_t<Graph_t>, commw_type>, "Communication weight type mismatch, cannot convert DAG to hypergraph.");
-
-    reset(dag.num_vertices(), 0);
-    for(const auto &node : dag.vertices())
-    {
-        set_vertex_work_weight(node, dag.vertex_work_weight(node));
-        set_vertex_memory_weight(node, dag.vertex_mem_weight(node));
-        for (const auto &child : dag.children(node))
-            if constexpr(has_edge_weights_v<Graph_t>)
-                add_hyperedge({node, child}, dag.edge_comm_weight(edge_desc(node, child, dag).first));
-            else 
-                add_hyperedge({node, child});
-    }
-}
-
-template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
-template<typename Graph_t>
-void Hypergraph<index_type, workw_type, memw_type, commw_type>::convert_from_cdag_as_hyperdag(const Graph_t& dag)
-{
-    static_assert(std::is_same_v<vertex_idx_t<Graph_t>, index_type>, "Index type mismatch, cannot convert DAG to hypergraph.");
-    static_assert(std::is_same_v<v_workw_t<Graph_t>, workw_type>, "Work weight type mismatch, cannot convert DAG to hypergraph.");
-    static_assert(std::is_same_v<v_memw_t<Graph_t>, memw_type>, "Memory weight type mismatch, cannot convert DAG to hypergraph.");
-    static_assert(std::is_same_v<v_commw_t<Graph_t>, commw_type>, "Communication weight type mismatch, cannot convert DAG to hypergraph.");
-
-    reset(dag.num_vertices(), 0);
-    for(const auto &node : dag.vertices())
-    {
-        set_vertex_work_weight(node, dag.vertex_work_weight(node));
-        set_vertex_memory_weight(node, dag.vertex_mem_weight(node));
-        if(dag.out_degree(node) == 0)
-            continue;
-        std::vector<index_type> new_hyperedge({node});
-        for (const auto &child : dag.children(node))
-            new_hyperedge.push_back(child);
-        add_hyperedge(new_hyperedge, dag.vertex_comm_weight(node));
-    }
-}
-
-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/model/hypergraph_utility.hpp

@@ -0,0 +1,145 @@
+/*
+Copyright 2024 Huawei Technologies Co., Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+@author Toni Boehnlein, Benjamin Lozes, Pal Andras Papp, Raphael S. Steiner
+*/
+
+#pragma once
+
+#include <queue>
+#include <unordered_set>
+#include <vector>
+
+#include "osp/partitioning/model/hypergraph.hpp"
+
+/**
+ * @file hypergraph_utility.hpp
+ * @brief Utility functions and classes for working with hypergraphs graphs.
+ *
+ * This file provides a collection of simple utility functions for the hypergraph class.
+ */
+
+namespace osp {
+
+
+// summing up weights
+
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
+workw_type compute_total_vertex_work_weight(const Hypergraph<index_type, workw_type, memw_type, commw_type>& hgraph)
+{
+    workw_type total = 0;
+    for(index_type node = 0; node < hgraph.num_vertices(); ++node)
+        total += hgraph.get_vertex_work_weight(node);
+    return total;
+}
+
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
+memw_type compute_total_vertex_memory_weight(const Hypergraph<index_type, workw_type, memw_type, commw_type>& hgraph)
+{
+    memw_type total = 0;
+    for(index_type node = 0; node < hgraph.num_vertices(); ++node)
+        total += hgraph.get_vertex_memory_weight(node);
+    return total;
+}
+
+
+// get induced subhypergraph
+
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type>
+Hypergraph<index_type, workw_type, memw_type, commw_type> create_induced_hypergraph(const Hypergraph<index_type, workw_type, memw_type, commw_type>& hgraph, const std::vector<bool>& include)
+{
+    if(include.size() != hgraph.num_vertices())
+        throw std::invalid_argument("Invalid Argument while extracting induced hypergraph: input bool array has incorrect size.");
+
+    std::vector<index_type> new_index(hgraph.num_vertices());
+    unsigned current_index = 0;
+    for(index_type node = 0; node < hgraph.num_vertices(); ++node)
+        if(include[node])
+            new_index[node] = current_index++;
+    
+    Hypergraph<index_type, workw_type, memw_type, commw_type> new_hgraph(current_index, 0);
+    for(index_type node = 0; node < hgraph.num_vertices(); ++node)
+        if(include[node])
+        {
+            new_hgraph.set_vertex_work_weight(new_index[node], hgraph.get_vertex_work_weight(node));
+            new_hgraph.set_vertex_memory_weight(new_index[node], hgraph.get_vertex_memory_weight(node));
+        }
+
+    for(index_type hyperedge = 0; hyperedge < hgraph.num_hyperedges(); ++hyperedge)
+    {
+        unsigned nr_induced_pins = 0;
+        std::vector<index_type> induced_hyperedge;
+        for(index_type node : hgraph.get_vertices_in_hyperedge(hyperedge))
+            if(include[node])
+            {
+                induced_hyperedge.push_back(new_index[node]);
+                ++nr_induced_pins;
+            }
+        
+        if(nr_induced_pins >= 2)
+            new_hgraph.add_hyperedge(induced_hyperedge, hgraph.get_hyperedge_weight(hyperedge));
+    }
+    return new_hgraph;
+}
+
+
+// conversion
+
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type, typename Graph_t>
+Hypergraph<index_type, workw_type, memw_type, commw_type> convert_from_cdag_as_dag(const Graph_t& dag)
+{
+    static_assert(std::is_same_v<vertex_idx_t<Graph_t>, index_type>, "Index type mismatch, cannot convert DAG to hypergraph.");
+    static_assert(std::is_same_v<v_workw_t<Graph_t>, workw_type>, "Work weight type mismatch, cannot convert DAG to hypergraph.");
+    static_assert(std::is_same_v<v_memw_t<Graph_t>, memw_type>, "Memory weight type mismatch, cannot convert DAG to hypergraph.");
+    static_assert(!has_edge_weights_v<Graph_t> || std::is_same_v<e_commw_t<Graph_t>, commw_type>, "Communication weight type mismatch, cannot convert DAG to hypergraph.");
+
+    Hypergraph<index_type, workw_type, memw_type, commw_type> hgraph(dag.num_vertices(), 0);
+    for(const auto &node : dag.vertices())
+    {
+        hgraph.set_vertex_work_weight(node, dag.vertex_work_weight(node));
+        hgraph.set_vertex_memory_weight(node, dag.vertex_mem_weight(node));
+        for (const auto &child : dag.children(node))
+            if constexpr(has_edge_weights_v<Graph_t>)
+                hgraph.add_hyperedge({node, child}, dag.edge_comm_weight(edge_desc(node, child, dag).first));
+            else 
+                hgraph.add_hyperedge({node, child});
+    }
+    return hgraph;
+}
+
+template<typename index_type, typename workw_type, typename memw_type, typename commw_type, typename Graph_t>
+Hypergraph<index_type, workw_type, memw_type, commw_type> convert_from_cdag_as_hyperdag(const Graph_t& dag)
+{
+    static_assert(std::is_same_v<vertex_idx_t<Graph_t>, index_type>, "Index type mismatch, cannot convert DAG to hypergraph.");
+    static_assert(std::is_same_v<v_workw_t<Graph_t>, workw_type>, "Work weight type mismatch, cannot convert DAG to hypergraph.");
+    static_assert(std::is_same_v<v_memw_t<Graph_t>, memw_type>, "Memory weight type mismatch, cannot convert DAG to hypergraph.");
+    static_assert(std::is_same_v<v_commw_t<Graph_t>, commw_type>, "Communication weight type mismatch, cannot convert DAG to hypergraph.");
+
+    Hypergraph<index_type, workw_type, memw_type, commw_type> hgraph(dag.num_vertices(), 0);
+    for(const auto &node : dag.vertices())
+    {
+        hgraph.set_vertex_work_weight(node, dag.vertex_work_weight(node));
+        hgraph.set_vertex_memory_weight(node, dag.vertex_mem_weight(node));
+        if(dag.out_degree(node) == 0)
+            continue;
+        std::vector<index_type> new_hyperedge({node});
+        for (const auto &child : dag.children(node))
+            new_hyperedge.push_back(child);
+        hgraph.add_hyperedge(new_hyperedge, dag.vertex_comm_weight(node));
+    }
+    return hgraph;
+}
+
+} // namespace osp

include/osp/partitioning/model/partitioning_problem.hpp

@@ -21,7 +21,7 @@ limitations under the License.
 #include <iostream>
 #include <cmath>
 
-#include "osp/partitioning/model/hypergraph.hpp"
+#include "osp/partitioning/model/hypergraph_utility.hpp"
 
 namespace osp {
 
@@ -80,14 +80,14 @@ class PartitioningProblem {
         if(imbalance < 0 )
             throw std::invalid_argument("Invalid Argument while setting imbalance parameter: parameter is negative.");
         else
-            max_work_weight_per_partition = static_cast<workw_type>(ceil(hgraph.compute_total_vertex_work_weight()/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
+            max_work_weight_per_partition = static_cast<workw_type>(ceil(compute_total_vertex_work_weight(hgraph)/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
     }
     inline void setMaxMemoryWeightExplicitly(memw_type max_weight_) { max_memory_weight_per_partition = max_weight_; }
     void setMaxMemoryWeightViaImbalanceFactor(double imbalance){
         if(imbalance < 0 )
             throw std::invalid_argument("Invalid Argument while setting imbalance parameter: parameter is negative.");
         else
-            max_memory_weight_per_partition = static_cast<memw_type>(ceil(hgraph.compute_total_vertex_memory_weight()/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
+            max_memory_weight_per_partition = static_cast<memw_type>(ceil(compute_total_vertex_memory_weight(hgraph)/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
     }
 };
 

include/osp/partitioning/partitioners/generic_FM.hpp

@@ -71,7 +71,7 @@ void GenericFM<index_type, workw_type, memw_type, commw_type>::ImprovePartitioni
 
     if(max_nodes_in_part == 0) // if not initialized
         max_nodes_in_part = static_cast<index_type>(ceil(static_cast<double>(Hgraph.num_vertices()) * static_cast<double>(partition.getInstance().getMaxWorkWeightPerPartition())
-                                         / static_cast<double>(Hgraph.compute_total_vertex_work_weight()) ));
+                                         / static_cast<double>(compute_total_vertex_work_weight(Hgraph)) ));
 
     for(unsigned pass_idx = 0; pass_idx < max_number_of_passes; ++pass_idx)
     {
@@ -282,7 +282,7 @@ void GenericFM<index_type, workw_type, memw_type, commw_type>::RecursiveFM(Parti
 
     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()) ));
+                                         / static_cast<double>(compute_total_vertex_work_weight(partition.getInstance().getHypergraph())) ));
 
     const std::vector<index_type> max_nodes_on_level = getMaxNodesOnLevel(nr_nodes, nr_parts);
 
@@ -328,7 +328,7 @@ void GenericFM<index_type, workw_type, memw_type, commw_type>::RecursiveFM(Parti
             }
 
             for(unsigned part = 0; part < 2; ++part)
-                sub_hgraphs.push_back(sub_hgraphs[sub_hgraph_index].create_induced_hypergraph(part_indicator[part]));
+                sub_hgraphs.push_back(create_induced_hypergraph(sub_hgraphs[sub_hgraph_index], part_indicator[part]));
 
             ++start_index;
         }