flexflow · seemamirch · Apr 9, 2026 · Apr 9, 2026 · Apr 15, 2026 · Apr 15, 2026
diff --git a/.proj.toml b/.proj.toml
@@ -3,6 +3,7 @@ testsuite_macro = "FF_TEST_SUITE"
 namespace_name = "FlexFlow"
 header_extension = ".h"
 doxygen = true
+build_tool = "ninja"
 cuda_launch_cmd = [
   "nixGL",
   "--",

diff --git a/bin/run-model/src/run-model/main.cc b/bin/run-model/src/run-model/main.cc
@@ -71,46 +71,47 @@ int main(int argc, char **argv) {
   char **realm_argv = realm_args.data();
   RealmManager manager(&realm_argc, &realm_argv);
 
-  ControllerTaskResult result = manager.start_controller([&](RealmContext
-                                                                 &ctx) {
-    MappedParallelComputationGraph mpcg = [&]() {
-      std::ifstream f(mapped_pcg_json);
-      nlohmann::json mpcg_json = nlohmann::json::parse(f);
-      return from_v1(mpcg_json.get<V1MappedParallelComputationGraph>());
-    }();
-
-    // instantiate computation graph
-    OptimizerAttrs optimizer_attrs =
-        OptimizerAttrs{SGDOptimizerAttrs{/*lr=*/0.001,
-                                         /*momentum=*/0.9,
-                                         /*nesterov=*/false,
-                                         /*weight_decay=*/0.001}};
-
-    std::unordered_map<DynamicValueAttrs, DynamicTensorAccessor> input_tensors;
-
-    DistributedFfHandle device_handle =
-        create_distributed_ff_handle(ctx,
-                                     /*workSpaceSize=*/1024 * 1024,
-                                     /*allowTensorOpMathConversion=*/true);
-
-    PCGInstance pcg_instance = create_pcg_instance(
-        /*ctx=*/ctx,
-        /*mpcg=*/mpcg,
-        /*optimizer=*/optimizer_attrs,
-        /*loss=*/std::nullopt,
-        /*input_tensors=*/input_tensors,
-        /*profiling_settings=*/ProfilingSettings{0, 0},
-        /*device_handle=*/device_handle);
-
-    // begin training loop
-    int num_epochs = 5;
-    for (int i = 0; i < num_epochs; i++) {
-      perform_all_passes_for_pcg_instance(
-          /*instance=*/pcg_instance,
-          /*profiling_settings=*/ProfilingSettings{0, 1},
-          /*device_handle=*/device_handle);
-    }
-  });
+  ControllerTaskResult result =
+      manager.start_controller([&](RealmContext &ctx) {
+        MappedParallelComputationGraph mpcg = [&]() {
+          std::ifstream f(mapped_pcg_json);
+          nlohmann::json mpcg_json = nlohmann::json::parse(f);
+          return from_v1(mpcg_json.get<V1MappedParallelComputationGraph>());
+        }();
+
+        // instantiate computation graph
+        OptimizerAttrs optimizer_attrs =
+            OptimizerAttrs{SGDOptimizerAttrs{/*lr=*/0.001,
+                                             /*momentum=*/0.9,
+                                             /*nesterov=*/false,
+                                             /*weight_decay=*/0.001}};
+
+        std::map<DynamicValueAttrs, DynamicTensorAccessor> input_tensors;
+
+        DistributedFfHandle device_handle =
+            create_distributed_ff_handle(ctx,
+                                         /*workSpaceSize=*/1024 * 1024,
+                                         /*allowTensorOpMathConversion=*/true);
+
+        PCGInstance pcg_instance = create_pcg_instance(
+            /*ctx=*/ctx,
+            /*mpcg=*/mpcg,
+            /*optimizer=*/optimizer_attrs,
+            /*loss=*/std::nullopt,
+            /*input_tensors=*/input_tensors,
+            /*profiling_settings=*/ProfilingSettings{0, 0},
+            /*device_handle=*/device_handle,
+            /*device_type=*/DeviceType::GPU);
+
+        // begin training loop
+        int num_epochs = 5;
+        for (int i = 0; i < num_epochs; i++) {
+          perform_all_passes_for_pcg_instance(
+              /*instance=*/pcg_instance,
+              /*profiling_settings=*/ProfilingSettings{0, 1},
+              /*device_handle=*/device_handle);
+        }
+      });
   result.wait();
 
   return 0;

diff --git a/bin/sp-ization-benchmarking/include/sp-ization-benchmarking/distributions.h b/bin/sp-ization-benchmarking/include/sp-ization-benchmarking/distributions.h
@@ -2,9 +2,9 @@
 #define _FLEXFLOW_BIN_SP_IZATION_BENCHMARKING_INCLUDE_SP_IZATION_BENCHMARKING_DISTRIBUTIONS_H
 
 #include "utils/graph/node/node.dtg.h"
+#include <map>
 #include <random>
-#include <unordered_map>
-#include <unordered_set>
+#include <set>
 
 namespace FlexFlow {
 
@@ -55,21 +55,19 @@ struct GaussianNoise {
 };
 
 template <typename Dist>
-std::unordered_map<Node, float>
-    make_cost_map(std::unordered_set<Node> const &nodes,
-                  Dist const &distribution) {
-  std::unordered_map<Node, float> cost_map;
+std::map<Node, float> make_cost_map(std::set<Node> const &nodes,
+                                    Dist const &distribution) {
+  std::map<Node, float> cost_map;
   for (Node const &node : nodes) {
     cost_map[node] = distribution();
   }
   return cost_map;
 }
 
 template <typename Noise>
-std::unordered_map<Node, float>
-    add_noise_to_cost_map(std::unordered_map<Node, float> cost_map,
-                          Noise const &noise) {
-  std::unordered_map<Node, float> noisy_cost_map;
+std::map<Node, float> add_noise_to_cost_map(std::map<Node, float> cost_map,
+                                            Noise const &noise) {
+  std::map<Node, float> noisy_cost_map;
   for (auto const &[node, cost] : cost_map) {
     noisy_cost_map[node] = noise() * cost;
   }

diff --git a/bin/sp-ization-benchmarking/src/sp-ization-benchmarking/sample_graphs.cc b/bin/sp-ization-benchmarking/src/sp-ization-benchmarking/sample_graphs.cc
@@ -108,7 +108,7 @@ DiGraph make_full_taso_nasnet(size_t num_reduction_cells, size_t N) {
         (i % (N + 1) == N) ? make_reduction_taso_nasnet_cell()
                            : make_normal_taso_nasnet_cell();
     Node cell_output = get_only(get_terminal_nodes(s));
-    std::unordered_map<Node, Node> node_map = parallel_extend(g, s);
+    std::map<Node, Node> node_map = parallel_extend(g, s);
     later_input = node_map.at(later_input);
     earlier_input = node_map.at(earlier_input);
     cell_output = node_map.at(cell_output);
@@ -331,8 +331,8 @@ DiGraph make_2_terminal_random_dag(size_t num_nodes, float p, size_t step) {
       }
     }
   }
-  std::unordered_set<Node> sinks = get_terminal_nodes(g);
-  std::unordered_set<Node> sources = get_initial_nodes(g);
+  std::set<Node> sinks = get_terminal_nodes(g);
+  std::set<Node> sources = get_initial_nodes(g);
   Node sink = g.add_node();
   Node source = g.add_node();
   for (Node s : sources) {

diff --git a/flake.lock b/flake.lock
diff --git a/flake.nix b/flake.nix
@@ -155,6 +155,7 @@
               expect
               universal-ctags
               ninja
+              tig
             ])
             (with pkgs.python3Packages; [
               gitpython

diff --git a/lib/compiler/include/compiler/cost_estimator/op_cost_estimate_key.dtg.toml b/lib/compiler/include/compiler/cost_estimator/op_cost_estimate_key.dtg.toml
@@ -24,9 +24,8 @@ includes = [
 ]
 
 src_includes = [
-  "utils/hash/unordered_map.h",
-  "utils/fmt/unordered_map.h",
-  "utils/ord/unordered_map.h",
+  "utils/hash/map.h",
+  "utils/fmt/map.h",
 ]
 
 [[fields]]
@@ -35,15 +34,15 @@ type = "::FlexFlow::PCGOperatorAttrs"
 
 [[fields]]
 name = "input_shapes"
-type = "std::unordered_map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
+type = "std::map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
 
 [[fields]]
 name = "weight_shapes"
-type = "std::unordered_map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
+type = "std::map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
 
 [[fields]]
 name = "output_shapes"
-type = "std::unordered_map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
+type = "std::map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
 
 [[fields]]
 name = "optimizer_attrs"

diff --git a/lib/compiler/include/compiler/cost_estimator/op_cost_estimate_key.h b/lib/compiler/include/compiler/cost_estimator/op_cost_estimate_key.h
@@ -3,7 +3,6 @@
 
 #include "compiler/cost_estimator/op_cost_estimate_key.dtg.h"
 #include "compiler/cost_estimator/runtime_only_op_cost_estimate_key.dtg.h"
-#include "pcg/device_id_t.dtg.h"
 #include "pcg/machine_specification.dtg.h"
 #include "pcg/parallel_computation_graph/parallel_computation_graph.dtg.h"
 #include "pcg/parallel_computation_graph/parallel_layer_guid_t.dtg.h"

diff --git a/lib/compiler/include/compiler/cost_estimator/op_cost_metrics.dtg.toml b/lib/compiler/include/compiler/cost_estimator/op_cost_metrics.dtg.toml
@@ -3,6 +3,7 @@ name = "OpCostMetrics"
 type = "struct"
 features = [
   "eq",
+  "ord",
   "fmt",
   "hash",
 ]

diff --git a/lib/compiler/include/compiler/cost_estimator/op_cost_metrics.h b/lib/compiler/include/compiler/cost_estimator/op_cost_metrics.h
@@ -7,7 +7,7 @@
 namespace FlexFlow {
 
 bool is_pareto_optimal_in(OpCostMetrics const &,
-                          std::unordered_set<OpCostMetrics> const &);
+                          std::set<OpCostMetrics> const &);
 
 OpCostMetrics make_op_cost_metrics_from_runtime_only(
     RuntimeOnlyOpCostMetrics const &runtime_only,

diff --git a/lib/compiler/include/compiler/cost_estimator/runtime_only_op_cost_estimate_key.dtg.toml b/lib/compiler/include/compiler/cost_estimator/runtime_only_op_cost_estimate_key.dtg.toml
@@ -17,9 +17,8 @@ includes = [
 ]
 
 src_includes = [
-  "utils/hash/unordered_map.h",
-  "utils/ord/unordered_map.h",
-  "utils/fmt/unordered_map.h",
+  "utils/hash/map.h",
+  "utils/fmt/map.h",
 ]
 
 [[fields]]
@@ -28,15 +27,15 @@ type = "::FlexFlow::PCGOperatorAttrs"
 
 [[fields]]
 name = "input_shapes"
-type = "std::unordered_map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
+type = "std::map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
 
 [[fields]]
 name = "weight_shapes"
-type = "std::unordered_map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
+type = "std::map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
 
 [[fields]]
 name = "output_shapes"
-type = "std::unordered_map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
+type = "std::map<::FlexFlow::TensorSlotName, ::FlexFlow::ParallelTensorShape>"
 
 [[fields]]
 name = "machine_view"

diff --git a/lib/compiler/include/compiler/cost_estimator/single_tensor_movement.dtg.toml b/lib/compiler/include/compiler/cost_estimator/single_tensor_movement.dtg.toml
@@ -10,14 +10,14 @@ features = [
 includes = [
   "compiler/cost_estimator/communication_edge.h",
   "utils/units/num_bytes_t.h",
-  "<unordered_map>",
+  "<map>",
 ]
 
 src_includes = [
-  "utils/fmt/unordered_map.h",
-  "utils/hash/unordered_map.h",
+  "utils/fmt/map.h",
+  "utils/hash/map.h",
 ]
 
 [[fields]]
 name = "edge_to_size"
-type = "std::unordered_map<::FlexFlow::CommunicationEdge, ::FlexFlow::num_bytes_t>"
+type = "std::map<::FlexFlow::CommunicationEdge, ::FlexFlow::num_bytes_t>"
diff --git a/lib/compiler/include/compiler/cost_estimator/tensor_set_movement.dtg.toml b/lib/compiler/include/compiler/cost_estimator/tensor_set_movement.dtg.toml
@@ -3,21 +3,22 @@ name = "TensorSetMovement"
 type = "struct"
 features = [
   "eq",
+  "ord",
   "hash",
   "fmt",
 ]
 
 includes = [
   "compiler/cost_estimator/communication_edge.h",
   "utils/units/num_bytes_t.h",
-  "<unordered_map>",
+  "<map>",
 ]
 
 src_includes = [
-  "utils/fmt/unordered_map.h",
-  "utils/hash/unordered_map.h",
+  "utils/fmt/map.h",
+  "utils/hash/map.h",
 ]
 
 [[fields]]
 name = "edge_to_size"
-type = "std::unordered_map<::FlexFlow::CommunicationEdge, ::FlexFlow::num_bytes_t>"
+type = "std::map<::FlexFlow::CommunicationEdge, ::FlexFlow::num_bytes_t>"
diff --git a/...piler/include/compiler/machine_mapping/abstracted_tensor_set_movement/abstracted_device.h b/...piler/include/compiler/machine_mapping/abstracted_tensor_set_movement/abstracted_device.h
@@ -13,7 +13,7 @@ namespace FlexFlow {
 
 MachineSpaceCoordinate concretize_abstracted_device(
     AbstractedDevice const &abstracted_device,
-    std::unordered_map<BinaryTreePath, MachineSpaceStencil> const
+    std::map<BinaryTreePath, MachineSpaceStencil> const
         &machine_space_stencils);
 
 } // namespace FlexFlow

diff --git a/...hine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_communication_edge.h b/...hine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_communication_edge.h
@@ -14,7 +14,7 @@ std::optional<CommunicationEdge>
     concretize_abstracted_single_tensor_communication_edge(
         AbstractedSingleTensorCommunicationEdge const &edge,
         MachineSpaceStencil const &src_machine_stencil,
-        std::unordered_map<BinaryTreePath, MachineSpaceStencil> const
+        std::map<BinaryTreePath, MachineSpaceStencil> const
             &dst_machine_stencils);
 
 } // namespace FlexFlow

diff --git a/...machine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_movement.dtg.toml b/...machine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_movement.dtg.toml
@@ -3,6 +3,7 @@ name = "AbstractedSingleTensorMovement"
 type = "struct"
 features = [
   "eq",
+  "ord",
   "hash",
   "fmt",
   "json",
@@ -11,12 +12,12 @@ features = [
 includes = [
   "compiler/machine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_communication_edge.dtg.h",
   "utils/units/num_bytes_t.h",
-  "<unordered_map>",
+  "<map>",
 ]
 
 src_includes = [
-  "utils/fmt/unordered_map.h",
-  "utils/hash/unordered_map.h",
+  "utils/fmt/map.h",
+  "utils/hash/map.h",
 ]
 
 [[fields]]
@@ -25,4 +26,4 @@ type = "::FlexFlow::BinaryTreePath"
 
 [[fields]]
 name = "edge_to_size"
-type = "std::unordered_map<::FlexFlow::AbstractedSingleTensorCommunicationEdge, ::FlexFlow::num_bytes_t>"
+type = "std::map<::FlexFlow::AbstractedSingleTensorCommunicationEdge, ::FlexFlow::num_bytes_t>"
diff --git a/...mpiler/machine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_movement.h b/...mpiler/machine_mapping/abstracted_tensor_set_movement/abstracted_single_tensor_movement.h
@@ -8,25 +8,21 @@
 
 namespace FlexFlow {
 
-std::unordered_set<BinaryTreePath>
-    abstracted_single_tensor_movement_get_dst_layers(
-        AbstractedSingleTensorMovement const &);
+std::set<BinaryTreePath> abstracted_single_tensor_movement_get_dst_layers(
+    AbstractedSingleTensorMovement const &);
 
 AbstractedSingleTensorMovement merge_abstracted_single_tensor_movements(
-    std::unordered_multiset<AbstractedSingleTensorMovement> const &);
+    std::multiset<AbstractedSingleTensorMovement> const &);
 
 AbstractedSingleTensorMovement
     abstracted_single_tensor_movement_from_communications(
         BinaryTreePath const &src_op_tree_path,
-        std::unordered_set<AbstractedSingleTensorCommunication> const
-            &communications);
+        std::set<AbstractedSingleTensorCommunication> const &communications);
 
 TensorSetMovement concretize_abstracted_single_tensor_movement(
     AbstractedSingleTensorMovement const &,
-    std::unordered_map<BinaryTreePath, MachineSpaceStencil> const
-        &pre_machine_stencils,
-    std::unordered_map<BinaryTreePath, MachineSpaceStencil> const
-        &post_machine_stencils);
+    std::map<BinaryTreePath, MachineSpaceStencil> const &pre_machine_stencils,
+    std::map<BinaryTreePath, MachineSpaceStencil> const &post_machine_stencils);
 
 } // namespace FlexFlow
-Original file line number
+Diff line change
@@ Expand Up / @@ -155,6 +155,7 @@ @@
                   expect
                   universal-ctags
                   ninja
+                  tig
                 ])
                 (with pkgs.python3Packages; [
                   gitpython
@@ Expand Down @@