handle more possible I/O errors

Author: N-Maas

mt-kahypar/io/hypergraph_io.cpp

@@ -56,12 +56,16 @@ namespace mt_kahypar::io {
                       bool& has_vertex_weights) {
     if (!is_line_ending(mapped_file, pos)) {
       // read the (up to) three 0/1 format digits
-      uint32_t format_num = read_number<uint32_t>(mapped_file, pos, current_line, length, "format specifier");
-      // TODO
-      ASSERT(format_num < 100, "Vertex sizes in input file are not supported.");
-      ASSERT(format_num / 10 == 0 || format_num / 10 == 1);
+      uint32_t format_num = read_number<uint32_t>(mapped_file, pos, current_line, length, "weight type");
+      if (format_num >= 100) {
+        parsing_exception(current_line, "header has invalid weight type: " + STR(format_num) +
+                          " (should be one of 00/01/10/11; note that vertex sizes are not supported)");
+      }
+      bool format_is_valid = (format_num / 10 == 0 || format_num / 10 == 1) && (format_num % 10 == 0 || format_num % 10 == 1);
+      if (!format_is_valid) {
+        parsing_exception(current_line, "header has invalid weight type: " + STR(format_num) + " (should be one of 00/01/10/11)");
+      }
       has_vertex_weights = (format_num / 10 == 1);
-      ASSERT(format_num % 10 == 0 || format_num % 10 == 1);
       has_edge_weights = (format_num % 10 == 1);
     }
   }
@@ -108,6 +112,7 @@ namespace mt_kahypar::io {
                                      size_t& current_line,
                                      const size_t length,
                                      const HyperedgeID num_hyperedges,
+                                     const HypernodeID num_hypernodes,
                                      const bool has_hyperedge_weights,
                                      HyperedgeVector& hyperedges,
                                      vec<HyperedgeWeight>& hyperedges_weight,
@@ -159,7 +164,12 @@ namespace mt_kahypar::io {
         Hyperedge hyperedge;
         while ( !is_line_ending(mapped_file, current_pos) ) {
           HypernodeID pin = read_number<HypernodeID>(mapped_file, current_pos, current_line, current_end, "vertex ID");
-          ASSERT(pin > 0, V(current_hyperedge_id));
+          if (pin == 0) {
+            parsing_exception(current_line, "0 is not a valid vertex ID; the hMETIS file format requires that IDs start at 1");
+          }
+          if (pin > num_hypernodes) {
+            parsing_exception(current_line, "invalid vertex ID: " + STR(pin) + " (larger than number of vertices)");
+          }
           hyperedge.push_back(pin - 1);
         }
         do_line_ending(mapped_file, current_pos, current_line);
@@ -216,7 +226,9 @@ namespace mt_kahypar::io {
     if ( has_hypernode_weights ) {
       hypernodes_weight.resize(num_hypernodes);
       for ( HypernodeID hn = 0; hn < num_hypernodes; ++hn ) {
-        ASSERT(pos > 0 && pos < length);
+        if (pos >= length) {
+          parsing_exception("found only " + STR(hn) + " hypernode weights, but there are " + STR(num_hypernodes) + " hypernodes");
+        }
         ASSERT(mapped_file[pos - 1] == '\n');
         hypernodes_weight[hn] = read_number<HypernodeWeight>(mapped_file, pos, current_line, length, "vertex weight");
         do_line_ending(mapped_file, pos, current_line);
@@ -249,7 +261,7 @@ namespace mt_kahypar::io {
     // Read Hyperedges
     HighResClockTimepoint hyperedges_start = std::chrono::high_resolution_clock::now();
     HyperedgeReadResult res =
-            readHyperedges(handle.mapped_file, pos, current_line, handle.length, num_hyperedges,
+            readHyperedges(handle.mapped_file, pos, current_line, handle.length, num_hyperedges, num_hypernodes,
               has_hyperedge_weights, hyperedges, hyperedges_weight, remove_single_pin_hes);
     num_hyperedges -= res.num_removed_single_pin_hyperedges;
     num_removed_single_pin_hyperedges = res.num_removed_single_pin_hyperedges;
@@ -384,7 +396,12 @@ namespace mt_kahypar::io {
 
         while ( !is_line_ending(mapped_file, current_pos) ) {
           const HypernodeID target = read_number<HypernodeID>(mapped_file, current_pos, current_line, current_end, "node ID");
-          ASSERT(target > 0 && (target - 1) < num_vertices, V(target));
+          if (target == 0) {
+            parsing_exception(current_line, "0 is not a valid node ID; the METIS file format requires that IDs start at 1");
+          }
+          if (target > num_vertices) {
+            parsing_exception(current_line, "invalid node ID: " + STR(target) + " (larger than number of nodes)");
+          }
 
           // process forward edges, ignore backward edges
           if ( current_vertex_id < (target - 1) ) {
@@ -407,7 +424,11 @@ namespace mt_kahypar::io {
     LOG << V(second_pass_time);
 
     // finally, we copy the local edge lists to the global list
-    copy_to_global_list(local_edges, edges);
+    size_t actual_num_edges = copy_to_global_list(local_edges, edges);
+    if (actual_num_edges != num_edges) {
+      parsing_exception("number of edges in header (=" + STR(num_edges) +
+                        ") does not match actual number of (forward) edges in file (=" + STR(actual_num_edges) + ")");
+    }
     if ( has_edge_weights ) {
       copy_to_global_list(local_edges_weight, edges_weight);
       ASSERT(edges.size() == edges_weight.size());

mt-kahypar/io/io_utils.h

@@ -209,12 +209,17 @@ void goto_next_line_unchecked(char* mapped_file, size_t& pos, size_t& current_li
   }
 }
 
+template<typename ResultType>
 MT_KAHYPAR_ATTRIBUTE_ALWAYS_INLINE
-int64_t read_number(char* mapped_file, size_t& pos, const size_t current_line, const size_t length) {
-  int64_t number = 0;
+ResultType read_number(char* mapped_file, size_t& pos, const size_t current_line, const size_t length, const char* expected_type) {
   while ( mapped_file[pos] == ' ' ) {
     ++pos;
   }
+  if ( is_line_ending(mapped_file, pos) ) {
+    parsing_exception(current_line, std::string("expected to find ") + expected_type + ", but line already ends");
+  }
+
+  ResultType number = 0;
   for ( ; pos < length; ++pos ) {
     if ( mapped_file[pos] == ' ' || is_line_ending(mapped_file, pos) ) {
       while ( mapped_file[pos] == ' ' ) {
@@ -225,6 +230,20 @@ int64_t read_number(char* mapped_file, size_t& pos, const size_t current_line, c
     if (mapped_file[pos] < '0' || mapped_file[pos] > '9') {
       parsing_exception(current_line, "invalid symbol: " + std::string(1, mapped_file[pos]));
     }
+
+    ResultType digit = mapped_file[pos] - '0';
+    if (number > (std::numeric_limits<ResultType>::max() - digit) / 10) {
+      // if the number would overflow, read the whole number and return a nice error message
+      std::string number_as_string = STR(number);
+      for ( ; mapped_file[pos] != ' ' && !is_line_ending(mapped_file, pos); ++pos ) {
+        number_as_string += mapped_file[pos];
+      }
+      std::string msg = std::string("number overflows input range for ") + expected_type + ": " + number_as_string;
+      if constexpr (sizeof(ResultType) < 8) {
+        msg += " (build with -DKAHYPAR_USE_64_BIT_IDS=ON to support larger ID ranges)";
+      }
+      parsing_exception(current_line, msg);
+    }
     number = number * 10 + (mapped_file[pos] - '0');
   }
   return number;
@@ -253,12 +272,14 @@ vec<LineRange> split_lines(char* mapped_file,
 
   // find line endings very fast
   line_positions.emplace_back(pos, current_line);
-  while ( line_positions.size() < expected_num_lines + 1 && pos < length ) {
+  while ( true ) {
     // skip comments
     while ( mapped_file[pos] == '%' && pos < length ) {
       goto_next_line_unchecked(mapped_file, pos, current_line, length);
     }
 
+    if ( line_positions.size() > expected_num_lines || pos >= length ) break;
+
     goto_next_line_unchecked(mapped_file, pos, current_line, length);
     line_positions.emplace_back(pos, current_line);
   }
@@ -298,7 +319,7 @@ vec<LineRange> split_lines(char* mapped_file,
 }
 
 template<typename T>
-void copy_to_global_list(const vec<vec<T>>& source, vec<T>& target) {
+size_t copy_to_global_list(const vec<vec<T>>& source, vec<T>& target) {
   vec<size_t> prefix_sum;
   prefix_sum.reserve(source.size() + 1);
   prefix_sum.push_back(0);
@@ -316,6 +337,7 @@ void copy_to_global_list(const vec<vec<T>>& source, vec<T>& target) {
       target[start + j] = source[i][j];
     }
   });
+  return prefix_sum.back();
 }
 
 }  // namespace io