two kinds of vertex weights on hypergraphs

Author: papp-pal-andras

include/osp/auxiliary/io/mtx_hypergraph_file_reader.hpp

@@ -79,7 +79,8 @@ bool readHypergraphMartixMarketFormat(std::ifstream& infile, Hypergraph& hgraph)
 
     hgraph.reset(num_nodes, 0);
     for (unsigned node = 0; node < num_nodes; ++node) {
-        hgraph.set_vertex_weight(node, 1);
+        hgraph.set_vertex_work_weight(node, 1);
+        hgraph.set_vertex_memory_weight(node, 1);
     }
 
     std::vector<std::vector<unsigned>> row_hyperedges(static_cast<unsigned>(M_row));

include/osp/partitioning/model/hypergraph.hpp

@@ -30,7 +30,8 @@ class Hypergraph {
     Hypergraph() = default;
 
     Hypergraph(unsigned num_vertices_, unsigned num_hyperedges_)
-        : Num_vertices(num_vertices_), Num_hyperedges(num_hyperedges_), vertex_weights(num_vertices_, 1), hyperedge_weights(num_hyperedges_, 1),
+        : Num_vertices(num_vertices_), Num_hyperedges(num_hyperedges_), vertex_work_weights(num_vertices_, 1),
+        vertex_memory_weights(num_vertices_, 1), hyperedge_weights(num_hyperedges_, 1),
         incident_hyperedges_to_vertex(num_vertices_), vertices_in_hyperedge(num_hyperedges_){}
 
     Hypergraph(const Hypergraph &other) = default;
@@ -41,17 +42,20 @@ class Hypergraph {
     inline unsigned num_vertices() const { return Num_vertices; }
     inline unsigned num_hyperedges() const { return Num_hyperedges; }
     inline unsigned num_pins() const { return Num_pins; }
-    inline int get_vertex_weight(unsigned node) const { return vertex_weights[node]; }
+    inline int get_vertex_work_weight(unsigned node) const { return vertex_work_weights[node]; }
+    inline int get_vertex_memory_weight(unsigned node) const { return vertex_memory_weights[node]; }
     inline int get_hyperedge_weight(unsigned hyperedge) const { return hyperedge_weights[hyperedge]; }
 
     void add_pin(unsigned vertex_idx, unsigned hyperedge_idx);
-    void add_vertex(int weight = 1);
+    void add_vertex(int work_weight = 1, int memory_weight = 1);
     void add_empty_hyperedge(int weight = 1);
     void add_hyperedge(const std::vector<unsigned>& pins, int weight = 1);
-    void set_vertex_weight(unsigned vertex_idx, int weight);
+    void set_vertex_work_weight(unsigned vertex_idx, int weight);
+    void set_vertex_memory_weight(unsigned vertex_idx, int weight);
     void set_hyperedge_weight(unsigned hyperedge_idx, int weight);
 
-    int compute_total_vertex_weight() const;
+    int compute_total_vertex_work_weight() const;
+    int compute_total_vertex_memory_weight() const;
 
     void clear();
     void reset(unsigned num_vertices_, unsigned num_hyperedges_);
@@ -68,7 +72,8 @@ class Hypergraph {
   private:
     unsigned Num_vertices = 0, Num_hyperedges = 0, Num_pins = 0;
 
-    std::vector<int> vertex_weights;
+    std::vector<int> vertex_work_weights;
+    std::vector<int> vertex_memory_weights;
     std::vector<int> hyperedge_weights;
 
     std::vector<std::vector<unsigned>> incident_hyperedges_to_vertex;
@@ -92,9 +97,10 @@ void Hypergraph::add_pin(unsigned vertex_idx, unsigned hyperedge_idx)
     }
 }
 
-void Hypergraph::add_vertex(int weight)
+void Hypergraph::add_vertex(int work_weight, int memory_weight)
 {
-    vertex_weights.push_back(weight);
+    vertex_work_weights.push_back(work_weight);
+    vertex_memory_weights.push_back(memory_weight);
     incident_hyperedges_to_vertex.emplace_back();
     ++Num_vertices;
 }
@@ -116,12 +122,20 @@ void Hypergraph::add_hyperedge(const std::vector<unsigned>& pins, int weight)
     Num_pins += static_cast<unsigned>(pins.size());
 }
 
-void Hypergraph::set_vertex_weight(unsigned vertex_idx, int weight)
+void Hypergraph::set_vertex_work_weight(unsigned vertex_idx, int weight)
 {
     if(vertex_idx >= Num_vertices)
         throw std::invalid_argument("Invalid Argument while setting vertex weight: vertex index out of range.");
     else   
-        vertex_weights[vertex_idx] = weight;
+        vertex_work_weights[vertex_idx] = weight;
+}
+
+void Hypergraph::set_vertex_memory_weight(unsigned vertex_idx, int weight)
+{
+    if(vertex_idx >= Num_vertices)
+        throw std::invalid_argument("Invalid Argument while setting vertex weight: vertex index out of range.");
+    else   
+        vertex_memory_weights[vertex_idx] = weight;
 }
 
 void Hypergraph::set_hyperedge_weight(unsigned hyperedge_idx, int weight)
@@ -132,11 +146,19 @@ void Hypergraph::set_hyperedge_weight(unsigned hyperedge_idx, int weight)
         hyperedge_weights[hyperedge_idx] = weight;
 }
 
-int Hypergraph::compute_total_vertex_weight() const
+int Hypergraph::compute_total_vertex_work_weight() const
+{
+    int total = 0;
+    for(unsigned node = 0; node < Num_vertices; ++node)
+        total += vertex_work_weights[node];
+    return total;
+}
+
+int Hypergraph::compute_total_vertex_memory_weight() const
 {
     int total = 0;
     for(unsigned node = 0; node < Num_vertices; ++node)
-        total += vertex_weights[node];
+        total += vertex_memory_weights[node];
     return total;
 }
 
@@ -146,7 +168,8 @@ void Hypergraph::clear()
     Num_hyperedges = 0;
     Num_pins = 0;
 
-    vertex_weights.clear();
+    vertex_work_weights.clear();
+    vertex_memory_weights.clear();
     hyperedge_weights.clear();
     incident_hyperedges_to_vertex.clear();
     vertices_in_hyperedge.clear();
@@ -159,7 +182,8 @@ void Hypergraph::reset(unsigned num_vertices_, unsigned num_hyperedges_)
     Num_vertices = num_vertices_;
     Num_hyperedges = num_hyperedges_;
 
-    vertex_weights.resize(num_vertices_, 1);
+    vertex_work_weights.resize(num_vertices_, 1);
+    vertex_memory_weights.resize(num_vertices_, 1);
     hyperedge_weights.resize(num_hyperedges_, 1);
     incident_hyperedges_to_vertex.resize(num_vertices_);
     vertices_in_hyperedge.resize(num_hyperedges_);
@@ -171,7 +195,8 @@ void Hypergraph::convert_from_cdag_as_dag(const Graph_t& dag)
     reset(static_cast<unsigned>(dag.num_vertices()), 0);
     for(const auto &node : dag.vertices())
     {
-        set_vertex_weight(static_cast<unsigned>(node), static_cast<int>(dag.vertex_work_weight(node)));
+        set_vertex_work_weight(static_cast<unsigned>(node), static_cast<int>(dag.vertex_work_weight(node)));
+        set_vertex_memory_weight(static_cast<unsigned>(node), static_cast<int>(dag.vertex_mem_weight(node)));
         for (const auto &child : dag.children(node))
             add_hyperedge({static_cast<unsigned>(node), static_cast<unsigned>(child)}); // TODO add edge weights if present
     }
@@ -183,7 +208,8 @@ void Hypergraph::convert_from_cdag_as_hyperdag(const Graph_t& dag)
     reset(static_cast<unsigned>(dag.num_vertices()), 0);
     for(const auto &node : dag.vertices())
     {
-        set_vertex_weight(static_cast<unsigned>(node), static_cast<int>(dag.vertex_work_weight(node)));
+        set_vertex_work_weight(static_cast<unsigned>(node), static_cast<int>(dag.vertex_work_weight(node)));
+        set_vertex_memory_weight(static_cast<unsigned>(node), static_cast<int>(dag.vertex_mem_weight(node)));
         if(dag.out_degree(node) == 0)
             continue;
         std::vector<unsigned> new_hyperedge({static_cast<unsigned>(node)});

include/osp/partitioning/model/partitioning.hpp

@@ -150,17 +150,25 @@ int Partitioning::computeCutNetCost() const {
 }
 
 bool Partitioning::satisfiesBalanceConstraint() const {
-    std::vector<int> weight(instance->getNumberOfPartitions(), 0);
+    std::vector<int> work_weight(instance->getNumberOfPartitions(), 0);
+    std::vector<int> memory_weight(instance->getNumberOfPartitions(), 0);
     for (unsigned node = 0; node < node_to_partition_assignment.size(); ++node) {
         if (node_to_partition_assignment[node] > instance->getNumberOfPartitions())
             throw std::invalid_argument("Invalid Argument while checking balance constraint: partition ID out of range.");
         else
-            weight[node_to_partition_assignment[node]] += instance->getHypergraph().get_vertex_weight(node);
+        {
+            work_weight[node_to_partition_assignment[node]] += instance->getHypergraph().get_vertex_work_weight(node);
+            memory_weight[node_to_partition_assignment[node]] += instance->getHypergraph().get_vertex_memory_weight(node);
+        }
     }
 
     for(unsigned part = 0; part < instance->getNumberOfPartitions(); ++part)
-        if(weight[part] > instance->getMaxWeightPerPartition())
+    {
+        if(work_weight[part] > instance->getMaxWorkWeightPerPartition())
             return false;
+        if(memory_weight[part] > instance->getMaxMemoryWeightPerPartition())
+            return false;
+    }
 
     return true;
 };

include/osp/partitioning/model/partitioning_problem.hpp

@@ -32,19 +32,22 @@ class PartitioningProblem {
     Hypergraph hgraph;
 
     unsigned nr_of_partitions;
-    int max_weight_per_partition;
+    int max_work_weight_per_partition;
+    int max_memory_weight_per_partition;
 
     bool allows_replication = false;
 
   public:
 
     PartitioningProblem() = default;
 
-    PartitioningProblem(const Hypergraph &hgraph_, unsigned nr_parts_ = 2, int max_weight_ = std::numeric_limits<int>::max())
-        : hgraph(hgraph_), nr_of_partitions(nr_parts_), max_weight_per_partition(max_weight_) {}
+    PartitioningProblem(const Hypergraph &hgraph_, unsigned nr_parts_ = 2, int max_work_weight_ = std::numeric_limits<int>::max(), 
+                        int max_memory_weight_ = std::numeric_limits<int>::max()) : hgraph(hgraph_), nr_of_partitions(nr_parts_),
+                        max_work_weight_per_partition(max_work_weight_), max_memory_weight_per_partition(max_memory_weight_) {}
 
-    PartitioningProblem(const Hypergraph &&hgraph_, unsigned nr_parts_ = 2, int max_weight_ = std::numeric_limits<int>::max())
-        : hgraph(hgraph_), nr_of_partitions(nr_parts_), max_weight_per_partition(max_weight_) {}
+    PartitioningProblem(const Hypergraph &&hgraph_, unsigned nr_parts_ = 2, int max_work_weight_ = std::numeric_limits<int>::max(), 
+                        int max_memory_weight_ = std::numeric_limits<int>::max()) : hgraph(hgraph_), nr_of_partitions(nr_parts_),
+                        max_work_weight_per_partition(max_work_weight_), max_memory_weight_per_partition(max_memory_weight_) {}
 
     PartitioningProblem(const PartitioningProblem &other) = default;
     PartitioningProblem(PartitioningProblem &&other) = default;
@@ -57,7 +60,8 @@ class PartitioningProblem {
     inline Hypergraph &getHypergraph() { return hgraph; }
 
     inline unsigned getNumberOfPartitions() const { return nr_of_partitions; }
-    inline int getMaxWeightPerPartition() const { return max_weight_per_partition; }
+    inline int getMaxWorkWeightPerPartition() const { return max_work_weight_per_partition; }
+    inline int getMaxMemoryWeightPerPartition() const { return max_memory_weight_per_partition; }
     inline bool getAllowsReplication() const { return allows_replication; }
 
     // setters
@@ -66,12 +70,19 @@ class PartitioningProblem {
     inline void setNumberOfPartitions(unsigned nr_parts_) { nr_of_partitions = nr_parts_; }
     inline void setAllowsReplication(bool allowed_) { allows_replication = allowed_; }
 
-    inline void setMaxWeightExplicitly(int max_weight_) { max_weight_per_partition = max_weight_; }
-    void setMaxWeightViaImbalanceFactor(double imbalance){
+    inline void setMaxWorkWeightExplicitly(int max_weight_) { max_work_weight_per_partition = max_weight_; }
+    void setMaxWorkWeightViaImbalanceFactor(double imbalance){
         if(imbalance < 0 )
             throw std::invalid_argument("Invalid Argument while setting imbalance parameter: parameter is negative.");
         else
-            max_weight_per_partition = static_cast<int>(ceil(hgraph.compute_total_vertex_weight()/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
+            max_work_weight_per_partition = static_cast<int>(ceil(hgraph.compute_total_vertex_work_weight()/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
+    }
+    inline void setMaxMemoryWeightExplicitly(int 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<int>(ceil(hgraph.compute_total_vertex_memory_weight()/ static_cast<double>(nr_of_partitions) * (1.0+imbalance)));
     }
 };
 

include/osp/partitioning/model/partitioning_replication.hpp

@@ -191,18 +191,26 @@ int PartitioningWithReplication::computeCutNetCost() const {
 }
 
 bool PartitioningWithReplication::satisfiesBalanceConstraint() const {
-    std::vector<int> weight(instance->getNumberOfPartitions(), 0);
+    std::vector<int> work_weight(instance->getNumberOfPartitions(), 0);
+    std::vector<int> memory_weight(instance->getNumberOfPartitions(), 0);
     for (unsigned node = 0; node < node_to_partitions_assignment.size(); ++node)
         for(unsigned part : node_to_partitions_assignment[node]){
             if (part > instance->getNumberOfPartitions())
                 throw std::invalid_argument("Invalid Argument while checking balance constraint: partition ID out of range.");
             else
-                weight[part] += instance->getHypergraph().get_vertex_weight(node);
+            {
+                work_weight[part] += instance->getHypergraph().get_vertex_work_weight(node);
+                memory_weight[part] += instance->getHypergraph().get_vertex_memory_weight(node);
+            }
         }
 
     for(unsigned part = 0; part < instance->getNumberOfPartitions(); ++part)
-        if(weight[part] > instance->getMaxWeightPerPartition())
+    {
+        if(work_weight[part] > instance->getMaxWorkWeightPerPartition())
             return false;
+        if(memory_weight[part] > instance->getMaxMemoryWeightPerPartition())
+            return false;
+    }
 
     return true;
 };

include/osp/partitioning/partitioners/generic_FM.hpp

@@ -63,8 +63,8 @@ void GenericFM::ImprovePartitioning(Partitioning& partition)
         max_degree = std::max(max_degree, static_cast<unsigned>(Hgraph.get_incident_hyperedges(node).size()));
 
     if(max_nodes_in_part == 0) // if not initialized
-        max_nodes_in_part = static_cast<unsigned>(ceil(static_cast<double>(Hgraph.num_vertices()) * static_cast<double>(partition.getInstance().getMaxWeightPerPartition())
-                                         / static_cast<double>(Hgraph.compute_total_vertex_weight()) ));
+        max_nodes_in_part = static_cast<unsigned>(ceil(static_cast<double>(Hgraph.num_vertices()) * static_cast<double>(partition.getInstance().getMaxWorkWeightPerPartition())
+                                         / static_cast<double>(Hgraph.compute_total_vertex_work_weight()) ));
 
     for(unsigned pass_idx = 0; pass_idx < max_number_of_passes; ++pass_idx)
     {

include/osp/partitioning/partitioners/partitioning_ILP_base.hpp

@@ -89,14 +89,28 @@ void HypergraphPartitioningILPBase::setupFundamentalVariablesConstraintsObjectiv
         hyperedge_uses_partition[hyperedge] = model.AddVars(static_cast<int>(numberOfParts), COPT_BINARY, "hyperedge_uses_partition");
 
     // partition size constraints
-    for (unsigned part = 0; part < numberOfParts; part++)
+    if(instance.getMaxWorkWeightPerPartition() < std::numeric_limits<int>::max())
     {
-        Expr expr;
-        for (unsigned node = 0; node < numberOfVertices; node++)
-            expr += instance.getHypergraph().get_vertex_weight(node) * node_in_partition[node][static_cast<int>(part)];
+        for (unsigned part = 0; part < numberOfParts; part++)
+        {
+            Expr expr;
+            for (unsigned node = 0; node < numberOfVertices; node++)
+                expr += instance.getHypergraph().get_vertex_work_weight(node) * node_in_partition[node][static_cast<int>(part)];
 
-        model.AddConstr(expr <= instance.getMaxWeightPerPartition());
+            model.AddConstr(expr <= instance.getMaxWorkWeightPerPartition());
+        }
     }    
+    if(instance.getMaxMemoryWeightPerPartition() < std::numeric_limits<int>::max())
+    {
+        for (unsigned part = 0; part < numberOfParts; part++)
+        {
+            Expr expr;
+            for (unsigned node = 0; node < numberOfVertices; node++)
+                expr += instance.getHypergraph().get_vertex_memory_weight(node) * node_in_partition[node][static_cast<int>(part)];
+
+            model.AddConstr(expr <= instance.getMaxMemoryWeightPerPartition());
+        }
+    } 
 
     // set objective
     Expr expr;

tests/hypergraph_and_partition.cpp

@@ -93,13 +93,13 @@ BOOST_AUTO_TEST_CASE(Hypergraph_and_Partition_test) {
     BOOST_CHECK(connectivityCost >= cutNetCost);
 
     for(unsigned node = 0; node < Hgraph.num_vertices(); ++node)
-        instance.getHypergraph().set_vertex_weight(node, 1);
+        instance.getHypergraph().set_vertex_work_weight(node, 1);
 
-    instance.setMaxWeightViaImbalanceFactor(0);
+    instance.setMaxWorkWeightViaImbalanceFactor(0);
     BOOST_CHECK(partition.satisfiesBalanceConstraint());
 
     instance.setNumberOfPartitions(5);
-    instance.setMaxWeightViaImbalanceFactor(0);
+    instance.setMaxWorkWeightViaImbalanceFactor(0);
     BOOST_CHECK(!partition.satisfiesBalanceConstraint());
 
     for(unsigned node = 0; node < Hgraph.num_vertices(); ++node)
@@ -108,14 +108,20 @@ BOOST_AUTO_TEST_CASE(Hypergraph_and_Partition_test) {
     BOOST_CHECK(partition.satisfiesBalanceConstraint());
     BOOST_CHECK(partition.computeConnectivityCost() >= partition.computeCutNetCost());
 
+    for(unsigned node = 0; node < Hgraph.num_vertices(); ++node)
+        instance.getHypergraph().set_vertex_memory_weight(node, 1);
+    instance.setMaxMemoryWeightExplicitly(10);
+    BOOST_CHECK(partition.satisfiesBalanceConstraint() == false);
+    instance.setMaxMemoryWeightExplicitly(std::numeric_limits<int>::max());
+
     file_writer::write_txt(std::cout, partition);
 
 
     // Dummy partitioning with replication
 
     instance.getHypergraph().convert_from_cdag_as_hyperdag(DAG);
     instance.setNumberOfPartitions(3);
-    instance.setMaxWeightExplicitly(30);
+    instance.setMaxWorkWeightExplicitly(30);
     PartitioningWithReplication partition_with_rep(instance);
     for(unsigned node = 0; node < Hgraph.num_vertices(); ++node)
         partition_with_rep.setAssignedPartitions(node, {node % 3});
@@ -124,14 +130,14 @@ BOOST_AUTO_TEST_CASE(Hypergraph_and_Partition_test) {
     BOOST_CHECK(partition_with_rep.computeCutNetCost() == cutNetCost);
     BOOST_CHECK(partition_with_rep.computeConnectivityCost() == connectivityCost);
 
-    instance.setMaxWeightExplicitly(60);
+    instance.setMaxWorkWeightExplicitly(60);
     for(unsigned node = 0; node < Hgraph.num_vertices(); ++node)
         partition_with_rep.setAssignedPartitions(node, {node % 3, (node+1)%3});
 
     BOOST_CHECK(partition_with_rep.satisfiesBalanceConstraint());
     BOOST_CHECK(partition_with_rep.computeConnectivityCost() >= partition_with_rep.computeCutNetCost());
 
-    instance.setMaxWeightExplicitly(Hgraph.compute_total_vertex_weight());
+    instance.setMaxWorkWeightExplicitly(Hgraph.compute_total_vertex_work_weight());
     for(unsigned node = 0; node < Hgraph.num_vertices(); ++node)
         partition_with_rep.setAssignedPartitions(node, {0, 1, 2});
 
@@ -145,9 +151,9 @@ BOOST_AUTO_TEST_CASE(Hypergraph_and_Partition_test) {
     // Generic FM
 
     instance.setNumberOfPartitions(2);
-    instance.setMaxWeightExplicitly(/*35*/ 4000);
+    instance.setMaxWorkWeightExplicitly(/*35*/ 4000);
     for(unsigned node = 0; node < instance.getHypergraph().num_vertices(); ++node)
-        instance.getHypergraph().set_vertex_weight(node, 1);
+        instance.getHypergraph().set_vertex_work_weight(node, 1);
 
     Partitioning partition_to_improve(instance);
     for(unsigned node = 0; node < instance.getHypergraph().num_vertices(); ++node)
@@ -168,9 +174,9 @@ BOOST_AUTO_TEST_CASE(Hypergraph_and_Partition_test) {
         (cwd / "data/spaa/large/instance_CG_N24_K22_nzP0d2.hdag").string(), larger_DAG);
     instance.getHypergraph().convert_from_cdag_as_hyperdag(larger_DAG);
 
-    instance.setMaxWeightExplicitly(4000);
+    instance.setMaxWorkWeightExplicitly(4000);
     for(unsigned node = 0; node < instance.getHypergraph().num_vertices(); ++node)
-        instance.getHypergraph().set_vertex_weight(node, 1);
+        instance.getHypergraph().set_vertex_work_weight(node, 1);
 
     partition_to_improve.resetPartition();
     for(unsigned node = 0; node < instance.getHypergraph().num_vertices(); ++node)