Update proj version, make changes to pass stricter CI

.gitignore

@@ -1,3 +1,6 @@
+# tag files
+tags
+
 # gdb history
 .gdb_history
 
@@ -176,7 +179,7 @@ cython_debug/
 # IDE
 .vscode/*
 
-# Docker container 
+# Docker container
 docker/config
 
 # yarn prettier module (for linting workflows)

bin/sp-ization-benchmarking/include/sp-ization-benchmarking/nasnet_bench_graph_generator.h

@@ -9,133 +9,29 @@
  * https://github.com/google-research/nasbench/blob/b94247037ee470418a3e56dcb83814e9be83f3a8/nasbench/api.py
  */
 
-#include "utils/containers/all_of.h"
-#include "utils/containers/repeat.h"
-#include "utils/containers/transform.h"
-#include "utils/graph/algorithms.h"
-#include "utils/graph/digraph/algorithms/get_edges.h"
-#include "utils/graph/digraph/algorithms/get_initial_nodes.h"
-#include "utils/graph/digraph/algorithms/get_terminal_nodes.h"
-#include "utils/graph/digraph/algorithms/is_acyclic.h"
-#include "utils/graph/digraph/algorithms/materialize_digraph_view.h"
-#include "utils/graph/digraph/algorithms/transitive_reduction.h"
-#include "utils/graph/instances/adjacency_digraph.h"
-#include "utils/graph/node/algorithms.h"
-#include "utils/graph/series_parallel/digraph_generation.h"
+#include "utils/graph/digraph/digraph.h"
+#include "utils/graph/digraph/digraph_view.h"
 #include "utils/nonnegative_int/nonnegative_int.h"
 #include <optional>
 #include <vector>
 
-using AdjacencyMatrix = std::vector<std::vector<bool>>;
 namespace FlexFlow {
 
-const nonnegative_int MIN_NODES = nonnegative_int{6};
-const nonnegative_int MAX_NODES = nonnegative_int{8};
-const nonnegative_int MIN_EDGES = nonnegative_int{8};
-const nonnegative_int MAX_EDGES = nonnegative_int{11};
-const nonnegative_int NUM_CELLS = nonnegative_int{9};
-
 struct NasNetBenchConfig {
-  AdjacencyMatrix adjacency_matrix;
+  std::vector<std::vector<bool>> adjacency_matrix;
 };
 
-bool is_valid_config(NasNetBenchConfig const &config) {
-  AdjacencyMatrix const &matrix = config.adjacency_matrix;
-  const size_t size = matrix.size();
-
-  auto is_valid_size = [](nonnegative_int s) {
-    return s >= MIN_NODES && s <= MAX_NODES;
-  };
-
-  auto is_square_matrix = [&](auto const &m) {
-    return all_of(m, [&](const auto &row) { return row.size() == size; });
-  };
-
-  auto is_upper_triangular = [&](auto const &m) {
-    for (size_t i = 0; i < size; ++i) {
-      for (size_t j = 0; j <= i; ++j) {
-        if (matrix[i][j]) {
-          return false;
-        }
-      }
-    }
-    return true;
-  };
-
-  return is_valid_size(nonnegative_int{size}) && is_square_matrix(matrix) &&
-         is_upper_triangular(matrix);
-}
-
-bool is_valid_cell(DiGraphView const &g) {
-  nonnegative_int n_edges = nonnegative_int{get_edges(g).size()};
-  nonnegative_int n_nodes = nonnegative_int{num_nodes(g)};
-  return (is_acyclic(g)) && (get_initial_nodes(g).size() == 1) &&
-         (get_terminal_nodes(g).size() == 1) && (n_edges <= MAX_EDGES) &&
-         (n_edges >= MIN_EDGES) && (n_nodes <= MAX_NODES) &&
-         (n_nodes >= MIN_NODES) &&
-         (n_edges > n_nodes); // filter linear cell and diamond cell
-}
+bool is_valid_config(NasNetBenchConfig const &config);
 
-NasNetBenchConfig generate_random_config() {
-  static std::uniform_int_distribution<> size_dist(
-      MIN_NODES.unwrap_nonnegative(), MAX_NODES.unwrap_nonnegative());
-  Binary bin = Binary(0, 1);
+bool is_valid_cell(DiGraphView const &g);
 
-  size_t num_nodes =
-      Uniform(MIN_NODES.unwrap_nonnegative(), MAX_NODES.unwrap_nonnegative())();
-  std::vector<std::vector<bool>> matrix(num_nodes,
-                                        std::vector<bool>(num_nodes, false));
-
-  for (size_t i = 0; i < num_nodes; ++i) {
-    for (size_t j = i + 1; j < num_nodes; ++j) {
-      matrix[i][j] = bin();
-    }
-  }
-
-  return {matrix};
-}
+NasNetBenchConfig generate_random_config();
 
 std::optional<DiGraph>
-    maybe_generate_nasnet_bench_cell(NasNetBenchConfig const &config) {
-  if (!is_valid_config(config)) {
-    return std::nullopt;
-  }
-
-  DiGraph g = DiGraph::create<AdjacencyDiGraph>();
-  std::vector<Node> nodes = add_nodes(g, config.adjacency_matrix.size());
-
-  for (size_t i = 0; i < nodes.size(); ++i) {
-    for (size_t j = i + 1; j < nodes.size(); ++j) {
-      if (config.adjacency_matrix[i][j]) {
-        g.add_edge(DirectedEdge{nodes[i], nodes[j]});
-      }
-    }
-  }
-
-  g = materialize_digraph_view<AdjacencyDiGraph>(transitive_reduction(g));
-
-  if (!is_valid_cell(g)) {
-    return std::nullopt;
-  }
+    maybe_generate_nasnet_bench_cell(NasNetBenchConfig const &config);
 
-  return g;
-}
+DiGraph generate_nasnet_bench_cell();
 
-DiGraph generate_nasnet_bench_cell() {
-  while (true) {
-    NasNetBenchConfig config = generate_random_config();
-    std::optional<DiGraph> maybe_cell =
-        maybe_generate_nasnet_bench_cell(config);
-    if (maybe_cell) {
-      return maybe_cell.value();
-    }
-  }
-}
+DiGraph generate_nasnet_bench_network();
 
-DiGraph generate_nasnet_bench_network() {
-  DiGraph g = series_composition(
-      transform(repeat(NUM_CELLS, generate_nasnet_bench_cell),
-                [](DiGraph const &cell) -> DiGraphView { return cell; }));
-  return g;
-}
 } // namespace FlexFlow

bin/sp-ization-benchmarking/src/sp-ization-benchmarking/nasnet_bench_graph_generator.cc

@@ -0,0 +1,137 @@
+#include "sp-ization-benchmarking/nasnet_bench_graph_generator.h"
+#include "utils/containers/all_of.h"
+#include "utils/containers/repeat.h"
+#include "utils/containers/transform.h"
+#include "utils/graph/algorithms.h"
+#include "utils/graph/digraph/algorithms/get_edges.h"
+#include "utils/graph/digraph/algorithms/get_initial_nodes.h"
+#include "utils/graph/digraph/algorithms/get_terminal_nodes.h"
+#include "utils/graph/digraph/algorithms/is_acyclic.h"
+#include "utils/graph/digraph/algorithms/materialize_digraph_view.h"
+#include "utils/graph/digraph/algorithms/transitive_reduction.h"
+#include "utils/graph/instances/adjacency_digraph.h"
+#include "utils/graph/node/algorithms.h"
+#include "utils/graph/series_parallel/digraph_generation.h"
+
+namespace FlexFlow {
+
+static const nonnegative_int MIN_NODES = nonnegative_int{6};
+static const nonnegative_int MAX_NODES = nonnegative_int{8};
+static const nonnegative_int MIN_EDGES = nonnegative_int{8};
+static const nonnegative_int MAX_EDGES = nonnegative_int{11};
+static const nonnegative_int NUM_CELLS = nonnegative_int{9};
+
+using AdjacencyMatrix = std::vector<std::vector<bool>>;
+
+bool is_valid_config(NasNetBenchConfig const &config) {
+  AdjacencyMatrix const &matrix = config.adjacency_matrix;
+  const size_t size = matrix.size();
+
+  auto is_valid_size = [](nonnegative_int s) {
+    return s >= MIN_NODES && s <= MAX_NODES;
+  };
+
+  auto is_square_matrix = [&](auto const &m) {
+    return all_of(m, [&](const auto &row) { return row.size() == size; });
+  };
+
+  auto is_upper_triangular = [&](auto const &m) {
+    for (size_t i = 0; i < size; ++i) {
+      for (size_t j = 0; j <= i; ++j) {
+        if (matrix[i][j]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+
+  return is_valid_size(nonnegative_int{size}) && is_square_matrix(matrix) &&
+         is_upper_triangular(matrix);
+}
+
+bool is_valid_cell(DiGraphView const &g) {
+  nonnegative_int n_edges = nonnegative_int{get_edges(g).size()};
+  nonnegative_int n_nodes = nonnegative_int{num_nodes(g)};
+  return (is_acyclic(g)) && (get_initial_nodes(g).size() == 1) &&
+         (get_terminal_nodes(g).size() == 1) && (n_edges <= MAX_EDGES) &&
+         (n_edges >= MIN_EDGES) && (n_nodes <= MAX_NODES) &&
+         (n_nodes >= MIN_NODES) &&
+         (n_edges > n_nodes); // filter linear cell and diamond cell
+}
+
+NasNetBenchConfig generate_random_config() {
+  static std::uniform_int_distribution<> size_dist(
+      MIN_NODES.unwrap_nonnegative(), MAX_NODES.unwrap_nonnegative());
+  Binary bin = Binary(0, 1);
+
+  size_t num_nodes =
+      Uniform(MIN_NODES.unwrap_nonnegative(), MAX_NODES.unwrap_nonnegative())();
+  std::vector<std::vector<bool>> matrix(num_nodes,
+                                        std::vector<bool>(num_nodes, false));
+
+  for (size_t i = 0; i < num_nodes; ++i) {
+    for (size_t j = i + 1; j < num_nodes; ++j) {
+      matrix[i][j] = bin();
+    }
+  }
+
+  return {matrix};
+}
+
+std::optional<DiGraph>
+    maybe_generate_nasnet_bench_cell(NasNetBenchConfig const &config) {
+  if (!is_valid_config(config)) {
+    return std::nullopt;
+  }
+
+  DiGraph g = DiGraph::create<AdjacencyDiGraph>();
+  std::vector<Node> nodes = add_nodes(g, config.adjacency_matrix.size());
+
+  for (size_t i = 0; i < nodes.size(); ++i) {
+    for (size_t j = i + 1; j < nodes.size(); ++j) {
+      if (config.adjacency_matrix[i][j]) {
+        g.add_edge(DirectedEdge{nodes[i], nodes[j]});
+      }
+    }
+  }
+
+  g = materialize_digraph_view<AdjacencyDiGraph>(transitive_reduction(g));
+
+  if (!is_valid_cell(g)) {
+    return std::nullopt;
+  }
+
+  return g;
+}
+
+DiGraph generate_nasnet_bench_cell() {
+  while (true) {
+    NasNetBenchConfig config = generate_random_config();
+    std::optional<DiGraph> maybe_cell =
+        maybe_generate_nasnet_bench_cell(config);
+    if (maybe_cell) {
+      return maybe_cell.value();
+    }
+  }
+}
+
+DiGraph generate_nasnet_bench_cell() {
+  while (true) {
+    NasNetBenchConfig config = generate_random_config();
+    std::optional<DiGraph> maybe_cell =
+        maybe_generate_nasnet_bench_cell(config);
+    if (maybe_cell) {
+      return maybe_cell.value();
+    }
+  }
+}
+
+DiGraph generate_nasnet_bench_network() {
+  DiGraph g = series_composition(
+      transform(repeat(NUM_CELLS, generate_nasnet_bench_cell),
+                [](DiGraph const &cell) -> DiGraphView { return cell; }));
+  return g;
+}
+
+} // namespace FlexFlow

bin/sp-ization-benchmarking/src/sp-ization-benchmarking/sample_graphs.cc

@@ -0,0 +1 @@
+#include "sp-ization-benchmarking/sample_graphs.h"

cmake/flexflow-utils.cmake

@@ -8,7 +8,7 @@ macro(ff_parse_args)
 endmacro()
 
 function(define_ff_vars target)
-  target_compile_definitions(${target} PRIVATE 
+  target_compile_definitions(${target} PRIVATE
     MAX_OPNAME=${FF_MAX_OPNAME}
     MAX_NUM_OUTPUTS=${FF_MAX_NUM_OUTPUTS}
     MAX_NUM_INPUTS=${FF_MAX_NUM_INPUTS}
@@ -41,24 +41,24 @@ function(ff_set_cxx_properties target)
       CXX_EXTENSIONS NO
   )
   target_compile_options(${target}
-    PUBLIC 
-    $<$<COMPILE_LANGUAGE:CXX>:> 
-    "-ffile-prefix-map=${CMAKE_SOURCE_DIR}=." 
-    "-fsanitize=undefined" 
+    PUBLIC
+    $<$<COMPILE_LANGUAGE:CXX>:>
+    "-ffile-prefix-map=${CMAKE_SOURCE_DIR}=."
+    "-fsanitize=undefined"
     "-fno-sanitize-recover=all"
     # add C++ compile flags here
   )
   target_link_options(${target}
-    PUBLIC 
-    $<$<COMPILE_LANGUAGE:CXX>:> 
-    "-fsanitize=undefined" 
+    PUBLIC
+    $<$<COMPILE_LANGUAGE:CXX>:>
+    "-fsanitize=undefined"
     "-fno-sanitize-recover=all"
   )
 endfunction()
 
 function(ff_add_library)
   ff_parse_args(
-    PREFIX 
+    PREFIX
       FF_LIBRARY
     ARGS
       NAME
@@ -71,10 +71,10 @@ function(ff_add_library)
     PARSE
       ${ARGN}
   )
-  
+
   project(${FF_LIBRARY_NAME})
   file(GLOB_RECURSE SRC
-       CONFIGURE_DEPENDS 
+       CONFIGURE_DEPENDS
        LIST_DIRECTORIES False
        ${FF_LIBRARY_SRC_PATTERNS})
 
@@ -103,7 +103,7 @@ endfunction()
 
 function(ff_add_test_executable)
   ff_parse_args(
-    PREFIX 
+    PREFIX
       FF_TEST_EXEC
     ARGS
       NAME
@@ -145,7 +145,7 @@ endfunction()
 
 function(ff_add_benchmark_executable)
   ff_parse_args(
-    PREFIX 
+    PREFIX
       FF_BENCHMARK_EXEC
     ARGS
       NAME
@@ -172,6 +172,11 @@ function(ff_add_benchmark_executable)
     ${FF_BENCHMARK_EXEC_NAME}
     ${SRC})
 
+  target_include_directories(
+    ${FF_BENCHMARK_EXEC_NAME}
+    PRIVATE
+    ${FF_BENCHMARK_EXEC_PRIVATE_INCLUDE})
+
   target_link_libraries(
     ${FF_BENCHMARK_EXEC_NAME}
     ${FF_BENCHMARK_EXEC_DEPS}
@@ -184,7 +189,7 @@ endfunction()
 
 function(ff_add_executable)
   ff_parse_args(
-    PREFIX 
+    PREFIX
       FF_EXEC
     ARGS
       NAME