check for overflow when computing total node weight

Author: N-Maas

mt-kahypar/datastructures/hypergraph_common.h

@@ -45,17 +45,19 @@ using RatingType = double;
 #define ID(X) static_cast<uint64_t>(X)
 using HypernodeID = uint64_t;
 using HyperedgeID = uint64_t;
+using HypernodeWeight = int64_t;
+using HyperedgeWeight = int64_t;
 // louvain graph
 using NodeID = uint64_t;
 #else
 #define ID(X) static_cast<uint32_t>(X)
 using HypernodeID = uint32_t;
 using HyperedgeID = uint32_t;
+using HypernodeWeight = int32_t;
+using HyperedgeWeight = int32_t;
 // louvain graph
 using NodeID = uint32_t;
 #endif
-using HypernodeWeight = int32_t;
-using HyperedgeWeight = int32_t;
 using PartitionID = int32_t;
 using Gain = HyperedgeWeight;
 

mt-kahypar/datastructures/hypergraph_utils.h

@@ -28,11 +28,32 @@
 
 #include "mt-kahypar/datastructures/hypergraph_common.h"
 
+#include <limits>
+
 #include <tbb/parallel_reduce.h>
 
 
 namespace mt_kahypar {
 
+namespace impl {
+  inline HypernodeWeight add(HypernodeWeight lhs, HypernodeWeight rhs) {
+    if (lhs > std::numeric_limits<HypernodeWeight>::max() - rhs) {
+      std::string msg = "total node weight overflows weight data type";
+      if constexpr (sizeof(HypernodeWeight) < 8) {
+        msg += " (build with -DKAHYPAR_USE_64_BIT_IDS=ON to support larger ranges)";
+      }
+      throw InvalidInputException(msg);
+    }
+    return lhs + rhs;
+  }
+
+  struct safe_addition {
+    HypernodeWeight operator()(const HypernodeWeight& lhs, const HypernodeWeight& rhs) const {
+      return add(lhs, rhs);
+    }
+  };
+}
+
 template<typename Hypergraph>
 HypernodeWeight computeTotalNodeWeightParallel(const Hypergraph& hypergraph, const HypernodeID num_hypernodes) {
   return tbb::parallel_reduce(
@@ -41,11 +62,11 @@ HypernodeWeight computeTotalNodeWeightParallel(const Hypergraph& hypergraph, con
       HypernodeWeight weight = init;
       for (HypernodeID hn = range.begin(); hn < range.end(); ++hn) {
         if (hypergraph.nodeIsEnabled(hn)) {
-          weight += hypergraph.nodeWeight(hn);
+          weight = impl::add(weight, hypergraph.nodeWeight(hn));
         }
       }
       return weight;
-    }, std::plus<>());
+    }, impl::safe_addition{});
   }
 
 } // namespace mt_kahypar

tests/datastructures/dynamic_graph_test.cc

@@ -180,6 +180,12 @@ TEST_F(ADynamicGraph, VerifiesEdgeSizes) {
   }
 }
 
+TEST_F(ADynamicGraph, PreventsWeightOverflow) {
+  hypergraph.setNodeWeight(0, std::numeric_limits<HypernodeWeight>::max() / 2);
+  hypergraph.setNodeWeight(1, std::numeric_limits<HypernodeWeight>::max() / 2);
+  ASSERT_THROW(hypergraph.computeAndSetTotalNodeWeight(parallel_tag_t()), InvalidInputException);
+}
+
 TEST_F(ADynamicGraph, SetsCommunityIDsForEachVertex) {
   hypergraph.setCommunityID(0, 1);
   hypergraph.setCommunityID(1, 1);

tests/datastructures/dynamic_hypergraph_test.cc

@@ -196,6 +196,12 @@ TEST_F(ADynamicHypergraph, VerifiesEdgeSizes) {
   ASSERT_EQ(3, hypergraph.edgeSize(3));
 }
 
+TEST_F(ADynamicHypergraph, PreventsWeightOverflow) {
+  hypergraph.setNodeWeight(0, std::numeric_limits<HypernodeWeight>::max() / 2);
+  hypergraph.setNodeWeight(1, std::numeric_limits<HypernodeWeight>::max() / 2);
+  ASSERT_THROW(hypergraph.computeAndSetTotalNodeWeight(parallel_tag_t()), InvalidInputException);
+}
+
 TEST_F(ADynamicHypergraph, SetsCommunityIDsForEachVertex) {
   hypergraph.setCommunityID(0, 1);
   hypergraph.setCommunityID(1, 1);

tests/datastructures/static_graph_test.cc

@@ -173,6 +173,12 @@ TEST_F(AStaticGraph, VerifiesEdgeSizes) {
   }
 }
 
+TEST_F(AStaticGraph, PreventsWeightOverflow) {
+  hypergraph.setNodeWeight(0, std::numeric_limits<HypernodeWeight>::max() / 2);
+  hypergraph.setNodeWeight(1, std::numeric_limits<HypernodeWeight>::max() / 2);
+  ASSERT_THROW(hypergraph.computeAndSetTotalNodeWeight(parallel_tag_t()), InvalidInputException);
+}
+
 TEST_F(AStaticGraph, SetsCommunityIDsForEachVertex) {
   hypergraph.setCommunityID(0, 1);
   hypergraph.setCommunityID(1, 1);

tests/datastructures/static_hypergraph_test.cc

@@ -181,6 +181,12 @@ TEST_F(AStaticHypergraph, VerifiesEdgeSizes) {
   ASSERT_EQ(3, hypergraph.edgeSize(3));
 }
 
+TEST_F(AStaticHypergraph, PreventsWeightOverflow) {
+  hypergraph.setNodeWeight(0, std::numeric_limits<HypernodeWeight>::max() / 2);
+  hypergraph.setNodeWeight(1, std::numeric_limits<HypernodeWeight>::max() / 2);
+  ASSERT_THROW(hypergraph.computeAndSetTotalNodeWeight(parallel_tag_t()), InvalidInputException);
+}
+
 TEST_F(AStaticHypergraph, SetsCommunityIDsForEachVertex) {
   hypergraph.setCommunityID(0, 1);
   hypergraph.setCommunityID(1, 1);