From 9e2e1e60d51f8753e48c660993899766b850290d Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Wed, 16 Aug 2023 16:13:34 -0600
Subject: [PATCH 01/15] WIP: Add (de)serialization support for data structures
 in lib/pcg.

  - Have types use the visitable interface.

  - Add stubs for functions/methods that have a declaration but not definition.
    These should fail with a "not implemented" message.

  - Some code clean up. Remove unnecessary constructors. Delete code that has
    been commented out. Remove files that don't contain any non-header files
    that do not contain any executable code.
---
 .../include/op-attrs/parallel_tensor_dims.h   |  9 ++-
 .../include/op-attrs/parallel_tensor_shape.h  |  6 +-
 lib/op-attrs/include/op-attrs/tensor_shape.h  | 17 ++---
 lib/pcg/CMakeLists.txt                        |  1 +
 .../include/pcg/computation_graph_builder.h   | 16 ++---
 lib/pcg/include/pcg/file_format/v1/graphs.h   | 15 +++-
 .../include/pcg/file_format/v1/initializer.h  |  3 +
 .../pcg/file_format/v1/parallel_tensor.h      | 17 ++++-
 .../include/pcg/file_format/v1/param_sync.h   |  3 +
 lib/pcg/include/pcg/file_format/v1/tensor.h   |  6 +-
 lib/pcg/include/pcg/file_format/v1/v1.h       | 13 +++-
 lib/pcg/include/pcg/layer.h                   | 12 ++--
 lib/pcg/include/pcg/operator.h                | 17 ++---
 lib/pcg/include/pcg/parallel_tensor.h         | 10 ++-
 lib/pcg/include/pcg/tensor.h                  | 11 +--
 lib/pcg/src/file_format/v1/graphs.cc          |  4 ++
 lib/pcg/src/file_format/v1/tensor.cc          | 16 +++++
 lib/pcg/src/layer.cc                          |  9 ---
 lib/pcg/test/CMakeLists.txt                   | 28 ++++++++
 lib/pcg/test/doctest.h                        | 70 +++++++++++++++++++
 lib/pcg/test/main.cc                          |  2 +
 lib/pcg/test/test_tensor.cc                   | 14 ++++
 lib/utils/include/utils/graph/algorithms.h    |  2 +
 lib/utils/include/utils/graph/cow_ptr_t.h     |  4 +-
 lib/utils/include/utils/graph/multidigraph.h  |  1 +
 .../utils/graph/multidigraph_interfaces.h     |  1 +
 lib/utils/src/graph/adjacency_digraph.cc      |  4 ++
 lib/utils/src/graph/adjacency_multidigraph.cc |  5 ++
 lib/utils/src/graph/algorithms.cc             | 17 +++++
 lib/utils/src/graph/digraph.cc                | 17 +++++
 30 files changed, 266 insertions(+), 84 deletions(-)
 create mode 100644 lib/pcg/src/file_format/v1/tensor.cc
 delete mode 100644 lib/pcg/src/layer.cc
 create mode 100644 lib/pcg/test/CMakeLists.txt
 create mode 100644 lib/pcg/test/doctest.h
 create mode 100644 lib/pcg/test/main.cc
 create mode 100644 lib/pcg/test/test_tensor.cc

diff --git a/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h b/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
index d38ba75232..d7b25aecd5 100644
--- a/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
+++ b/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
@@ -6,7 +6,7 @@
 
 namespace FlexFlow {
 
-struct ParallelTensorDims : public use_visitable_cmp<ParallelTensorDims> {
+struct ParallelTensorDims {
   explicit ParallelTensorDims(TensorDims const &);
 
   size_t get_volume() const;
@@ -38,16 +38,15 @@ struct ParallelTensorDims : public use_visitable_cmp<ParallelTensorDims> {
   const_reverse_iterator crend() const;
 
 public:
-  FFOrdered<ParallelDim> data;
+  req<FFOrdered<ParallelDim>> data;
 };
 
+FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(ParallelTensorDims, data);
+
 bool is_valid(ParallelTensorDims const &);
 TensorDims get_piece_dims(ParallelTensorDims const &);
 TensorDims get_tensor_dims_unsafe(ParallelTensorDims const &);
 
 } // namespace FlexFlow
 
-VISITABLE_STRUCT(::FlexFlow::ParallelTensorDims, data);
-MAKE_VISIT_HASHABLE(::FlexFlow::ParallelTensorDims);
-
 #endif
diff --git a/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h b/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
index fd560352bb..7ebfa947de 100644
--- a/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
+++ b/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
@@ -16,7 +16,7 @@ namespace FlexFlow {
 /**
  * @brief Represent the shape of a ParallelTensor.
  */
-struct ParallelTensorShape : public use_visitable_cmp<ParallelTensorShape> {
+struct ParallelTensorShape {
   ParallelTensorShape() = delete;
 
   template <typename Dims>
@@ -36,6 +36,7 @@ struct ParallelTensorShape : public use_visitable_cmp<ParallelTensorShape> {
   ParallelTensorDims dims;
   DataType data_type;
 };
+FF_VISITABLE_STRUCT(ParallelTensorShape, dims, data_type);
 
 TensorShape get_piece_shape(ParallelTensorShape const &);
 int get_num_replica_dims(ParallelTensorShape const &);
@@ -49,7 +50,4 @@ std::vector<TensorShape>
 
 } // namespace FlexFlow
 
-VISITABLE_STRUCT(::FlexFlow::ParallelTensorShape, data_type, dims);
-MAKE_VISIT_HASHABLE(::FlexFlow::ParallelTensorShape);
-
 #endif
diff --git a/lib/op-attrs/include/op-attrs/tensor_shape.h b/lib/op-attrs/include/op-attrs/tensor_shape.h
index fa34860817..2c0cd562d2 100644
--- a/lib/op-attrs/include/op-attrs/tensor_shape.h
+++ b/lib/op-attrs/include/op-attrs/tensor_shape.h
@@ -11,24 +11,17 @@ namespace FlexFlow {
 
 using TensorDims = FFOrdered<size_t>;
 
-struct TensorShape : public use_visitable_cmp<TensorShape> {
-  TensorShape() = delete;
-
-  template <typename Dims>
-  TensorShape(Dims const &dims, DataType data_type)
-      : dims(dims), data_type(data_type) {}
-
+struct TensorShape {
   size_t at(ff_dim_t) const;
   size_t operator[](ff_dim_t) const;
 
 public:
-  TensorDims dims;
-  DataType data_type;
+  req<TensorDims> dims;
+  req<DataType> data_type;
 };
 
-} // namespace FlexFlow
+FF_VISITABLE_STRUCT(TensorShape, dims, data_type);
 
-VISITABLE_STRUCT(::FlexFlow::TensorShape, dims, data_type);
-MAKE_VISIT_HASHABLE(::FlexFlow::TensorShape);
+} // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/CMakeLists.txt b/lib/pcg/CMakeLists.txt
index 81009b0f1f..e1875ca694 100644
--- a/lib/pcg/CMakeLists.txt
+++ b/lib/pcg/CMakeLists.txt
@@ -13,3 +13,4 @@ ff_add_library(
 )
 
 add_subdirectory(ffi)
+add_subdirectory(test)
diff --git a/lib/pcg/include/pcg/computation_graph_builder.h b/lib/pcg/include/pcg/computation_graph_builder.h
index 7f01439712..2722214251 100644
--- a/lib/pcg/include/pcg/computation_graph_builder.h
+++ b/lib/pcg/include/pcg/computation_graph_builder.h
@@ -5,11 +5,8 @@
 
 namespace FlexFlow {
 
-struct ComputationGraphBuilder
-    : public use_visitable_cmp<ComputationGraphBuilder> {
+struct ComputationGraphBuilder {
 public:
-  ComputationGraphBuilder();
-
   // C++ APIs for constructing models
   // Add an exp layer
   Tensor exp(Tensor const &, optional<std::string> const &name = nullopt);
@@ -280,16 +277,11 @@ struct ComputationGraphBuilder
                     optional<std::string> const &name = nullopt);
 
 public:
-  ComputationGraph computation_graph;
+  req<ComputationGraph> computation_graph;
 };
 
-} // namespace FlexFlow
-
-VISITABLE_STRUCT(::FlexFlow::ComputationGraphBuilder, computation_graph);
+FF_VISITABLE_STRUCT(ComputationGraphBuilder, computation_graph);
 
-namespace FlexFlow {
-static_assert(
-    is_well_behaved_value_type_no_hash<ComputationGraphBuilder>::value, "");
-}
+} // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/file_format/v1/graphs.h b/lib/pcg/include/pcg/file_format/v1/graphs.h
index 71a8adb344..09d6f1ad0e 100644
--- a/lib/pcg/include/pcg/file_format/v1/graphs.h
+++ b/lib/pcg/include/pcg/file_format/v1/graphs.h
@@ -16,6 +16,7 @@ struct V1GraphOutput {
   req<size_t> srcNode;
   req<size_t> srcIdx;
 };
+
 FF_VISITABLE_STRUCT(V1GraphOutput, srcNode, srcIdx);
 CHECK_IS_JSONABLE(V1GraphOutput);
 
@@ -25,6 +26,7 @@ struct V1GraphEdge {
   req<size_t> dstNode;
   req<size_t> dstIdx;
 };
+
 FF_VISITABLE_STRUCT(V1GraphEdge, srcNode, srcIdx, dstNode, dstIdx);
 CHECK_IS_JSONABLE(V1GraphEdge);
 
@@ -33,6 +35,7 @@ struct V1MultiDiGraph {
   req<std::vector<size_t>> ports;
   req<std::unordered_set<V1GraphEdge>> edges;
 };
+
 FF_VISITABLE_STRUCT(V1MultiDiGraph, nodes, ports, edges);
 CHECK_IS_JSONABLE(V1MultiDiGraph);
 V1MultiDiGraph to_v1(MultiDiGraphView const &);
@@ -55,6 +58,7 @@ struct V1Layer {
   V1CompGraphOperatorAttrs attrs;
   req<optional<std::string>> name;
 };
+
 FF_VISITABLE_STRUCT(V1Layer, attrs, name);
 V1Layer to_v1(Layer const &);
 
@@ -64,8 +68,17 @@ FF_VISITABLE_STRUCT(
 CHECK_IS_JSONABLE(V1ComputationGraph);
 V1ComputationGraph to_v1(ComputationGraph const &);
 
+struct V1Operator {
+  V1PCGOperatorAttrs attrs;
+  req<optional<std::string>> name;
+};
+
+FF_VISITABLE_STRUCT(V1Operator, attrs, name);
+V1Operator to_v1(Operator const &);
+
 using V1ParallelComputationGraph =
-    V1JsonableGraph<V1PCGOperatorAttrs, V1ParallelTensor>;
+    V1JsonableGraph<V1Operator, V1ParallelTensor>;
+
 FF_VISITABLE_STRUCT(
     V1ParallelComputationGraph, node_labels, outputs, output_labels, graph);
 CHECK_IS_JSONABLE(V1ParallelComputationGraph);
diff --git a/lib/pcg/include/pcg/file_format/v1/initializer.h b/lib/pcg/include/pcg/file_format/v1/initializer.h
index 24f0320bd9..17272218ae 100644
--- a/lib/pcg/include/pcg/file_format/v1/initializer.h
+++ b/lib/pcg/include/pcg/file_format/v1/initializer.h
@@ -2,6 +2,7 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_INITIALIZER_H
 
 #include "data_type.h"
+#include "pcg/initializer.h"
 #include "utils/json.h"
 #include "utils/required.h"
 #include "utils/variant.h"
@@ -43,6 +44,8 @@ using V1Initializer = variant<V1GlorotInitializer,
                               V1NormInitializer,
                               V1ConstantInitializer>;
 
+V1Initializer to_v1(Initializer const &);
+
 } // namespace FlexFlow
 
 namespace FlexFlow {
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
index 1ea4cd04de..d8a2a00ee4 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
@@ -4,6 +4,7 @@
 #include "data_type.h"
 #include "initializer.h"
 #include "param_sync.h"
+#include "pcg/parallel_tensor.h"
 #include "utils/json.h"
 #include "utils/variant.h"
 #include "utils/visitable.h"
@@ -15,22 +16,32 @@ struct V1ParallelDim {
   req<int> degree;
   req<bool> is_replica_dim;
 };
+
 FF_VISITABLE_STRUCT(V1ParallelDim, size, degree, is_replica_dim);
+CHECK_IS_JSONABLE(V1ParallelDim);
+V1ParallelDim to_v1(ParallelDim const &);
 
 struct V1ParallelTensorShape {
   req<std::vector<V1ParallelDim>> dims;
   req<V1DataType> data_type;
 };
+
 FF_VISITABLE_STRUCT(V1ParallelTensorShape, dims, data_type);
+CHECK_IS_JSONABLE(V1ParallelTensorShape);
+V1ParallelTensorShape to_v1(ParallelTensorShape const &);
 
 struct V1ParallelTensor {
   V1ParallelTensorShape shape;
-  req<optional<V1ParamSync>> sync_type;
+  req<bool> create_gradients;
   req<optional<V1Initializer>> initializer;
-  req<bool> create_grad;
+  req<optional<V1ParamSync>> sync_type;
+  req<optional<std::string>> name;
 };
+
 FF_VISITABLE_STRUCT(
-    V1ParallelTensor, shape, sync_type, initializer, create_grad);
+    V1ParallelTensor, shape, create_gradients, initializer, sync_type, name);
+CHECK_IS_JSONABLE(V1ParallelTensor);
+V1ParallelTensor to_v1(ParallelTensor const &);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/param_sync.h b/lib/pcg/include/pcg/file_format/v1/param_sync.h
index 32769a8d20..286abd9c11 100644
--- a/lib/pcg/include/pcg/file_format/v1/param_sync.h
+++ b/lib/pcg/include/pcg/file_format/v1/param_sync.h
@@ -1,12 +1,15 @@
 #ifndef _FLEXFLOW_PCG_FILE_FORMAT_V1_PARAM_SYNC_H
 #define _FLEXFLOW_PCG_FILE_FORMAT_V1_PARAM_SYNC_H
 
+#include "op-attrs/param_sync.h"
 #include "utils/json.h"
 
 namespace FlexFlow {
 
 enum class V1ParamSync { PARAM_SERVER, NCCL };
 
+V1ParamSync to_v1(ParamSync const &);
+
 NLOHMANN_JSON_SERIALIZE_ENUM(V1ParamSync,
                              {{V1ParamSync::PARAM_SERVER, "PARAM_SERVER"},
                               {V1ParamSync::NCCL, "NCCL"}});
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor.h b/lib/pcg/include/pcg/file_format/v1/tensor.h
index e1f6828186..7aaf0012de 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor.h
@@ -17,18 +17,20 @@ struct V1TensorShape {
 };
 FF_VISITABLE_STRUCT(V1TensorShape, dims, data_type);
 CHECK_IS_JSONABLE(V1TensorShape);
+
 V1TensorShape to_v1(TensorShape const &);
 
 struct V1Tensor {
   V1TensorShape shape;
-  req<optional<V1Initializer>> initializer;
   req<bool> create_gradients;
+  req<optional<V1Initializer>> initializer;
   req<optional<V1ParamSync>> sync_type;
   req<optional<std::string>> name;
 };
 FF_VISITABLE_STRUCT(
-    V1Tensor, shape, initializer, create_gradients, sync_type, name);
+    V1Tensor, shape, create_gradients, initializer, sync_type, name);
 CHECK_IS_JSONABLE(V1Tensor);
+
 V1Tensor to_v1(Tensor const &);
 
 } // namespace FlexFlow
diff --git a/lib/pcg/include/pcg/file_format/v1/v1.h b/lib/pcg/include/pcg/file_format/v1/v1.h
index e2557af4f5..afaa4f08b9 100644
--- a/lib/pcg/include/pcg/file_format/v1/v1.h
+++ b/lib/pcg/include/pcg/file_format/v1/v1.h
@@ -4,6 +4,17 @@
 #include "graphs.h"
 #include "pcg/computation_graph.h"
 
-namespace FlexFlow {}
+namespace FlexFlow {
+
+template <typename V1T, typename T>
+optional<V1T> to_v1(optional<T> const &t) {
+  if (t.has_value()) {
+    return to_v1(t.value());
+  } else {
+    return nullopt;
+  }
+}
+
+} // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/layer.h b/lib/pcg/include/pcg/layer.h
index 6e9415a8fb..e17eef3875 100644
--- a/lib/pcg/include/pcg/layer.h
+++ b/lib/pcg/include/pcg/layer.h
@@ -7,16 +7,14 @@
 
 namespace FlexFlow {
 
-struct Layer : public use_visitable_cmp<Layer> {
+struct Layer {
 public:
-  Layer() = delete;
-  Layer(CompGraphOperatorAttrs const &attrs, optional<std::string> const &name);
-
-public:
-  optional<stack_string<MAX_OPNAME>> name;
-  CompGraphOperatorAttrs attrs;
+  req<CompGraphOperatorAttrs> attrs;
+  req<optional<stack_string<MAX_OPNAME>>> name;
 };
 
+FF_VISITABLE_STRUCT(Layer, attrs, name);
+
 } // namespace FlexFlow
 
 VISITABLE_STRUCT(::FlexFlow::Layer, attrs, name);
diff --git a/lib/pcg/include/pcg/operator.h b/lib/pcg/include/pcg/operator.h
index c7a49bb57e..1f5a004680 100644
--- a/lib/pcg/include/pcg/operator.h
+++ b/lib/pcg/include/pcg/operator.h
@@ -8,24 +8,17 @@
 
 namespace FlexFlow {
 
-struct Operator : public use_visitable_cmp<Operator> {
+struct Operator {
 public:
-  Operator() = delete;
-  Operator(PCGOperatorAttrs const &attrs, optional<std::string> const &name);
-
   operator PCGOperatorAttrs() const;
 
 public:
-  PCGOperatorAttrs attrs;
+  req<PCGOperatorAttrs> attrs;
+  req<optional<stack_string<MAX_OPNAME>>> name;
 };
 
-} // namespace FlexFlow
-
-VISITABLE_STRUCT(::FlexFlow::Operator, attrs);
-MAKE_VISIT_HASHABLE(::FlexFlow::Operator);
+FF_VISITABLE_STRUCT(Operator, attrs, name);
 
-namespace FlexFlow {
-static_assert(is_well_behaved_value_type<Operator>::value, "");
-}
+} // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/parallel_tensor.h b/lib/pcg/include/pcg/parallel_tensor.h
index eadc83d9fd..1a83edc93f 100644
--- a/lib/pcg/include/pcg/parallel_tensor.h
+++ b/lib/pcg/include/pcg/parallel_tensor.h
@@ -50,9 +50,10 @@ struct ParallelTensor : public use_visitable_cmp<ParallelTensor> {
 public:
   ParallelTensorDims dims;
   DataType data_type;
+  CreateGrad create_gradients;
   optional<ParamSync> sync_type = nullopt;
   optional<Initializer> initializer = nullopt;
-  CreateGrad create_gradients;
+  optional<std::string> name = nullopt;
 };
 
 using ParallelParameter = ParallelTensor;
@@ -64,11 +65,8 @@ VISITABLE_STRUCT(::FlexFlow::ParallelTensor,
                  data_type,
                  sync_type,
                  initializer,
-                 create_gradients);
+                 create_gradients,
+                 name);
 MAKE_VISIT_HASHABLE(::FlexFlow::ParallelTensor);
 
-namespace FlexFlow {
-static_assert(is_well_behaved_value_type<ParallelTensor>::value, "");
-}
-
 #endif
diff --git a/lib/pcg/include/pcg/tensor.h b/lib/pcg/include/pcg/tensor.h
index cb79be245a..706516bd15 100644
--- a/lib/pcg/include/pcg/tensor.h
+++ b/lib/pcg/include/pcg/tensor.h
@@ -9,12 +9,6 @@
 namespace FlexFlow {
 
 struct Tensor {
-  /* Tensor() = delete; */
-  /* Tensor(TensorShape const &, */
-  /*        CreateGrad create_gradients, */
-  /*        optional<Initializer const &> initializer = nullopt, */
-  /*        optional<ParamSync> sync_type = nullopt); */
-
   size_t get_volume() const;
   TensorShape get_shape() const;
   int num_dims() const;
@@ -24,12 +18,13 @@ struct Tensor {
 public:
   TensorDims dims;
   DataType data_type;
-  req<optional<Initializer>> initializer;
   req<bool> create_gradients;
+  req<optional<Initializer>> initializer;
   req<optional<ParamSync>> sync_type;
+  req<optional<std::string>> name;
 };
 FF_VISITABLE_STRUCT(
-    Tensor, dims, data_type, initializer, create_gradients, sync_type);
+    Tensor, dims, data_type, create_gradients, initializer, sync_type, name);
 
 using Parameter = Tensor;
 
diff --git a/lib/pcg/src/file_format/v1/graphs.cc b/lib/pcg/src/file_format/v1/graphs.cc
index 519c38448b..0ad71b3ab4 100644
--- a/lib/pcg/src/file_format/v1/graphs.cc
+++ b/lib/pcg/src/file_format/v1/graphs.cc
@@ -55,4 +55,8 @@ V1ComputationGraph to_v1(ComputationGraph const &g) {
   return to_v1<Layer, Tensor>(g.value());
 }
 
+V1ParallelComputationGraph to_v1(ParallelComputationGraph const &g) {
+  return to_v1<Operator, ParallelTensor>(g.value());
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/tensor.cc b/lib/pcg/src/file_format/v1/tensor.cc
new file mode 100644
index 0000000000..55bc71ce0d
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/tensor.cc
@@ -0,0 +1,16 @@
+#include "pcg/file_format/v1/tensor.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1Tensor to_v1(Tensor const &t) {
+  return {
+      to_v1(t.get_shape()),
+      t.create_gradients,
+      to_v1<V1Initializer>(t.initializer),
+      to_v1<V1ParamSync>(t.sync_type),
+      t.name,
+  };
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/layer.cc b/lib/pcg/src/layer.cc
deleted file mode 100644
index 27d5b31003..0000000000
--- a/lib/pcg/src/layer.cc
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "pcg/layer.h"
-
-namespace FlexFlow {
-
-Layer::Layer(CompGraphOperatorAttrs const &_attrs,
-             optional<std::string> const &_name)
-    : attrs(_attrs), name(_name) {}
-
-} // namespace FlexFlow
diff --git a/lib/pcg/test/CMakeLists.txt b/lib/pcg/test/CMakeLists.txt
new file mode 100644
index 0000000000..df1321f05f
--- /dev/null
+++ b/lib/pcg/test/CMakeLists.txt
@@ -0,0 +1,28 @@
+set(test_target pcg-test)
+project(${test_target})
+
+file(GLOB_RECURSE SRC
+     CONFIGURE_DEPENDS
+     LIST_DIRECTORIES False
+     *.cc)
+
+add_executable(
+  ${test_target}
+  ${SRC})
+
+define_ff_vars(${test_target})
+
+target_link_libraries(
+  ${test_target}
+  pcg
+  utils
+  doctest::doctest)
+
+set_target_properties(
+  ${test_target}
+  PROPERTIES
+    CXX_STANDARD 11
+    CXX_STANDARD_REQUIRED YES
+    CXX_EXTENSIONS NO
+)
+doctest_discover_tests(${test_target})
diff --git a/lib/pcg/test/doctest.h b/lib/pcg/test/doctest.h
new file mode 100644
index 0000000000..891cc81d32
--- /dev/null
+++ b/lib/pcg/test/doctest.h
@@ -0,0 +1,70 @@
+#include "doctest/doctest.h"
+#include "utils/containers.h"
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace doctest {
+
+template <typename InputIt, typename Stringifiable = std::string>
+std::string
+    doctest_print_container(InputIt first,
+                            InputIt last,
+                            std::string const &open,
+                            std::string const &delimiter,
+                            std::string const &close,
+                            std::function<Stringifiable(InputIt)> const &f) {
+  if (first == last) {
+    return open + "(empty)" + close;
+  } else {
+    return open + join_strings(first, last, delimiter, f) + close;
+  }
+}
+
+template <typename InputIt>
+std::string doctest_print_container(InputIt first,
+                                    InputIt last,
+                                    std::string const &open,
+                                    std::string const &delimiter,
+                                    std::string const &close) {
+  return doctest_print_container<InputIt, decltype(*first)>(
+      first, last, open, delimiter, close, [](InputIt ref) { return *ref; });
+}
+
+template <typename Container>
+std::string doctest_print_container(Container const &c,
+                                    std::string const &open,
+                                    std::string const &delimiter,
+                                    std::string const &close) {
+  return doctest_print_container<decltype(c.cbegin())>(
+      c.cbegin(), c.cend(), open, delimiter, close);
+}
+
+template <typename T>
+struct StringMaker<std::unordered_set<T>> {
+  static String convert(std::unordered_set<T> const &s) {
+    return doctest_print_container(s, "{ ", ", ", " }").c_str();
+  }
+};
+
+template <typename K, typename V>
+struct StringMaker<std::unordered_map<K, V>> {
+  static String convert(std::unordered_map<K, V> const &m) {
+    std::unordered_set<std::string> entries;
+    for (auto const &kv : m) {
+      std::ostringstream oss;
+      oss << toString(kv.first) << " -> " << toString(kv.second);
+      entries.insert(oss.str());
+    }
+    return toString(entries);
+  }
+};
+
+template <typename T>
+struct StringMaker<std::vector<T>> {
+  static String convert(std::vector<T> const &vec) {
+    return doctest_print_container(vec, "[ ", ", ", " ]").c_str();
+  }
+};
+} // namespace doctest
diff --git a/lib/pcg/test/main.cc b/lib/pcg/test/main.cc
new file mode 100644
index 0000000000..9522fa7fdb
--- /dev/null
+++ b/lib/pcg/test/main.cc
@@ -0,0 +1,2 @@
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include "doctest/doctest.h"
diff --git a/lib/pcg/test/test_tensor.cc b/lib/pcg/test/test_tensor.cc
new file mode 100644
index 0000000000..0a15fd22e1
--- /dev/null
+++ b/lib/pcg/test/test_tensor.cc
@@ -0,0 +1,14 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/tensor.h"
+#include "pcg/tensor.h"
+#include "utils/containers.h"
+#include "utils/required.h"
+
+#include <optional>
+
+using namespace FlexFlow;
+
+TEST_CASE("Tensor") {
+  Tensor t{{3, 4, 5}, DataType::FLOAT, false, nullopt, nullopt, std::string("tensor")};
+  to_v1(t);
+}
diff --git a/lib/utils/include/utils/graph/algorithms.h b/lib/utils/include/utils/graph/algorithms.h
index 9f1d2e12d5..ed18d6e1c5 100644
--- a/lib/utils/include/utils/graph/algorithms.h
+++ b/lib/utils/include/utils/graph/algorithms.h
@@ -233,6 +233,8 @@ tl::optional<Node> get_imm_post_dominator(MultiDiGraphView const &,
                                           Node const &);
 tl::optional<Node> get_imm_post_dominator(DiGraphView const &,
                                           std::unordered_set<Node> const &);
+tl::optional<Node> get_imm_post_dominator(MultiDiGraphView const &,
+                                          std::unordered_set<Node> const &);
 
 std::vector<Node>
     get_dfs_ordering(DiGraphView const &,
diff --git a/lib/utils/include/utils/graph/cow_ptr_t.h b/lib/utils/include/utils/graph/cow_ptr_t.h
index 9a655ae072..3c5cf6ed10 100644
--- a/lib/utils/include/utils/graph/cow_ptr_t.h
+++ b/lib/utils/include/utils/graph/cow_ptr_t.h
@@ -11,8 +11,8 @@ namespace FlexFlow {
 
 template <typename T>
 struct cow_ptr_t {
-  static_assert(is_clonable<T>::value,
-                "cow_ptr_t requires the type to have a clone() method");
+  // static_assert(is_clonable<T>::value,
+  //               "cow_ptr_t requires the type to have a clone() method");
 
   cow_ptr_t(std::shared_ptr<T> const &ptr) : ptr(ptr) {}
   cow_ptr_t(std::shared_ptr<T> &&ptr) : ptr(std::move(ptr)) {}
diff --git a/lib/utils/include/utils/graph/multidigraph.h b/lib/utils/include/utils/graph/multidigraph.h
index 77bd3aedea..deb32fceb0 100644
--- a/lib/utils/include/utils/graph/multidigraph.h
+++ b/lib/utils/include/utils/graph/multidigraph.h
@@ -47,6 +47,7 @@ struct MultiDiGraph {
   MultiDiGraph() = delete;
   MultiDiGraph(MultiDiGraph const &) = default;
   MultiDiGraph &operator=(MultiDiGraph const &) = default;
+  virtual ~MultiDiGraph() = default;
 
   operator MultiDiGraphView() const;
 
diff --git a/lib/utils/include/utils/graph/multidigraph_interfaces.h b/lib/utils/include/utils/graph/multidigraph_interfaces.h
index 291021ae6b..1fcd83903c 100644
--- a/lib/utils/include/utils/graph/multidigraph_interfaces.h
+++ b/lib/utils/include/utils/graph/multidigraph_interfaces.h
@@ -52,6 +52,7 @@ struct IMultiDiGraph : public IMultiDiGraphView, public IGraph {
   }
 
   virtual IMultiDiGraph *clone() const override = 0;
+  virtual ~IMultiDiGraph() = default;
 };
 CHECK_RC_COPY_VIRTUAL_COMPLIANT(IMultiDiGraph);
 
diff --git a/lib/utils/src/graph/adjacency_digraph.cc b/lib/utils/src/graph/adjacency_digraph.cc
index 1438edc78b..e750d32c42 100644
--- a/lib/utils/src/graph/adjacency_digraph.cc
+++ b/lib/utils/src/graph/adjacency_digraph.cc
@@ -3,6 +3,10 @@
 
 namespace FlexFlow {
 
+AdjacencyDiGraph::AdjacencyDiGraph(std::size_t, ContentsType const&) {
+  NOT_IMPLEMENTED();
+}
+
 Node AdjacencyDiGraph::add_node() {
   Node node{this->next_node_idx};
   adjacency[node];
diff --git a/lib/utils/src/graph/adjacency_multidigraph.cc b/lib/utils/src/graph/adjacency_multidigraph.cc
index 79e7de7d75..0b883a441f 100644
--- a/lib/utils/src/graph/adjacency_multidigraph.cc
+++ b/lib/utils/src/graph/adjacency_multidigraph.cc
@@ -3,6 +3,11 @@
 
 namespace FlexFlow {
 
+AdjacencyMultiDiGraph::AdjacencyMultiDiGraph(std::size_t,
+                                             ContentsType const &) {
+  NOT_IMPLEMENTED();
+}
+
 Node AdjacencyMultiDiGraph::add_node() {
   Node node{this->next_node_idx};
   adjacency[node];
diff --git a/lib/utils/src/graph/algorithms.cc b/lib/utils/src/graph/algorithms.cc
index d261fc6be7..0543fc89b5 100644
--- a/lib/utils/src/graph/algorithms.cc
+++ b/lib/utils/src/graph/algorithms.cc
@@ -506,6 +506,23 @@ std::unordered_map<Node, std::unordered_set<Node>>
 
 std::unordered_map<Node, optional<Node>>
     get_imm_dominators(DiGraphView const &g) {
+  std::unordered_map<Node, int> topo_rank = [&g]() {
+    std::vector<Node> topo_ordering = get_topological_ordering(g);
+    std::unordered_map<Node, int> topo_rank;
+    for (int i = 0; i < topo_ordering.size(); i++) {
+      topo_rank[topo_ordering[i]] = i;
+    }
+    return topo_rank;
+  }();
+
+  auto with_greatest_topo_rank =
+      [&topo_rank](std::unordered_set<Node> const &nodes) -> Node {
+    return *std::max_element(nodes.cbegin(),
+                             nodes.cend(),
+                             [&topo_rank](Node const &lhs, Node const &rhs) {
+                               return topo_rank.at(lhs) < topo_rank.at(rhs);
+                             });
+  };
 
   std::unordered_map<Node, optional<Node>> result;
   for (auto const &kv : get_dominators(g)) {
diff --git a/lib/utils/src/graph/digraph.cc b/lib/utils/src/graph/digraph.cc
index 341005bd08..4c85362841 100644
--- a/lib/utils/src/graph/digraph.cc
+++ b/lib/utils/src/graph/digraph.cc
@@ -5,6 +5,11 @@
 
 namespace FlexFlow {
 
+DirectedEdgeQuery query_intersection(DirectedEdgeQuery const &lhs,
+                                     DirectedEdgeQuery const &rhs) {
+  NOT_IMPLEMENTED();
+}
+
 void swap(DiGraph &lhs, DiGraph &rhs) {
   using std::swap;
 
@@ -104,4 +109,16 @@ DiGraph::operator DiGraphView() const {
 
 DiGraphView::DiGraphView(std::shared_ptr<IDiGraphView const> ptr) : ptr(ptr) {}
 
+DiGraph::operator DiGraphView() const {
+  return DiGraphView(this->ptr.get());
+}
+
+DiGraphView::DiGraphView(std::shared_ptr<IDiGraphView const>) {
+  NOT_IMPLEMENTED();
+}
+
+DiGraphView::operator GraphView() const {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow

From aade00cea3773e495a12fad06abb1cfe8b38c99a Mon Sep 17 00:00:00 2001
From: Colin Unger <lockshaw@lockshaw.net>
Date: Thu, 31 Aug 2023 23:45:47 -0700
Subject: [PATCH 02/15] Add partial required fix

---
 lib/utils/include/utils/required.h            |  32 +++--
 lib/utils/include/utils/required_core.h       | 115 ++++++++++++++---
 lib/utils/include/utils/test_types.h          |  42 ++++++-
 lib/utils/include/utils/type_traits.h         |  81 ------------
 lib/utils/include/utils/type_traits_core.h    | 118 ++++++++++++++++++
 .../test/common/include/test/utils/doctest.h  |   4 +
 lib/utils/test/src/test_required.cc           |  92 ++++++++++++++
 7 files changed, 369 insertions(+), 115 deletions(-)
 create mode 100644 lib/utils/test/src/test_required.cc

diff --git a/lib/utils/include/utils/required.h b/lib/utils/include/utils/required.h
index 499994770a..4165b442fa 100644
--- a/lib/utils/include/utils/required.h
+++ b/lib/utils/include/utils/required.h
@@ -24,24 +24,34 @@ struct adl_serializer<::FlexFlow::req<T>> {
 };
 } // namespace nlohmann
 
-namespace fmt {
+/* namespace fmt { */
 
-template <typename T>
-struct formatter<::FlexFlow::req<T>> : formatter<T> {
-  template <typename FormatContext>
-  auto format(::FlexFlow::req<T> const &t, FormatContext &ctx)
-      -> decltype(ctx.out()) {
-    return formatter<T>::format(static_cast<T>(t), ctx);
-  }
-};
+/* template <typename T> */
+/* struct formatter<::FlexFlow::req<T>> : formatter<T> { */
+/*   template <typename FormatContext> */
+/*   auto format(::FlexFlow::req<T> const &t, FormatContext &ctx) */
+/*       -> decltype(ctx.out()) { */
+/*     return formatter<T>::format(static_cast<T>(t), ctx); */
+/*   } */
+/* }; */
 
-} // namespace fmt
+/* } // namespace fmt */
 
 namespace FlexFlow {
 static_assert(is_json_serializable<req<int>>::value, "");
 static_assert(is_json_deserializable<req<int>>::value, "");
 static_assert(is_jsonable<req<int>>::value, "");
-static_assert(is_fmtable<req<int>>::value, "");
+CHECK_FMTABLE(req<int>);
+CHECK_FMTABLE(std::vector<std::string>);
+CHECK_FMTABLE(required_inheritance_impl<std::vector<std::string>>);
+static_assert(
+  std::is_base_of<
+    required_inheritance_impl<std::vector<std::string>>,
+    req<std::vector<std::string>>
+  >::value, ""
+);
+CHECK_FMTABLE(req<std::vector<std::string>>);
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/utils/include/utils/required_core.h b/lib/utils/include/utils/required_core.h
index 3336e38243..8d20597efc 100644
--- a/lib/utils/include/utils/required_core.h
+++ b/lib/utils/include/utils/required_core.h
@@ -4,9 +4,22 @@
 #include "hash-utils-core.h"
 #include "type_traits_core.h"
 #include <vector>
+#include "test_types.h"
+#include "fmt.decl.h"
 
 namespace FlexFlow {
 
+template <typename T, typename Enable = void, typename...>
+struct enable_if_valid {};
+
+template <typename T, typename... Args>
+struct enable_if_valid<T, void_t<Args...>, Args...> : type_identity<T> {};
+
+/* required_wrapper_impl<decltype(std::declval<T>() + std::declval<T>())>> */
+/* operator+(required_wrapper_impl<T> const &lhs, required_wrapper_impl<T> const &rhs) { */
+/*   /1* return 1; *1/ */
+/* } */
+
 template <typename T>
 struct required_wrapper_impl {
 public:
@@ -34,6 +47,10 @@ struct required_wrapper_impl {
     return static_cast<TT>(this->m_value);
   }
 
+  friend T format_as(required_wrapper_impl<T> const &r) {
+    return static_cast<T>(r);
+  }
+
   /* T const &operator*() const { */
   /*   return this->m_value; */
   /* } */
@@ -42,12 +59,54 @@ struct required_wrapper_impl {
   /*   return &this->m_value; */
   /* } */
 
-  /* bool operator==(T const &other) const { */
-  /*   return this->m_value == other; */
+  template <typename TT = T>
+  enable_if_t<is_neq_comparable<TT>::value, bool>
+  operator==(required_wrapper_impl const &rhs) const {
+    return this->m_value == rhs.m_value;
+  }
+
+  template <typename TT = T>
+  enable_if_t<is_neq_comparable<TT>::value, bool>
+  operator==(TT const &rhs) const {
+    return this->m_value == rhs;
+  }
+
+  /* friend enable_if_t<is_equal_comparable<T>::value, bool> */
+  /*   operator==(required_wrapper_impl<T> const &lhs, T const &rhs) { */
+  /*   return lhs.m_value == rhs; */
+  /* } */
+
+  /* friend enable_if_t<is_equal_comparable<T>::value, bool> */
+  /*   operator==(T const &lhs, required_wrapper_impl<T> const &rhs) { */
+  /*   return lhs == rhs.m_value; */
+  /* } */
+
+  template <typename TT = T>
+  enable_if_t<is_neq_comparable<TT>::value, bool>
+  operator!=(required_wrapper_impl const &rhs) const {
+    return this->m_value != rhs.m_value;
+  }
+
+  /* friend enable_if_t<is_plusable<T>::value, required_wrapper_impl<decltype(std::declval<T>() + std::declval<T>())>> */
+  /* operator+(required_wrapper_impl<T> const &lhs, required_wrapper_impl<T> const &rhs) { */
+  /*   /1* return 1; *1/ */
+  /* } */
+  /* required_wrapper_impl<Out> */
+  /* operator+(required_wrapper_impl const &rhs) { */
+  /*   Out o = this->m_value + rhs.m_value; */
+  /*   return required_wrapper_impl<Out>{o}; */
   /* } */
 
-  /* bool operator!=(T const &other) const { */
-  /*   return this->m_value != other; */
+  /* template <typename TT = T, */
+  /*           enable_if_t<is_minusable<TT>::value> = true> */
+  /* required_wrapper_impl operator-(required_wrapper_impl const &rhs) { */
+  /*   return {this->m_value - rhs.m_value}; */
+  /* } */
+
+  /* template <typename TT = T, */
+  /*           enable_if_t<is_timesable<TT>::value> = true> */
+  /* required_wrapper_impl operator*(required_wrapper_impl const &rhs) { */
+  /*   return {this->m_value * rhs.m_value}; */
   /* } */
 
   /* bool operator<(T const &other) const { */
@@ -68,8 +127,31 @@ struct required_inheritance_impl : public T {
 
   using T::T;
   required_inheritance_impl() = delete;
-  required_inheritance_impl(T const &);
-  required_inheritance_impl(T &&t);
+  required_inheritance_impl(T const &t) : T(t) {}
+  required_inheritance_impl(T &&t) : T(t) {}
+
+  required_inheritance_impl(required_inheritance_impl<T> const &) = default;
+  required_inheritance_impl(required_inheritance_impl<T> &&) = default;
+
+  required_inheritance_impl<T> &operator=(required_inheritance_impl<T> const &) = default;
+  required_inheritance_impl<T> &operator=(required_inheritance_impl<T> &&) = default;
+
+  friend enable_if_t<is_equal_comparable<T>::value, bool>
+    operator==(required_inheritance_impl<T> const &lhs, required_inheritance_impl<T> const &rhs) {
+    return static_cast<T>(lhs) == static_cast<T>(rhs);
+  }
+
+  friend enable_if_t<is_neq_comparable<T>::value, bool>
+    operator!=(required_inheritance_impl<T> const &lhs, required_inheritance_impl<T> const &rhs) {
+    return static_cast<T>(lhs) != static_cast<T>(rhs);
+  }
+
+  friend std::string format_as(required_inheritance_impl<T> const &r) {
+    return "";
+    /* static_assert(is_fmtable<T>::value, ""); */
+
+    /* return static_cast<T>(r); */
+  }
 
   template <typename TT>
   required_inheritance_impl(
@@ -78,8 +160,6 @@ struct required_inheritance_impl : public T {
                               !std::is_same<TT, T>::value>::type * = 0)
       : required_inheritance_impl(static_cast<T>(tt)) {}
 
-  operator T() const;
-
   template <typename TTT,
             typename std::enable_if<(is_static_castable<T, TTT>::value &&
                                      !std::is_same<T, TTT>::value),
@@ -116,19 +196,16 @@ struct remove_req<req<T>> {
 template <typename T>
 using remove_req_t = typename remove_req<T>::type;
 
+static_assert(is_equal_comparable<required_inheritance_impl<std::vector<int>>>::value, "");
+CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(required_inheritance_impl<test_types::well_behaved_value_type>);
+CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(required_wrapper_impl<test_types::well_behaved_value_type>);
+
+/* static_assert(std::is_same<decltype(std::declval<required_wrapper_impl<int>>() + std::declval<required_wrapper_impl<int>>()), required_wrapper_impl<int>>::value, ""); */
+
+static_assert(std::is_copy_constructible<req<int>>::value, "");
+
 static_assert(std::is_convertible<req<int>, int>::value, "");
 static_assert(is_static_castable<req<void *>, int *>::value, "");
-static_assert(
-    std::is_same<
-        void_t<decltype(std::declval<req<int>>() == std::declval<int>())>,
-        void>::value,
-    "");
-static_assert(is_list_initializable<req<bool>, bool>::value, "");
-static_assert(
-    std::is_same<
-        void_t<decltype(std::declval<req<int>>() + std::declval<int>())>,
-        void>::value,
-    "");
 
 } // namespace FlexFlow
 
diff --git a/lib/utils/include/utils/test_types.h b/lib/utils/include/utils/test_types.h
index 2cac547bb6..308bd61428 100644
--- a/lib/utils/include/utils/test_types.h
+++ b/lib/utils/include/utils/test_types.h
@@ -1,7 +1,7 @@
 #ifndef _FLEXFLOW_UTILS_INCLUDE_UTILS_TEST_TYPES_H
 #define _FLEXFLOW_UTILS_INCLUDE_UTILS_TEST_TYPES_H
 
-#include "type_traits.h"
+#include "type_traits_core.h"
 
 namespace FlexFlow {
 
@@ -12,7 +12,10 @@ enum capability {
   EQ,
   CMP,
   DEFAULT_CONSTRUCTIBLE,
-  COPYABLE,
+  MOVE_CONSTRUCTIBLE,
+  MOVE_ASSIGNABLE,
+  COPY_CONSTRUCTIBLE,
+  COPY_ASSIGNABLE,
   PLUS,
   PLUSEQ,
   FMT
@@ -51,14 +54,38 @@ struct test_type_t {
             typename std::enable_if<!supports<C>::value, bool>::type = true>
   test_type_t() = delete;
 
-  template <capability C = COPYABLE,
+  template <capability C = COPY_CONSTRUCTIBLE,
             typename std::enable_if<supports<C>::value, bool>::type = true>
   test_type_t(test_type_t const &);
 
-  template <capability C = COPYABLE,
+  template <capability C = COPY_CONSTRUCTIBLE,
             typename std::enable_if<!supports<C>::value, bool>::type = true>
   test_type_t(test_type_t const &) = delete;
 
+  template <capability C = COPY_ASSIGNABLE,
+            typename std::enable_if<supports<C>::value, bool>::type = true>
+  test_type_t &operator=(test_type_t const &);
+
+  template <capability C = COPY_ASSIGNABLE,
+            typename std::enable_if<!supports<C>::value, bool>::type = true>
+  test_type_t &operator=(test_type_t const &) = delete;
+
+  template <capability C = MOVE_CONSTRUCTIBLE,
+            typename std::enable_if<supports<C>::value, bool>::type = true>
+  test_type_t(test_type_t &&);
+
+  template <capability C = MOVE_CONSTRUCTIBLE,
+            typename std::enable_if<!supports<C>::value, bool>::type = true>
+  test_type_t(test_type_t &&) = delete;
+
+  template <capability C = MOVE_ASSIGNABLE,
+            typename std::enable_if<supports<C>::value, bool>::type = true>
+  test_type_t &operator=(test_type_t &&);
+
+  template <capability C = MOVE_ASSIGNABLE,
+            typename std::enable_if<!supports<C>::value, bool>::type = true>
+  test_type_t &operator=(test_type_t &&) = delete;
+
   template <capability C = EQ>
   typename std::enable_if<supports<C>::value, bool>::type
       operator==(test_type_t const &) const;
@@ -102,6 +129,13 @@ using cmp = test_type_t<CMP>;
 using hash_cmp = test_type_t<HASHABLE, CMP>;
 using plusable = test_type_t<PLUS, PLUSEQ>;
 using fmtable = test_type_t<FMT>;
+using well_behaved_value_type = test_type_t<
+  EQ, 
+  COPY_CONSTRUCTIBLE,
+  MOVE_CONSTRUCTIBLE,
+  COPY_ASSIGNABLE,
+  MOVE_ASSIGNABLE
+>;
 
 } // namespace test_types
 } // namespace FlexFlow
diff --git a/lib/utils/include/utils/type_traits.h b/lib/utils/include/utils/type_traits.h
index dc8fe2cf57..ee45e8dc2e 100644
--- a/lib/utils/include/utils/type_traits.h
+++ b/lib/utils/include/utils/type_traits.h
@@ -65,24 +65,6 @@ template <typename T>
 struct is_streamable<T, void_t<decltype(std::cout << std::declval<T>())>>
     : std::true_type {};
 
-template <typename T, typename Enable = void>
-struct is_equal_comparable : std::false_type {};
-
-template <typename T>
-struct is_equal_comparable<
-    T,
-    void_t<decltype((bool)(std::declval<T>() == std::declval<T>()))>>
-    : std::true_type {};
-
-template <typename T, typename Enable = void>
-struct is_neq_comparable : std::false_type {};
-
-template <typename T>
-struct is_neq_comparable<
-    T,
-    void_t<decltype((bool)(std::declval<T>() != std::declval<T>()))>>
-    : std::true_type {};
-
 template <typename T, typename Enable = void>
 struct is_lt_comparable : std::false_type {};
 
@@ -92,19 +74,6 @@ struct is_lt_comparable<
     void_t<decltype((bool)(std::declval<T>() < std::declval<T>()))>>
     : std::true_type {};
 
-template <typename T, typename Enable = void>
-struct is_hashable : std::false_type {};
-
-template <typename T>
-struct is_hashable<
-    T,
-    void_t<decltype((size_t)(std::declval<std::hash<T>>()(std::declval<T>())))>>
-    : std::true_type {};
-
-#define CHECK_HASHABLE(...)                                                    \
-  static_assert(is_hashable<__VA_ARGS__>::value,                               \
-                #__VA_ARGS__ " should be hashable (but is not)");
-
 template <template <typename...> class Cond, typename... Ts>
 struct elements_satisfy_impl;
 
@@ -138,56 +107,6 @@ struct elements_satisfy<Cond,
 static_assert(
     elements_satisfy<is_equal_comparable, std::tuple<int, float>>::value, "");
 
-template <typename T>
-using is_default_constructible = std::is_default_constructible<T>;
-
-template <typename T>
-using is_copy_constructible = std::is_copy_constructible<T>;
-
-template <typename T>
-using is_move_constructible = std::is_move_constructible<T>;
-
-template <typename T>
-using is_copy_assignable = std::is_copy_assignable<T>;
-
-template <typename T>
-using is_move_assignable = std::is_move_assignable<T>;
-
-template <typename T>
-struct is_well_behaved_value_type_no_hash
-    : conjunction<is_equal_comparable<T>,
-                  is_neq_comparable<T>,
-                  is_copy_constructible<T>,
-                  is_move_constructible<T>,
-                  is_copy_assignable<T>,
-                  is_move_assignable<T>> {};
-
-#define CHECK_WELL_BEHAVED_VALUE_TYPE_NO_EQ(...)                               \
-  static_assert(is_copy_constructible<__VA_ARGS__>::value,                     \
-                #__VA_ARGS__ " should be copy-constructible");                 \
-  static_assert(is_move_constructible<__VA_ARGS__>::value,                     \
-                #__VA_ARGS__ " should be move-constructible");                 \
-  static_assert(is_copy_assignable<__VA_ARGS__>::value,                        \
-                #__VA_ARGS__ " should be copy-assignable");                    \
-  static_assert(is_move_assignable<__VA_ARGS__>::value,                        \
-                #__VA_ARGS__ " should be move-assignable")
-
-#define CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(...)                             \
-  CHECK_WELL_BEHAVED_VALUE_TYPE_NO_EQ(__VA_ARGS__);                            \
-  static_assert(is_equal_comparable<__VA_ARGS__>::value,                       \
-                #__VA_ARGS__ " should support operator==");                    \
-  static_assert(is_neq_comparable<__VA_ARGS__>::value,                         \
-                #__VA_ARGS__ " should support operator!=");
-
-template <typename T>
-struct is_well_behaved_value_type
-    : conjunction<is_well_behaved_value_type_no_hash<T>, is_hashable<T>> {};
-
-#define CHECK_WELL_BEHAVED_VALUE_TYPE(...)                                     \
-  CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(__VA_ARGS__);                          \
-  static_assert(is_hashable<__VA_ARGS__>::value,                               \
-                #__VA_ARGS__ " should support std::hash")
-
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/utils/include/utils/type_traits_core.h b/lib/utils/include/utils/type_traits_core.h
index 0aef490fce..7eccccb431 100644
--- a/lib/utils/include/utils/type_traits_core.h
+++ b/lib/utils/include/utils/type_traits_core.h
@@ -124,6 +124,124 @@ struct supports_iterator_tag
   static_assert(supports_iterator_tag<__VA_ARGS__, TAG>::value,                \
                 #__VA_ARGS__ " does not support required iterator tag " #TAG);
 
+template <typename T>
+using is_default_constructible = std::is_default_constructible<T>;
+
+template <typename T>
+using is_copy_constructible = std::is_copy_constructible<T>;
+
+template <typename T>
+using is_move_constructible = std::is_move_constructible<T>;
+
+template <typename T>
+using is_copy_assignable = std::is_copy_assignable<T>;
+
+template <typename T>
+using is_move_assignable = std::is_move_assignable<T>;
+
+template <typename T, typename Enable = void>
+struct is_equal_comparable : std::false_type {};
+
+template <typename T>
+struct is_equal_comparable<
+    T,
+    void_t<decltype(std::declval<T>() == std::declval<T>())>>
+      /* std::is_same< */
+      /*   decltype(), */
+      /*   bool */
+      /* >::value */
+    /* >> */
+    : std::true_type {};
+
+template <typename T, typename Enable = void>
+struct is_neq_comparable : std::false_type {};
+
+template <typename T>
+struct is_neq_comparable<
+    T,
+    void_t<decltype((bool)(std::declval<T>() != std::declval<T>()))>>
+    : std::true_type {};
+
+template <typename T, typename Enable = void>
+struct is_hashable : std::false_type {};
+
+template <typename T>
+struct is_hashable<
+    T,
+    void_t<decltype((size_t)(std::declval<std::hash<T>>()(std::declval<T>())))>>
+    : std::true_type {};
+
+template <typename T, typename Enable = void>
+struct is_plusable : std::false_type {};
+
+template <typename T>
+struct is_plusable<
+    T,
+    void_t<decltype((T)(std::declval<T>() + std::declval<T>()))>>
+    : std::true_type {};
+
+static_assert(is_plusable<int>::value, "");
+
+template <typename T, typename Enable = void>
+struct is_minusable : std::false_type {};
+
+template <typename T>
+struct is_minusable<
+    T,
+    void_t<decltype((T)(std::declval<T>() - std::declval<T>()))>>
+    : std::true_type {};
+
+template <typename T, typename Enable = void>
+struct is_timesable : std::false_type {};
+
+template <typename T>
+struct is_timesable<
+    T,
+    void_t<decltype((T)(std::declval<T>() * std::declval<T>()))>>
+    : std::true_type {};
+
+
+
+
+template <typename T>
+struct is_well_behaved_value_type_no_hash
+    : conjunction<is_equal_comparable<T>,
+                  is_neq_comparable<T>,
+                  is_copy_constructible<T>,
+                  is_move_constructible<T>,
+                  is_copy_assignable<T>,
+                  is_move_assignable<T>> {};
+
+#define CHECK_WELL_BEHAVED_VALUE_TYPE_NO_EQ(...)                               \
+  static_assert(is_copy_constructible<__VA_ARGS__>::value,                     \
+                #__VA_ARGS__ " should be copy-constructible");                 \
+  static_assert(is_move_constructible<__VA_ARGS__>::value,                     \
+                #__VA_ARGS__ " should be move-constructible");                 \
+  static_assert(is_copy_assignable<__VA_ARGS__>::value,                        \
+                #__VA_ARGS__ " should be copy-assignable");                    \
+  static_assert(is_move_assignable<__VA_ARGS__>::value,                        \
+                #__VA_ARGS__ " should be move-assignable")
+
+#define CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(...)                             \
+  CHECK_WELL_BEHAVED_VALUE_TYPE_NO_EQ(__VA_ARGS__);                            \
+  static_assert(is_equal_comparable<__VA_ARGS__>::value,                       \
+                #__VA_ARGS__ " should support operator==");                    \
+  static_assert(is_neq_comparable<__VA_ARGS__>::value,                         \
+                #__VA_ARGS__ " should support operator!=");
+
+template <typename T>
+struct is_well_behaved_value_type
+    : conjunction<is_well_behaved_value_type_no_hash<T>, is_hashable<T>> {};
+
+#define CHECK_HASHABLE(...)                                                    \
+  static_assert(is_hashable<__VA_ARGS__>::value,                               \
+                #__VA_ARGS__ " should be hashable (but is not)");
+
+#define CHECK_WELL_BEHAVED_VALUE_TYPE(...)                                     \
+  CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(__VA_ARGS__);                          \
+  CHECK_HASHABLE(__VA_ARGS__)
+
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/utils/test/common/include/test/utils/doctest.h b/lib/utils/test/common/include/test/utils/doctest.h
index 8089621850..5800e84f2b 100644
--- a/lib/utils/test/common/include/test/utils/doctest.h
+++ b/lib/utils/test/common/include/test/utils/doctest.h
@@ -69,4 +69,8 @@ struct StringMaker<std::vector<T>> {
     return doctest_print_container(vec, "[ ", ", ", " ]").c_str();
   }
 };
+
+#define STATIC_CHECK(...) static_assert(__VA_ARGS__, ""); CHECK(__VA_ARGS__);
+#define STATIC_CHECK_FALSE(...) static_assert(!(__VA_ARGS__), ""); CHECK_FALSE(__VA_ARGS__);
+
 } // namespace doctest
diff --git a/lib/utils/test/src/test_required.cc b/lib/utils/test/src/test_required.cc
new file mode 100644
index 0000000000..206267631f
--- /dev/null
+++ b/lib/utils/test/src/test_required.cc
@@ -0,0 +1,92 @@
+#include "test/utils/doctest.h"
+#include "utils/required.h"
+#include "test/utils/rapidcheck/doctest.h"
+
+using namespace FlexFlow;
+
+struct default_constructible_example {
+  int member;
+
+  default_constructible_example()
+    : member(1234)
+  { }
+
+  friend bool operator==(default_constructible_example const &lhs,
+                         default_constructible_example const &rhs) {
+    return lhs.member == rhs.member;
+  }
+
+  friend bool operator!=(default_constructible_example const &lhs,
+                         default_constructible_example const &rhs) {
+    return lhs.member != rhs.member;
+  }
+};
+
+TEST_CASE_TEMPLATE("required_wrapper_impl is not default constructible", T, int, float, double, char) {
+  STATIC_CHECK(std::is_default_constructible<T>::value);
+  STATIC_CHECK_FALSE(std::is_default_constructible<required_wrapper_impl<T>>::value);
+}
+
+TEST_CASE_TEMPLATE("required_inheritance_impl is not default constructible", 
+                   T, 
+                   std::vector<std::vector<int>>,
+                   std::unordered_map<std::string, float>) {
+  STATIC_CHECK(std::is_default_constructible<T>::value);
+  STATIC_CHECK_FALSE(std::is_default_constructible<required_wrapper_impl<T>>::value);
+}
+
+TEST_CASE_TEMPLATE("required_wrapper_impl supports expected operations", T, int, float, double, char) {
+  rc::dc_check("copy constructible", [&](T t) {
+    required_wrapper_impl<T> r{t};
+    required_wrapper_impl<T> r2(r);
+    CHECK(r == r2);
+  });
+
+  rc::dc_check("static_cast", [&](T t) {
+    CHECK(static_cast<T>(required_wrapper_impl<T>{t}) == t);
+  });
+
+  /* rc::dc_check("ops", [&](T t1, T t2) { */
+  /*   required_wrapper_impl<T> r1{t1}; */
+  /*   required_wrapper_impl<T> r2{t2}; */
+  /*   STATIC_CHECK(std::is_same<decltype(std::declval<required_wrapper_impl<T>>() + std::declval<required_wrapper_impl<T>>()), required_wrapper_impl<decltype(t1 + t2)>>::value); */
+  /*   CHECK(static_cast<T>(r1 + r2) == t1 + t2); */
+  /*   CHECK(static_cast<T>(r1 - r2) == t1 - t2); */
+  /*   CHECK(static_cast<T>(r1 * r2) == t1 * t2); */
+  /* }); */
+}
+
+TEST_CASE_TEMPLATE("required_inheritance_impl supports expected operations (generic)",
+                   T, 
+                   std::vector<int>,
+                   std::string) {
+  rc::dc_check("copy constructible", [&](T t) {
+    required_inheritance_impl<T> r{t};
+    required_inheritance_impl<T> r2(r);
+    assert(r == r2);
+  });
+
+  rc::dc_check("copy assignable", [&](T t) {
+    required_inheritance_impl<T> r{t};
+    required_inheritance_impl<T> r2 = r;
+    assert(r == r2);
+  });
+
+  rc::dc_check("move constructible", [&](T t) {
+    required_inheritance_impl<T> r{t};
+    required_inheritance_impl<T> r2{t};
+    required_inheritance_impl<T> r3{std::move(r2)};
+    assert(r == r3);
+  });
+
+  rc::dc_check("move assignable", [&](T t) {
+    required_inheritance_impl<T> r{t};
+    required_inheritance_impl<T> r2{t};
+    required_inheritance_impl<T> r3 = std::move(r2);
+    assert(r == r3);
+  });
+}
+
+
+TEST_CASE("required_inheritance_impl supports expected operations (std::vector<int>)") {
+}

From 15580ba5b16ea0ca3eaaff6504f9dae548591b39 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Thu, 28 Sep 2023 08:20:59 -0600
Subject: [PATCH 03/15] WIP: More progress towards serialization of PCG. This
 will build but there are still missing functions. The lowering to v1 for the
 CompGraphOperatorAttrs is missing a lot.

---
 lib/op-attrs/src/attention.cc                 | 21 ++++
 lib/op-attrs/src/conv_2d.cc                   |  8 ++
 lib/op-attrs/src/embedding.cc                 |  8 +-
 lib/op-attrs/src/get_op_type.cc               |  6 ++
 lib/op-attrs/src/get_output_shapes.cc         | 66 ++++++++++++-
 lib/op-attrs/src/parallel_dim.cc              |  4 +
 .../src/parallel_dim_mapping_record_solver.cc | 50 ++++++++++
 lib/op-attrs/src/parallel_tensor_shape.cc     | 97 +++++++++++++++++++
 lib/op-attrs/src/tensor_shape.cc              | 12 ++-
 .../pcg/file_format/v1/operator_attrs.h       | 32 +++++-
 lib/pcg/include/pcg/layer.h                   |  3 -
 lib/pcg/include/pcg/strided_rectangle.h       | 48 ++++++---
 lib/pcg/src/computation_graph_builder.cc      | 91 ++++++++++++++++-
 lib/pcg/src/device_id.cc                      |  4 +
 lib/pcg/src/file_format/v1/graphs.cc          |  4 +
 lib/pcg/src/file_format/v1/operator_attrs.cc  | 21 ++++
 lib/pcg/src/file_format/v1/param_sync.cc      | 17 ++++
 lib/pcg/src/machine_view.cc                   |  3 +
 lib/pcg/src/tensor.cc                         | 20 ++++
 .../utils/graph/labelled/output_labelled.h    | 14 ++-
 lib/utils/src/graph/adjacency_digraph.cc      |  4 -
 lib/utils/src/graph/adjacency_multidigraph.cc |  5 -
 lib/utils/src/graph/digraph.cc                | 19 +---
 23 files changed, 500 insertions(+), 57 deletions(-)
 create mode 100644 lib/pcg/src/file_format/v1/operator_attrs.cc
 create mode 100644 lib/pcg/src/file_format/v1/param_sync.cc
 create mode 100644 lib/pcg/src/tensor.cc

diff --git a/lib/op-attrs/src/attention.cc b/lib/op-attrs/src/attention.cc
index e9ae6ec803..b15f787668 100644
--- a/lib/op-attrs/src/attention.cc
+++ b/lib/op-attrs/src/attention.cc
@@ -26,6 +26,22 @@ int get_oProjSize(MultiHeadAttentionAttrs const &attrs) {
   return attrs.embed_dim;
 }
 
+int get_qSize(MultiHeadAttentionInputs<ParallelTensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
+
+int get_kSize(MultiHeadAttentionInputs<ParallelTensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
+
+int get_vSize(MultiHeadAttentionInputs<ParallelTensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
+
+int get_oSize(ParallelTensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
 int get_qSize(TensorShape const &query_shape) {
   return query_shape.at(ff_dim_t(0));
 }
@@ -80,6 +96,11 @@ TensorShape get_output_shape(MultiHeadAttentionAttrs const &attrs,
   return get_tensor_shape_unsafe(parallel_shape);
 }
 
+TensorShape get_output_shape(MultiHeadAttentionAttrs const &,
+                             MultiHeadAttentionInputs<TensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow
 
 // Tensor FFModel::multihead_attention(const Tensor query,
diff --git a/lib/op-attrs/src/conv_2d.cc b/lib/op-attrs/src/conv_2d.cc
index d000d31feb..40ba3c8b41 100644
--- a/lib/op-attrs/src/conv_2d.cc
+++ b/lib/op-attrs/src/conv_2d.cc
@@ -81,6 +81,14 @@ std::vector<ParallelDimMappingRecord>
   return mappings;
 }
 
+TensorShape get_kernel_shape(Conv2DAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+TensorShape get_bias_shape(Conv2DAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
 /* bool Conv2DAttrs::is_valid(ParallelTensorShape const &input_shape) const { */
 /*   bool is_valid = true; */
 /*   is_valid &= input_shape.is_valid(); */
diff --git a/lib/op-attrs/src/embedding.cc b/lib/op-attrs/src/embedding.cc
index 02cbfaa031..56014fcc67 100644
--- a/lib/op-attrs/src/embedding.cc
+++ b/lib/op-attrs/src/embedding.cc
@@ -1,3 +1,9 @@
 #include "op-attrs/ops/embedding.h"
 
-namespace FlexFlow {} // namespace FlexFlow
+namespace FlexFlow {
+
+TensorShape get_weights_shape(EmbeddingAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/op-attrs/src/get_op_type.cc b/lib/op-attrs/src/get_op_type.cc
index 7e3235fa9d..16f92f4b1e 100644
--- a/lib/op-attrs/src/get_op_type.cc
+++ b/lib/op-attrs/src/get_op_type.cc
@@ -32,6 +32,9 @@ OperatorType get_op_type(DropoutAttrs const &) {
 OperatorType get_op_type(ElementBinaryAttrs const &attrs) {
   return attrs.type;
 }
+OperatorType get_op_type(ElementScalarUnaryAttrs const &) {
+  NOT_IMPLEMENTED();
+}
 OperatorType get_op_type(ElementUnaryAttrs const &attrs) {
   return attrs.op;
 }
@@ -71,6 +74,9 @@ OperatorType get_op_type(ReduceAttrs const &) {
 OperatorType get_op_type(ReshapeAttrs const &) {
   return Op::RESHAPE;
 }
+OperatorType get_op_type(ReverseAttrs const &) {
+  return Op::REVERSE;
+}
 OperatorType get_op_type(SplitAttrs const &) {
   return Op::SPLIT;
 }
diff --git a/lib/op-attrs/src/get_output_shapes.cc b/lib/op-attrs/src/get_output_shapes.cc
index f44a677873..b3a38c167c 100644
--- a/lib/op-attrs/src/get_output_shapes.cc
+++ b/lib/op-attrs/src/get_output_shapes.cc
@@ -2,8 +2,13 @@
 
 namespace FlexFlow {
 
-ParallelTensorShape as_parallel(TensorShape const &);
-std::vector<ParallelTensorShape> as_parallel(std::vector<TensorShape> const &);
+ParallelTensorShape as_parallel(TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+std::vector<ParallelTensorShape> as_parallel(std::vector<TensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
 
 TensorShape get_output_shape(AggregateAttrs const &attrs,
                              TensorShape const &gate_preds,
@@ -20,4 +25,61 @@ TensorShape get_output_shape(AggregateAttrs const &attrs,
                        as_parallel(exp_preds)));
 }
 
+ParallelTensorShape get_output_shape(ElementBinaryAttrs const &,
+                                     ParallelTensorShape const &,
+                                     ParallelTensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+// FIXME: These are added to get rid of the linker errors about missing
+// definitions.
+template <>
+TensorShape get_output_shape(BatchNormAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+TensorShape get_output_shape(Conv2DAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+TensorShape get_output_shape(DropoutAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+TensorShape get_output_shape(ElementBinaryAttrs const &,
+                             TensorShape const &,
+                             TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+TensorShape get_output_shape(EmbeddingAttrs const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+TensorShape FlexFlow::get_output_shape(
+    variant<FlexFlow::ElementUnaryAttrs,
+            FlexFlow::ElementScalarUnaryAttrs> const &,
+    TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+std::vector<TensorShape> get_output_shapes(ElementBinaryAttrs const &attrs,
+                                           TensorShape const &,
+                                           TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+template <>
+std::vector<TensorShape> get_output_shapes(GatherAttrs const &attrs,
+                                           TensorShape const &,
+                                           TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow
diff --git a/lib/op-attrs/src/parallel_dim.cc b/lib/op-attrs/src/parallel_dim.cc
index cb9c603508..7e961880c9 100644
--- a/lib/op-attrs/src/parallel_dim.cc
+++ b/lib/op-attrs/src/parallel_dim.cc
@@ -6,4 +6,8 @@ bool is_valid(ParallelDim const &dim) {
   return dim.size > 0 && dim.degree >= 1 && dim.size % dim.degree == 0;
 }
 
+bool is_replica_dim(ParallelDim const &) {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow
diff --git a/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc b/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc
index 52df0fe0fa..622ceccbcc 100644
--- a/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc
+++ b/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc
@@ -183,6 +183,22 @@ void construct_weight_parallel_dims(
       input_idx, input_dim, weight_idx, weight_dim, operation));
 }
 
+ParallelDimMappingRecord
+    construct_weight_parallel_dims(int input_dim,
+                                   int weight_dim,
+                                   int input_idx,
+                                   int weight_idx,
+                                   tl::optional<MappingOperation> operation) {
+  NOT_IMPLEMENTED();
+}
+
+std::vector<ParallelDimMappingRecord> construct_weight_parallel_dims(
+    std::vector<std::tuple<int, MappingOperation, int>> mappings,
+    int input_idx,
+    int weight_idx) {
+  NOT_IMPLEMENTED();
+}
+
 /* void ParallelDimMappingRecordSolver::register_weight_parallel_dims( */
 /*     std::vector<std::pair<int, int>> mappings, int input_idx, int weight_idx)
  * { */
@@ -226,6 +242,15 @@ void construct_output_parallel_dims(
   }
 }
 
+ParallelDimMappingRecord
+    construct_output_parallel_dims(int input_dim,
+                                   int output_dim,
+                                   int input_idx,
+                                   int output_idx,
+                                   tl::optional<MappingOperation> operation) {
+  NOT_IMPLEMENTED();
+}
+
 void construct_output_parallel_dims(
     std::vector<ParallelDimMappingRecord> &records,
     std::vector<std::pair<int, int>> mappings,
@@ -248,6 +273,18 @@ void construct_output_parallel_dims(
       input_idx, input_dim, output_idx, output_dim, operation));
 }
 
+std::vector<ParallelDimMappingRecord> construct_output_parallel_dims(
+    std::vector<std::pair<int, int>> mappings, int input_idx, int output_idx) {
+  NOT_IMPLEMENTED();
+}
+
+std::vector<ParallelDimMappingRecord> construct_output_parallel_dims(
+    std::vector<std::tuple<int, MappingOperation, int>> mappings,
+    int input_idx,
+    int output_idx) {
+  NOT_IMPLEMENTED();
+}
+
 /* void register_output_parallel_dims( */
 /*     std::vector<std::pair<int, int>> mappings, int input_idx, int output_idx)
  * { */
@@ -320,4 +357,17 @@ void construct_output_parallel_dims(
 /*   return solution; */
 /* } */
 
+ParallelDimMappingSolution solve_parallel_dim_mappings(
+    std::vector<ParallelDimMappingRecord> const &mappings,
+    std::vector<ParallelTensorShape> const &input,
+    int numWeights,
+    int numOutputs) {
+  // There is a definition of this function earlier in this file that might be
+  // the actual implementation, but is commented out for whatever reason. Rather
+  // than enabling that, just fail for now so someone else can take a look and
+  // decide whether to enable it.
+  NOT_IMPLEMENTED();
+}
+
+
 } // namespace FlexFlow
diff --git a/lib/op-attrs/src/parallel_tensor_shape.cc b/lib/op-attrs/src/parallel_tensor_shape.cc
index 9a36e7d11b..dca2dd50af 100644
--- a/lib/op-attrs/src/parallel_tensor_shape.cc
+++ b/lib/op-attrs/src/parallel_tensor_shape.cc
@@ -16,9 +16,97 @@ static std::vector<ParallelDim> lift_dims(TensorDims const &dims) {
 ParallelTensorDims::ParallelTensorDims(TensorDims const &dims)
     : data(lift_dims(dims)) {}
 
+size_t ParallelTensorDims::get_volume() const {
+  NOT_IMPLEMENTED();
+}
+
+size_t ParallelTensorDims::num_dims() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelDim const &ParallelTensorDims::at(ff_dim_t const &) const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelDim &ParallelTensorDims::at(ff_dim_t const &) {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::iterator ParallelTensorDims::begin() {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_iterator ParallelTensorDims::begin() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_iterator ParallelTensorDims::cbegin() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::iterator ParallelTensorDims::end() {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_iterator ParallelTensorDims::end() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_iterator ParallelTensorDims::cend() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::reverse_iterator ParallelTensorDims::rbegin() {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_reverse_iterator ParallelTensorDims::rbegin() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_reverse_iterator ParallelTensorDims::crbegin() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::reverse_iterator ParallelTensorDims::rend() {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_reverse_iterator ParallelTensorDims::rend() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorDims::const_reverse_iterator ParallelTensorDims::crend() const {
+  NOT_IMPLEMENTED();
+}
+
 ParallelTensorShape::ParallelTensorShape(TensorShape const &tensor_shape)
     : dims(tensor_shape.dims), data_type(tensor_shape.data_type) {}
 
+int ParallelTensorShape::num_dims() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelDim const &ParallelTensorShape::at(ff_dim_t const &) const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelDim &ParallelTensorShape::at(ff_dim_t const &) {
+  NOT_IMPLEMENTED();
+}
+
+ParallelDim const &ParallelTensorShape::operator[](ff_dim_t const &) const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelDim &ParallelTensorShape::operator[](ff_dim_t const &) {
+  NOT_IMPLEMENTED();
+}
+
+TensorShape get_piece_shape(ParallelTensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
 int get_num_replica_dims(ParallelTensorShape const &shape) {
   return count(shape.dims, is_replica_dim);
 }
@@ -37,4 +125,13 @@ bool is_valid(ParallelTensorShape const &shape) {
   return is_valid(shape.dims);
 }
 
+TensorShape get_tensor_shape_unsafe(ParallelTensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+std::vector<TensorShape>
+    get_tensor_shapes_unsafe(std::vector<ParallelTensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow
diff --git a/lib/op-attrs/src/tensor_shape.cc b/lib/op-attrs/src/tensor_shape.cc
index d31fb7cf21..0a8b1d1e19 100644
--- a/lib/op-attrs/src/tensor_shape.cc
+++ b/lib/op-attrs/src/tensor_shape.cc
@@ -1,3 +1,13 @@
 #include "op-attrs/tensor_shape.h"
 
-namespace FlexFlow {}
+namespace FlexFlow {
+
+size_t TensorShape::at(ff_dim_t) const {
+  NOT_IMPLEMENTED();
+}
+
+size_t TensorShape::operator[](ff_dim_t) const {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
index 2ea87cbf56..7acb24f70c 100644
--- a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
+++ b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
@@ -1,20 +1,42 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPERATOR_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPERATOR_ATTRS_H
 
+#include "op-attrs/operator_attrs.h"
 #include "utils/json.h"
 #include "utils/variant.h"
 
 namespace FlexFlow {
 
-struct V1Conv2DAttrs {};
-FF_VISITABLE_STRUCT(V1Conv2DAttrs);
-
-static_assert(
-    std::is_same<visit_as_tuple_t<V1Conv2DAttrs>, std::tuple<>>::value, "");
+struct V1Conv2DAttrs {
+  req<int> out_channels;
+  req<int> kernel_h;
+  req<int> kernel_w;
+  req<int> stride_h;
+  req<int> stride_w;
+  req<int> padding_h;
+  req<int> padding_w;
+  req<int> groups;
+  req<optional<Activation>> activation;
+  req<bool> use_bias;
+};
+FF_VISITABLE_STRUCT(V1Conv2DAttrs,
+                    out_channels,
+                    kernel_h,
+                    kernel_w,
+                    stride_h,
+                    stride_w,
+                    padding_h,
+                    padding_w,
+                    groups,
+                    activation,
+                    use_bias);
+CHECK_IS_JSONABLE(V1Conv2DAttrs);
 
 using V1CompGraphOperatorAttrs = variant<V1Conv2DAttrs>;
 using V1PCGOperatorAttrs = variant<V1Conv2DAttrs>;
 
+V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/layer.h b/lib/pcg/include/pcg/layer.h
index e17eef3875..d218e9d8b9 100644
--- a/lib/pcg/include/pcg/layer.h
+++ b/lib/pcg/include/pcg/layer.h
@@ -17,9 +17,6 @@ FF_VISITABLE_STRUCT(Layer, attrs, name);
 
 } // namespace FlexFlow
 
-VISITABLE_STRUCT(::FlexFlow::Layer, attrs, name);
-MAKE_VISIT_HASHABLE(::FlexFlow::Layer);
-
 namespace FlexFlow {
 
 FF_VISIT_FMTABLE(Layer);
diff --git a/lib/pcg/include/pcg/strided_rectangle.h b/lib/pcg/include/pcg/strided_rectangle.h
index 28331f441c..d8188c13b4 100644
--- a/lib/pcg/include/pcg/strided_rectangle.h
+++ b/lib/pcg/include/pcg/strided_rectangle.h
@@ -12,23 +12,44 @@ namespace FlexFlow {
 struct num_points_t : public strong_typedef<num_points_t, int> {
   using strong_typedef::strong_typedef;
 };
+FF_TYPEDEF_HASHABLE(num_points_t);
+FF_TYPEDEF_PRINTABLE(num_points_t, "num_points");
 
 struct side_size_t : public strong_typedef<side_size_t, int> {
   using strong_typedef::strong_typedef;
 };
+FF_TYPEDEF_HASHABLE(side_size_t);
+FF_TYPEDEF_PRINTABLE(side_size_t, "side_size");
 
 struct StridedRectangleSide : public use_visitable_cmp<StridedRectangleSide> {
 public:
   StridedRectangleSide() = delete;
-  StridedRectangleSide(num_points_t const &, int stride);
-  StridedRectangleSide(side_size_t const &, int stride);
+  StridedRectangleSide(num_points_t const &num_points, int stride)
+      : num_points(num_points), stride(stride) {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
+  StridedRectangleSide(side_size_t const &num_points, int stride)
+      : num_points(num_points), stride(stride) {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
 
   num_points_t get_num_points() const;
-  side_size_t get_size() const;
+  side_size_t get_size() const {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
   int get_stride() const;
 
-  side_size_t at(num_points_t) const;
-  num_points_t at(side_size_t) const;
+  side_size_t at(num_points_t) const {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
+  num_points_t at(side_size_t) const {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
 
 public:
   num_points_t num_points;
@@ -38,23 +59,24 @@ struct StridedRectangleSide : public use_visitable_cmp<StridedRectangleSide> {
 struct StridedRectangle : public use_visitable_cmp<StridedRectangle> {
 public:
   StridedRectangle() = delete;
-  StridedRectangle(std::vector<StridedRectangleSide> const &);
+  StridedRectangle(std::vector<StridedRectangleSide> const &sides)
+      : sides(sides) {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
 
   size_t at(FFOrdered<num_points_t> const &) const;
   StridedRectangleSide at(ff_dim_t const &) const;
-  size_t num_dims() const;
+  size_t num_dims() const {
+    // FIXME: Move this definition elsewhere.
+    NOT_IMPLEMENTED();
+  }
 
 public:
   FFOrdered<StridedRectangleSide> sides;
 };
 } // namespace FlexFlow
 
-MAKE_TYPEDEF_HASHABLE(::FlexFlow::num_points_t);
-MAKE_TYPEDEF_PRINTABLE(::FlexFlow::num_points_t, "num_points");
-
-MAKE_TYPEDEF_HASHABLE(::FlexFlow::side_size_t);
-MAKE_TYPEDEF_PRINTABLE(::FlexFlow::side_size_t, "side_size");
-
 VISITABLE_STRUCT(::FlexFlow::StridedRectangleSide, num_points, stride);
 MAKE_VISIT_HASHABLE(::FlexFlow::StridedRectangleSide);
 
diff --git a/lib/pcg/src/computation_graph_builder.cc b/lib/pcg/src/computation_graph_builder.cc
index a17cd18f7c..ad335f1930 100644
--- a/lib/pcg/src/computation_graph_builder.cc
+++ b/lib/pcg/src/computation_graph_builder.cc
@@ -310,8 +310,13 @@ std::vector<Tensor>
   return this->add_layer(layer, {input}, {}, output_shapes);
 }
 
-TensorShape get_shape(Tensor const &);
-std::vector<TensorShape> get_shape(std::vector<Tensor> const &);
+TensorShape get_shape(Tensor const &) {
+  NOT_IMPLEMENTED();
+}
+
+std::vector<TensorShape> get_shape(std::vector<Tensor> const &) {
+  NOT_IMPLEMENTED();
+}
 
 Tensor ComputationGraphBuilder::aggregate(
     Tensor const &gate_preds,
@@ -351,4 +356,86 @@ Tensor ComputationGraphBuilder::batch_norm(
   return this->add_layer(layer, {input}, {}, output_shape);
 }
 
+Tensor ComputationGraphBuilder::dense(Tensor const &input,
+             int outDim,
+             optional<Activation> activation,
+             bool use_bias,
+             DataType data_type,
+             optional<Initializer const &> kernel_initializer,
+             optional<Initializer const &> bias_initializer,
+             optional<std::string> const &name) {
+  NOT_IMPLEMENTED();
+}
+
+Tensor ComputationGraphBuilder::cast(Tensor const &input,
+            DataType dtype,
+            optional<std::string> const &name) {
+  NOT_IMPLEMENTED();
+}
+
+Tensor ComputationGraphBuilder::concat(int n,
+              std::vector<Tensor> const &tensors,
+              int axis,
+              optional<std::string> const &name) {
+  NOT_IMPLEMENTED();
+}
+
+Tensor ComputationGraphBuilder::mean(Tensor const &input,
+            std::vector<int> const &dims,
+            bool keepdims,
+            char const *name) {
+  NOT_IMPLEMENTED();
+}
+
+Tensor ComputationGraphBuilder::moe(Tensor const &input,
+           int num_exp,
+           int num_select,
+           int expert_hidden_size,
+           float alpha,
+           float lambda) {
+  NOT_IMPLEMENTED();
+}
+
+void ComputationGraphBuilder::split(Tensor const &input,
+           Tensor *outputs,
+           std::vector<int> const &split,
+           int axis,
+           optional<std::string> const &name) {
+  NOT_IMPLEMENTED();
+}
+
+Tensor ComputationGraphBuilder::broadcast(Tensor const &, TensorShape const &) {
+  NOT_IMPLEMENTED();
+}
+
+void ComputationGraphBuilder::add_layer(Layer const &layer,
+                                        std::vector<Tensor> const &inputs,
+                                        std::vector<Tensor> const &weights,
+                                        std::vector<Tensor> const &outputs) {
+  NOT_IMPLEMENTED();
+}
+
+Tensor ComputationGraphBuilder::add_layer(
+    Layer const &layer,
+    std::vector<Tensor> const &inputs,
+    std::vector<std::pair<TensorShape, optional<Initializer>>> const
+        &weight_shapes,
+    TensorShape const &output_shape) {
+  NOT_IMPLEMENTED();
+}
+
+std::vector<Tensor> ComputationGraphBuilder::add_layer(
+    Layer const &layer,
+    std::vector<Tensor> const &inputs,
+    std::vector<std::pair<TensorShape, optional<Initializer>>> const
+        &weight_shapes,
+    std::vector<TensorShape> const &output_shapes) {
+  NOT_IMPLEMENTED();
+}
+
+TensorShape ComputationGraphBuilder::get_broadcast_target_shape(
+    std::vector<TensorShape> const &) {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/device_id.cc b/lib/pcg/src/device_id.cc
index b669009f42..7bb1de0763 100644
--- a/lib/pcg/src/device_id.cc
+++ b/lib/pcg/src/device_id.cc
@@ -3,6 +3,10 @@
 
 namespace FlexFlow {
 
+device_id_t operator+(device_id_t, size_t) {
+  NOT_IMPLEMENTED();
+}
+
 DeviceType get_device_type(device_id_t const &id) {
   if (holds_alternative<gpu_id_t>(id)) {
     return DeviceType::GPU;
diff --git a/lib/pcg/src/file_format/v1/graphs.cc b/lib/pcg/src/file_format/v1/graphs.cc
index 0ad71b3ab4..02e2cc007b 100644
--- a/lib/pcg/src/file_format/v1/graphs.cc
+++ b/lib/pcg/src/file_format/v1/graphs.cc
@@ -3,6 +3,10 @@
 
 namespace FlexFlow {
 
+V1Layer to_v1(Layer const &l) {
+  return {to_v1(l.attrs), l.name};
+}
+
 V1MultiDiGraph to_v1(MultiDiGraphView const &g) {
   return to_v1(g,
                enumerate(get_nodes(g)).reversed(),
diff --git a/lib/pcg/src/file_format/v1/operator_attrs.cc b/lib/pcg/src/file_format/v1/operator_attrs.cc
new file mode 100644
index 0000000000..5eaff7416a
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/operator_attrs.cc
@@ -0,0 +1,21 @@
+#include "pcg/file_format/v1/operator_attrs.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1Conv2DAttrs to_v1(Conv2DAttrs const &attrs) {
+  return {
+    attrs.out_channels,
+    attrs.kernel_h,
+    attrs.kernel_w,
+    attrs.stride_h,
+    attrs.stride_w,
+    attrs.padding_h,
+    attrs.padding_w,
+    attrs.groups,
+    attrs.activation,
+    attrs.use_bias,
+  };
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/param_sync.cc b/lib/pcg/src/file_format/v1/param_sync.cc
new file mode 100644
index 0000000000..5972b10f54
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/param_sync.cc
@@ -0,0 +1,17 @@
+#include "pcg/file_format/v1/param_sync.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ParamSync to_v1(ParamSync const &p) {
+  switch (p) {
+    case ParamSync::PS:
+      return V1ParamSync::PARAM_SERVER;
+    case ParamSync::NCCL:
+      return V1ParamSync::NCCL;
+    default:
+      NOT_IMPLEMENTED();
+  };
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/machine_view.cc b/lib/pcg/src/machine_view.cc
index 46f87833f0..9edfb09a8e 100644
--- a/lib/pcg/src/machine_view.cc
+++ b/lib/pcg/src/machine_view.cc
@@ -3,6 +3,9 @@
 
 namespace FlexFlow {
 
+MachineView::MachineView(device_id_t const &start, StridedRectangle const &rect)
+    : start(start), rect(rect) {}
+
 static StridedRectangle make_1d_rect(int start, int stop, int stride) {
   assert(stop > start);
   assert(stride > 0);
diff --git a/lib/pcg/src/tensor.cc b/lib/pcg/src/tensor.cc
new file mode 100644
index 0000000000..2b61ab5c03
--- /dev/null
+++ b/lib/pcg/src/tensor.cc
@@ -0,0 +1,20 @@
+#include "pcg/tensor.h"
+
+namespace FlexFlow {
+size_t Tensor::get_volume() const {
+  NOT_IMPLEMENTED();
+}
+
+TensorShape Tensor::get_shape() const {
+  NOT_IMPLEMENTED();
+}
+
+int Tensor::num_dims() const {
+  NOT_IMPLEMENTED();
+}
+
+Tensor::operator TensorShape() const {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/utils/include/utils/graph/labelled/output_labelled.h b/lib/utils/include/utils/graph/labelled/output_labelled.h
index ffb69b717d..54dc397d06 100644
--- a/lib/utils/include/utils/graph/labelled/output_labelled.h
+++ b/lib/utils/include/utils/graph/labelled/output_labelled.h
@@ -47,9 +47,17 @@ struct OutputLabelledMultiDiGraph {
   OutputLabelledMultiDiGraph &
       operator=(OutputLabelledMultiDiGraph const &other) = default;
 
-  operator LabelledMultiDiGraphView<NodeLabel, OutputLabel>() const;
-  operator MultiDiGraphView() const;
-  operator GraphView() const;
+  operator LabelledMultiDiGraphView<NodeLabel, OutputLabel>() const {
+    NOT_IMPLEMENTED();
+  }
+
+  operator MultiDiGraphView() const {
+    NOT_IMPLEMENTED();
+  }
+
+  operator GraphView() const {
+    NOT_IMPLEMENTED();
+  }
 
   friend void swap(OutputLabelledMultiDiGraph &lhs,
                    OutputLabelledMultiDiGraph &rhs) {
diff --git a/lib/utils/src/graph/adjacency_digraph.cc b/lib/utils/src/graph/adjacency_digraph.cc
index e750d32c42..1438edc78b 100644
--- a/lib/utils/src/graph/adjacency_digraph.cc
+++ b/lib/utils/src/graph/adjacency_digraph.cc
@@ -3,10 +3,6 @@
 
 namespace FlexFlow {
 
-AdjacencyDiGraph::AdjacencyDiGraph(std::size_t, ContentsType const&) {
-  NOT_IMPLEMENTED();
-}
-
 Node AdjacencyDiGraph::add_node() {
   Node node{this->next_node_idx};
   adjacency[node];
diff --git a/lib/utils/src/graph/adjacency_multidigraph.cc b/lib/utils/src/graph/adjacency_multidigraph.cc
index 0b883a441f..79e7de7d75 100644
--- a/lib/utils/src/graph/adjacency_multidigraph.cc
+++ b/lib/utils/src/graph/adjacency_multidigraph.cc
@@ -3,11 +3,6 @@
 
 namespace FlexFlow {
 
-AdjacencyMultiDiGraph::AdjacencyMultiDiGraph(std::size_t,
-                                             ContentsType const &) {
-  NOT_IMPLEMENTED();
-}
-
 Node AdjacencyMultiDiGraph::add_node() {
   Node node{this->next_node_idx};
   adjacency[node];
diff --git a/lib/utils/src/graph/digraph.cc b/lib/utils/src/graph/digraph.cc
index 4c85362841..31ad74d2ae 100644
--- a/lib/utils/src/graph/digraph.cc
+++ b/lib/utils/src/graph/digraph.cc
@@ -5,11 +5,6 @@
 
 namespace FlexFlow {
 
-DirectedEdgeQuery query_intersection(DirectedEdgeQuery const &lhs,
-                                     DirectedEdgeQuery const &rhs) {
-  NOT_IMPLEMENTED();
-}
-
 void swap(DiGraph &lhs, DiGraph &rhs) {
   using std::swap;
 
@@ -103,22 +98,10 @@ DirectedEdgeQuery query_intersection(DirectedEdgeQuery const &lhs,
   return result;
 }
 
-DiGraph::operator DiGraphView() const {
-  return GraphInternal::create_digraphview(this->ptr.get());
-}
-
 DiGraphView::DiGraphView(std::shared_ptr<IDiGraphView const> ptr) : ptr(ptr) {}
 
 DiGraph::operator DiGraphView() const {
-  return DiGraphView(this->ptr.get());
-}
-
-DiGraphView::DiGraphView(std::shared_ptr<IDiGraphView const>) {
-  NOT_IMPLEMENTED();
-}
-
-DiGraphView::operator GraphView() const {
-  NOT_IMPLEMENTED();
+  return GraphInternal::create_digraphview(this->ptr.get());
 }
 
 } // namespace FlexFlow

From 75495818eb65721d159abad7822950ae4ddfa86f Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Mon, 2 Oct 2023 16:45:25 -0600
Subject: [PATCH 04/15] WIP: Broken build. Add declarations for the V1 variants
 of the operators. Add stubs with NOT_IMPLEMENTED calls for functions and
 methods whose definitions are missing.

---
 lib/op-attrs/CMakeLists.txt                   |   2 +-
 .../include/pcg/file_format/v1/activation.h   |  18 ++++
 .../v1/{data_type.h => datatype.h}            |   0
 .../include/pcg/file_format/v1/dim_ordered.h  |  29 +++++
 .../include/pcg/file_format/v1/initializer.h  |  15 +--
 .../pcg/file_format/v1/operator_attrs.h       | 102 +++++++++++++-----
 .../pcg/file_format/v1/ops/aggregate.h        |  21 ++++
 .../pcg/file_format/v1/ops/aggregate_spec.h   |  21 ++++
 .../pcg/file_format/v1/ops/attention.h        |  29 +++++
 .../pcg/file_format/v1/ops/batch_matmul.h     |  19 ++++
 .../pcg/file_format/v1/ops/batch_norm.h       |  19 ++++
 .../pcg/file_format/v1/ops/broadcast.h        |  19 ++++
 lib/pcg/include/pcg/file_format/v1/ops/cast.h |  20 ++++
 .../include/pcg/file_format/v1/ops/combine.h  |  21 ++++
 .../include/pcg/file_format/v1/ops/concat.h   |  20 ++++
 .../include/pcg/file_format/v1/ops/conv_2d.h  |  34 ++++++
 .../include/pcg/file_format/v1/ops/dropout.h  |  20 ++++
 .../pcg/file_format/v1/ops/element_binary.h   |  28 +++++
 .../pcg/file_format/v1/ops/element_unary.h    |  29 +++++
 .../pcg/file_format/v1/ops/embedding.h        |  32 ++++++
 lib/pcg/include/pcg/file_format/v1/ops/flat.h |  17 +++
 .../include/pcg/file_format/v1/ops/gather.h   |  20 ++++
 .../include/pcg/file_format/v1/ops/groupby.h  |  20 ++++
 .../include/pcg/file_format/v1/ops/input.h    |  17 +++
 .../pcg/file_format/v1/ops/layer_norm.h       |  26 +++++
 .../include/pcg/file_format/v1/ops/linear.h   |  45 ++++++++
 lib/pcg/include/pcg/file_format/v1/ops/noop.h |  17 +++
 .../include/pcg/file_format/v1/ops/pool_2d.h  |  30 ++++++
 .../include/pcg/file_format/v1/ops/reduce.h   |  24 +++++
 .../pcg/file_format/v1/ops/reduction.h        |  21 ++++
 .../pcg/file_format/v1/ops/repartition.h      |  21 ++++
 .../pcg/file_format/v1/ops/replicate.h        |  21 ++++
 .../include/pcg/file_format/v1/ops/reshape.h  |  20 ++++
 .../include/pcg/file_format/v1/ops/reverse.h  |  20 ++++
 .../include/pcg/file_format/v1/ops/softmax.h  |  20 ++++
 .../include/pcg/file_format/v1/ops/split.h    |  21 ++++
 lib/pcg/include/pcg/file_format/v1/ops/topk.h |  20 ++++
 .../pcg/file_format/v1/ops/transpose.h        |  25 +++++
 .../include/pcg/file_format/v1/parallel_dim.h |  22 ++++
 .../pcg/file_format/v1/parallel_tensor.h      |   2 +-
 .../pcg/file_format/v1/parallel_tensor_dims.h |  20 ++++
 .../file_format/v1/parallel_tensor_shape.h    |  22 ++++
 lib/pcg/include/pcg/file_format/v1/tensor.h   |  13 +--
 .../include/pcg/file_format/v1/tensor_shape.h |  28 +++++
 44 files changed, 959 insertions(+), 51 deletions(-)
 create mode 100644 lib/pcg/include/pcg/file_format/v1/activation.h
 rename lib/pcg/include/pcg/file_format/v1/{data_type.h => datatype.h} (100%)
 create mode 100644 lib/pcg/include/pcg/file_format/v1/dim_ordered.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/attention.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/cast.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/combine.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/concat.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/dropout.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/embedding.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/flat.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/gather.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/groupby.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/input.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/linear.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/noop.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/reduce.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/reduction.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/repartition.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/replicate.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/reshape.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/reverse.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/softmax.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/split.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/topk.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ops/transpose.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/parallel_dim.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/tensor_shape.h

diff --git a/lib/op-attrs/CMakeLists.txt b/lib/op-attrs/CMakeLists.txt
index 778be53d7c..244958c76e 100644
--- a/lib/op-attrs/CMakeLists.txt
+++ b/lib/op-attrs/CMakeLists.txt
@@ -6,7 +6,7 @@ ff_add_library(
   PUBLIC_INCLUDE
     include/
   PRIVATE_INCLUDE
-    src/ 
+    src/
   DEPS
     utils
 )
diff --git a/lib/pcg/include/pcg/file_format/v1/activation.h b/lib/pcg/include/pcg/file_format/v1/activation.h
new file mode 100644
index 0000000000..38a93021db
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/activation.h
@@ -0,0 +1,18 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_ACTIVATION_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_ACTIVATION_H
+
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+enum class V1Activation { RELU, SIGMOID, TANH, GELU };
+
+NLOHMANN_JSON_SERIALIZE_ENUM(V1Activation,
+                             {{V1Activation::RELU, "RELU"},
+                              {V1Activation::SIGMOID, "SIGMOID"},
+                              {V1Activation::TANH, "TANH"},
+                              {V1Activation::GELU, "GELU"}});
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/data_type.h b/lib/pcg/include/pcg/file_format/v1/datatype.h
similarity index 100%
rename from lib/pcg/include/pcg/file_format/v1/data_type.h
rename to lib/pcg/include/pcg/file_format/v1/datatype.h
diff --git a/lib/pcg/include/pcg/file_format/v1/dim_ordered.h b/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
new file mode 100644
index 0000000000..5e4c767438
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
@@ -0,0 +1,29 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_DIM_ORDERED_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_DIM_ORDERED_H
+
+#include "op-attrs/dim_ordered.h"
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+template <typename Idx, typename T>
+struct V1DimOrdered {
+  std::vector<T> contents;
+
+  bool operator!=(const V1DimOrdered &o) {
+    return this->contents != o.contents;
+  }
+};
+
+template <typename Idx, typename T>
+V1DimOrdered<Idx, T> to_v1(DimOrdered<Idx, T> const &dim);
+
+template <typename T>
+using V1FFOrdered = V1DimOrdered<ff_dim_t, T>;
+
+template <typename T>
+V1FFOrdered<T> to_v1(FFOrdered<T> const& o);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/initializer.h b/lib/pcg/include/pcg/file_format/v1/initializer.h
index 17272218ae..f69ce06439 100644
--- a/lib/pcg/include/pcg/file_format/v1/initializer.h
+++ b/lib/pcg/include/pcg/file_format/v1/initializer.h
@@ -1,7 +1,7 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_INITIALIZER_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_INITIALIZER_H
 
-#include "data_type.h"
+#include "datatype.h"
 #include "pcg/initializer.h"
 #include "utils/json.h"
 #include "utils/required.h"
@@ -15,6 +15,7 @@ struct V1GlorotInitializer {
   req<int> seed;
 };
 FF_VISITABLE_STRUCT(V1GlorotInitializer, seed);
+CHECK_IS_JSONABLE(V1GlorotInitializer);
 
 struct V1ZeroInitializer {};
 FF_VISITABLE_STRUCT(V1ZeroInitializer);
@@ -25,6 +26,7 @@ struct V1UniformInitializer {
   req<float> max_val;
 };
 FF_VISITABLE_STRUCT(V1UniformInitializer, seed, min_val, max_val);
+CHECK_IS_JSONABLE(V1UniformInitializer);
 
 struct V1NormInitializer {
   req<int> seed;
@@ -32,11 +34,13 @@ struct V1NormInitializer {
   req<float> stddev;
 };
 FF_VISITABLE_STRUCT(V1NormInitializer, seed, mean, stddev);
+CHECK_IS_JSONABLE(V1NormInitializer);
 
 struct V1ConstantInitializer {
   req<V1DataTypeValue> value;
 };
 FF_VISITABLE_STRUCT(V1ConstantInitializer, value);
+CHECK_IS_JSONABLE(V1ConstantInitializer);
 
 using V1Initializer = variant<V1GlorotInitializer,
                               V1ZeroInitializer,
@@ -48,13 +52,4 @@ V1Initializer to_v1(Initializer const &);
 
 } // namespace FlexFlow
 
-namespace FlexFlow {
-CHECK_IS_JSONABLE(V1GlorotInitializer);
-CHECK_IS_JSONABLE(V1ZeroInitializer);
-CHECK_IS_JSONABLE(V1UniformInitializer);
-CHECK_IS_JSONABLE(V1NormInitializer);
-CHECK_IS_JSONABLE(V1ConstantInitializer);
-CHECK_IS_JSONABLE(V1Initializer);
-} // namespace FlexFlow
-
 #endif
diff --git a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
index 7acb24f70c..d3f1b9dc41 100644
--- a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
+++ b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
@@ -2,38 +2,86 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPERATOR_ATTRS_H
 
 #include "op-attrs/operator_attrs.h"
+#include "op-attrs/ops/core.h"
+#include "ops/aggregate.h"
+#include "ops/aggregate_spec.h"
+#include "ops/attention.h"
+#include "ops/batch_matmul.h"
+#include "ops/batch_norm.h"
+#include "ops/broadcast.h"
+#include "ops/cast.h"
+#include "ops/combine.h"
+#include "ops/concat.h"
+#include "ops/conv_2d.h"
+#include "ops/dropout.h"
+#include "ops/element_binary.h"
+#include "ops/element_unary.h"
+#include "ops/embedding.h"
+#include "ops/flat.h"
+#include "ops/gather.h"
+#include "ops/groupby.h"
+#include "ops/input.h"
+#include "ops/layer_norm.h"
+#include "ops/linear.h"
+#include "ops/noop.h"
+#include "ops/pool_2d.h"
+#include "ops/reduce.h"
+#include "ops/reduction.h"
+#include "ops/repartition.h"
+#include "ops/replicate.h"
+#include "ops/reshape.h"
+#include "ops/reverse.h"
+#include "ops/softmax.h"
+#include "ops/split.h"
+#include "ops/topk.h"
+#include "ops/transpose.h"
 #include "utils/json.h"
 #include "utils/variant.h"
 
 namespace FlexFlow {
 
-struct V1Conv2DAttrs {
-  req<int> out_channels;
-  req<int> kernel_h;
-  req<int> kernel_w;
-  req<int> stride_h;
-  req<int> stride_w;
-  req<int> padding_h;
-  req<int> padding_w;
-  req<int> groups;
-  req<optional<Activation>> activation;
-  req<bool> use_bias;
-};
-FF_VISITABLE_STRUCT(V1Conv2DAttrs,
-                    out_channels,
-                    kernel_h,
-                    kernel_w,
-                    stride_h,
-                    stride_w,
-                    padding_h,
-                    padding_w,
-                    groups,
-                    activation,
-                    use_bias);
-CHECK_IS_JSONABLE(V1Conv2DAttrs);
-
-using V1CompGraphOperatorAttrs = variant<V1Conv2DAttrs>;
-using V1PCGOperatorAttrs = variant<V1Conv2DAttrs>;
+using V1SharedOperatorAttrs = variant<V1AggregateAttrs,
+                                      V1AggregateSpecAttrs,
+                                      V1BatchMatmulAttrs,
+                                      V1BatchNormAttrs,
+                                      V1CastAttrs,
+                                      V1ConcatAttrs,
+                                      V1Conv2DAttrs,
+                                      V1DropoutAttrs,
+                                      V1ElementBinaryAttrs,
+                                      V1ElementScalarUnaryAttrs,
+                                      V1ElementUnaryAttrs,
+                                      V1EmbeddingAttrs,
+                                      V1FlatAttrs,
+                                      V1GatherAttrs,
+                                      V1Group_byAttrs,
+                                      V1InputAttrs,
+                                      V1LayerNormAttrs,
+                                      V1LinearAttrs,
+                                      V1MultiHeadAttentionAttrs,
+                                      V1NoopAttrs,
+                                      V1Pool2DAttrs,
+                                      V1ReduceAttrs,
+                                      V1ReverseAttrs,
+                                      V1ReshapeAttrs,
+                                      V1SplitAttrs,
+                                      V1SoftmaxAttrs,
+                                      V1TopKAttrs,
+                                      V1TransposeAttrs>;
+
+using V1ParallelOperatorAttrs = variant<V1CombineAttrs,
+                                        V1ReductionAttrs,
+                                        V1RepartitionAttrs,
+                                        V1ReplicateAttrs>;
+
+using V1ComputationGraphAttrs =
+    variant_join<V1SharedOperatorAttrs, variant<V1BroadcastAttrs>>;
+using V1CompGraphOperatorAttrs = V1ComputationGraphAttrs;
+
+using V1PCGOperatorAttrs =
+    variant_join<V1SharedOperatorAttrs, V1ParallelOperatorAttrs>;
+
+V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
 
 V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h b/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
new file mode 100644
index 0000000000..385624f44b
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_AGGREGATE_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_AGGREGATE_H
+
+#include "op-attrs/ops/aggregate.h"
+#include "utils/visitable.h"
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+struct V1AggregateAttrs {
+  req<int> n;
+  req<float> lambda_bal;
+};
+FF_VISITABLE_STRUCT(V1AggregateAttrs, n, lambda_bal);
+CHECK_IS_JSONABLE(V1AggregateAttrs);
+
+V1AggregateAttrs to_v1(AggregateAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h b/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h
new file mode 100644
index 0000000000..294e395568
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_AGGREGATE_SPEC_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_AGGREGATE_SPEC_ATTRS_H
+
+#include "op-attrs/ops/aggregate_spec.h"
+#include "utils/json.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1AggregateSpecAttrs {
+  req<int> n;
+  req<float> lambda_bal;
+};
+FF_VISITABLE_STRUCT(V1AggregateSpecAttrs, n, lambda_bal);
+CHECK_IS_JSONABLE(V1AggregateSpecAttrs);
+
+V1AggregateSpecAttrs to_v1(AggregateSpecAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/attention.h b/lib/pcg/include/pcg/file_format/v1/ops/attention.h
new file mode 100644
index 0000000000..2c5b298fb8
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/attention.h
@@ -0,0 +1,29 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ATTENTION_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ATTENTION_ATTRS_H
+
+#include "op-attrs/ops/attention.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1MultiHeadAttentionAttrs {
+  req<int> embed_dim, num_heads, kdim, vdim;
+  req<float> dropout;
+  req<bool> bias, add_bias_kv, add_zero_attn;
+};
+FF_VISITABLE_STRUCT(V1MultiHeadAttentionAttrs,
+                    embed_dim,
+                    num_heads,
+                    kdim,
+                    vdim,
+                    dropout,
+                    bias,
+                    add_bias_kv,
+                    add_zero_attn);
+CHECK_IS_JSONABLE(V1MultiHeadAttentionAttrs);
+
+V1MultiHeadAttentionAttrs to_v1(MultiHeadAttentionAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h b/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h
new file mode 100644
index 0000000000..c7a9b8fd69
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h
@@ -0,0 +1,19 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BATCH_MATMUL_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BATCH_MATMUL_ATTRS_H
+
+#include "op-attrs/ops/batch_matmul.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1BatchMatmulAttrs {
+  req<int> a_seq_length_dim, b_seq_length_dim;
+};
+FF_VISITABLE_STRUCT(V1BatchMatmulAttrs, a_seq_length_dim, b_seq_length_dim);
+CHECK_IS_JSONABLE(V1BatchMatmulAttrs);
+
+V1BatchMatmulAttrs to_v1(BatchMatmulAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h b/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h
new file mode 100644
index 0000000000..89f611bd4d
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h
@@ -0,0 +1,19 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BATCH_NORM_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BATCH_NORM_H
+
+#include "op-attrs/ops/batch_norm.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1BatchNormAttrs {
+  req<bool> relu;
+};
+FF_VISITABLE_STRUCT(V1BatchNormAttrs, relu);
+CHECK_IS_JSONABLE(V1BatchNormAttrs);
+
+V1BatchNormAttrs to_v1(BatchNormAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
new file mode 100644
index 0000000000..424bc8eb61
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
@@ -0,0 +1,19 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BROADCAST_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BROADCAST_H
+
+#include "utils/stack_vector.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1BroadcastAttrs {
+  req<stack_vector<int, MAX_TENSOR_DIM>> target_dims;
+};
+FF_VISITABLE_STRUCT(V1BroadcastAttrs, target_dims);
+CHECK_IS_JSONABLE(V1BroadcastAttrs);
+
+V1BroadcastAttrs to_v1(BroadcastAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/cast.h b/lib/pcg/include/pcg/file_format/v1/ops/cast.h
new file mode 100644
index 0000000000..c7e5201630
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/cast.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CAST_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CAST_ATTRS_H
+
+#include "op-attrs/ops/cast.h"
+#include "op-attrs/datatype.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1CastAttrs {
+  req<DataType> dtype;
+};
+FF_VISITABLE_STRUCT(V1CastAttrs, dtype);
+CHECK_IS_JSONABLE(V1CastAttrs);
+
+V1CastAttrs to_v1(CastAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/combine.h b/lib/pcg/include/pcg/file_format/v1/ops/combine.h
new file mode 100644
index 0000000000..d7f006584c
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/combine.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_COMBINE_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_COMBINE_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/combine.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1CombineAttrs {
+  ff_dim_t combine_dim;
+  req<int> combine_degree;
+};
+FF_VISITABLE_STRUCT(V1CombineAttrs, combine_dim, combine_degree);
+CHECK_IS_JSONABLE(V1CombineAttrs);
+
+V1CombineAttrs to_v1(CombineAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/concat.h b/lib/pcg/include/pcg/file_format/v1/ops/concat.h
new file mode 100644
index 0000000000..f15abb9e99
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/concat.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONCAT_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONCAT_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/concat.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ConcatAttrs {
+  ff_dim_t axis;
+};
+FF_VISITABLE_STRUCT(V1ConcatAttrs, axis);
+CHECK_IS_JSONABLE(V1ConcatAttrs);
+
+V1ConcatAttrs to_v1(ConcatAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h b/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
new file mode 100644
index 0000000000..b995dbad32
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
@@ -0,0 +1,34 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONV_2D_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONV_2D_ATTRS_H
+
+#include "op-attrs/activation.h"
+#include "op-attrs/ops/conv_2d.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1Conv2DAttrs {
+  req<int> out_channels, kernel_h, kernel_w, stride_h, stride_w, padding_h,
+      padding_w, groups;
+  req<optional<Activation>> activation;
+  req<bool> use_bias;
+};
+
+FF_VISITABLE_STRUCT(V1Conv2DAttrs,
+                    out_channels,
+                    kernel_h,
+                    kernel_w,
+                    stride_h,
+                    stride_w,
+                    padding_h,
+                    padding_w,
+                    groups,
+                    activation,
+                    use_bias);
+CHECK_IS_JSONABLE(V1Conv2DAttrs);
+
+V1Conv2DAttrs to_v1(Conv2DAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/dropout.h b/lib/pcg/include/pcg/file_format/v1/ops/dropout.h
new file mode 100644
index 0000000000..5d0eace907
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/dropout.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_DROPOUT_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_DROPOUT_ATTRS_H
+
+#include "op-attrs/ops/dropout.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1DropoutAttrs {
+  req<float> rate;
+  req<unsigned long long> seed;
+};
+FF_VISITABLE_STRUCT(V1DropoutAttrs, rate, seed);
+CHECK_IS_JSONABLE(V1DropoutAttrs);
+
+V1DropoutAttrs to_v1(DropoutAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h b/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
new file mode 100644
index 0000000000..a01992d034
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
@@ -0,0 +1,28 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENT_BINARY_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENT_BINARY_ATTRS_H
+
+#include "op-attrs/datatype.h"
+#include "op-attrs/op.h"
+#include "op-attrs/ops/element_binary.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ElementBinaryAttrs {
+  req<Op> type;
+  req<DataType> compute_type;
+  req<bool> should_broadcast_lhs;
+  req<bool> should_broadcast_rhs;
+};
+FF_VISITABLE_STRUCT(V1ElementBinaryAttrs,
+                    type,
+                    compute_type,
+                    should_broadcast_lhs,
+                    should_broadcast_rhs);
+CHECK_IS_JSONABLE(V1ElementBinaryAttrs);
+
+V1ElementBinaryAttrs to_v1(ElementBinaryAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h b/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
new file mode 100644
index 0000000000..a697fac940
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
@@ -0,0 +1,29 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENTARY_UNARY_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENTARY_UNARY_ATTRS_H
+
+#include "op-attrs/op.h"
+#include "op-attrs/ops/element_unary.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ElementScalarUnaryAttrs {
+  req<Op> op;
+  req<float> scalar;
+};
+FF_VISITABLE_STRUCT(V1ElementScalarUnaryAttrs, op, scalar);
+CHECK_IS_JSONABLE(V1ElementScalarUnaryAttrs);
+
+V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &attrs);
+
+struct V1ElementUnaryAttrs {
+  req<Op> op;
+};
+FF_VISITABLE_STRUCT(V1ElementUnaryAttrs, op);
+CHECK_IS_JSONABLE(V1ElementUnaryAttrs);
+
+V1ElementUnaryAttrs to_v1(ElementUnaryAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/embedding.h b/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
new file mode 100644
index 0000000000..29c81bcb92
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
@@ -0,0 +1,32 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_EMBEDDING_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_EMBEDDING_ATTRS_H
+
+#include "op-attrs/ops/embedding.h"
+#include "pcg/file_format/v1/datatype.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+enum class V1AggregateOp {
+  SUM,
+  AVG,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(V1AggregateOp,
+                             {{V1AggregateOp::SUM, "SUM"},
+                              {V1AggregateOp::AVG, "AVG"}});
+
+struct V1EmbeddingAttrs {
+  req<int> num_entries, out_channels;
+  req<V1AggregateOp> aggr;
+  req<V1DataType> data_type;
+};
+FF_VISITABLE_STRUCT(
+    V1EmbeddingAttrs, num_entries, out_channels, aggr, data_type);
+CHECK_IS_JSONABLE(V1EmbeddingAttrs);
+
+V1EmbeddingAttrs to_v1(EmbeddingAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/flat.h b/lib/pcg/include/pcg/file_format/v1/ops/flat.h
new file mode 100644
index 0000000000..999d0c5473
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/flat.h
@@ -0,0 +1,17 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_FLAT_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_FLAT_ATTRS_H
+
+#include "op-attrs/ops/flat.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1FlatAttrs {};
+FF_VISITABLE_STRUCT(V1FlatAttrs);
+CHECK_IS_JSONABLE(V1FlatAttrs);
+
+V1FlatAttrs to_v1(FlatAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/gather.h b/lib/pcg/include/pcg/file_format/v1/ops/gather.h
new file mode 100644
index 0000000000..a8b8437ca8
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/gather.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_GATHER_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_GATHER_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/gather.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1GatherAttrs {
+  ff_dim_t dim;
+};
+FF_VISITABLE_STRUCT(V1GatherAttrs, dim);
+CHECK_IS_JSONABLE(V1GatherAttrs);
+
+V1GatherAttrs to_v1(GatherAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/groupby.h b/lib/pcg/include/pcg/file_format/v1/ops/groupby.h
new file mode 100644
index 0000000000..76dfe7bd48
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/groupby.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_GROUPBY_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_GROUPBY_ATTRS_H
+
+#include "op-attrs/ops/groupby.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1Group_byAttrs {
+  req<int> n;
+  req<float> alpha;
+};
+FF_VISITABLE_STRUCT(V1Group_byAttrs, n, alpha);
+CHECK_IS_JSONABLE(V1Group_byAttrs);
+
+V1Group_byAttrs to_v1(Group_byAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/input.h b/lib/pcg/include/pcg/file_format/v1/ops/input.h
new file mode 100644
index 0000000000..b664a9a85b
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/input.h
@@ -0,0 +1,17 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_INPUT_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_INPUT_H
+
+#include "op-attrs/ops/input.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1InputAttrs {};
+FF_VISITABLE_STRUCT(V1InputAttrs);
+CHECK_IS_JSONABLE(V1InputAttrs);
+
+V1InputAttrs to_v1(InputAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h b/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
new file mode 100644
index 0000000000..4edbacfabd
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
@@ -0,0 +1,26 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LAYER_NORM_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LAYER_NORM_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/layer_norm.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1LayerNormAttrs {
+  // FIXME: stack_vector is probably causing a problem because it is not
+  // automatically (de)serializable, but need to ensure that one way or the
+  // other.
+  // stack_vector<ff_dim_t, MAX_TENSOR_DIM> axes;
+  req<bool> elementwise_affine;
+  req<float> eps;
+};
+FF_VISITABLE_STRUCT(V1LayerNormAttrs, // axes,
+                    elementwise_affine, eps);
+CHECK_IS_JSONABLE(V1LayerNormAttrs);
+
+V1LayerNormAttrs to_v1(LayerNormAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/linear.h b/lib/pcg/include/pcg/file_format/v1/ops/linear.h
new file mode 100644
index 0000000000..33f239d878
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/linear.h
@@ -0,0 +1,45 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LINEAR_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LINEAR_ATTRS_H
+
+#include "op-attrs/ops/linear.h"
+#include "op-attrs/parallel_tensor_shape.h"
+#include "pcg/file_format/v1/activation.h"
+#include "pcg/file_format/v1/datatype.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1L1RegularizerAttrs {
+  req<float> lambda;
+};
+FF_VISITABLE_STRUCT(V1L1RegularizerAttrs, lambda);
+CHECK_IS_JSONABLE(V1L1RegularizerAttrs);
+
+V1L1RegularizerAttrs to_v1(L1RegularizerAttrs const &attrs);
+
+struct V1L2RegularizerAttrs {
+  req<float> lambda;
+};
+FF_VISITABLE_STRUCT(V1L2RegularizerAttrs, lambda);
+CHECK_IS_JSONABLE(V1L2RegularizerAttrs);
+
+V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &attrs);
+
+using V1RegularizerAttrs = variant<V1L1RegularizerAttrs, V1L2RegularizerAttrs>;
+
+struct V1LinearAttrs {
+  req<int> out_channels;
+  req<bool> use_bias;
+  req<V1DataType> data_type;
+  req<V1Activation> activation;
+  req<optional<V1RegularizerAttrs>> regularizer;
+};
+FF_VISITABLE_STRUCT(
+    V1LinearAttrs, out_channels, use_bias, data_type, activation, regularizer);
+CHECK_IS_JSONABLE(V1LinearAttrs);
+
+V1LinearAttrs to_v1(LinearAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/noop.h b/lib/pcg/include/pcg/file_format/v1/ops/noop.h
new file mode 100644
index 0000000000..afd7326710
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/noop.h
@@ -0,0 +1,17 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_NOOP_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_NOOP_H
+
+#include "op-attrs/ops/noop.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1NoopAttrs {};
+FF_VISITABLE_STRUCT(V1NoopAttrs);
+CHECK_IS_JSONABLE(NoopAttrs);
+
+V1NoopAttrs to_v1(NoopAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h b/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
new file mode 100644
index 0000000000..c27940ee03
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
@@ -0,0 +1,30 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_POOL_2D_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_POOL_2D_ATTRS_H
+
+#include "op-attrs/activation.h"
+#include "op-attrs/ops/pool_2d.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1Pool2DAttrs {
+  req<int> kernel_h, kernel_w, stride_h, stride_w, padding_h, padding_w;
+  req<PoolOp> pool_type;
+  req<Activation> activation;
+};
+FF_VISITABLE_STRUCT(V1Pool2DAttrs,
+                    kernel_h,
+                    kernel_w,
+                    stride_h,
+                    stride_w,
+                    padding_h,
+                    padding_w,
+                    pool_type,
+                    activation);
+CHECK_IS_JSONABLE(V1Pool2DAttrs);
+
+V1Pool2DAttrs to_v1(Pool2DAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reduce.h b/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
new file mode 100644
index 0000000000..8b8baa741f
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
@@ -0,0 +1,24 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCE_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCE_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/op.h"
+#include "op-attrs/ops/reduce.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ReduceAttrs {
+  // The size of this vector is <= MAX_TENSOR_DIMS.
+  req<std::vector<ff_dim_t>> axes;
+  req<Op> op_type;
+  req<bool> keepdims;
+};
+FF_VISITABLE_STRUCT(V1ReduceAttrs, axes, op_type, keepdims);
+CHECK_IS_JSONABLE(V1ReduceAttrs);
+
+V1ReduceAttrs to_v1(ReduceAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reduction.h b/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
new file mode 100644
index 0000000000..989b33871b
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCTION_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCTION_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/reduction.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ReductionAttrs {
+  ff_dim_t reduction_dim;
+  req<int> reduction_degree;
+};
+FF_VISITABLE_STRUCT(V1ReductionAttrs, reduction_dim, reduction_degree);
+CHECK_IS_JSONABLE(V1ReductionAttrs);
+
+V1ReductionAttrs to_v1(ReductionAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/repartition.h b/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
new file mode 100644
index 0000000000..c8bf22d64c
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPARTITION_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPARTITION_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/repartition.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1RepartitionAttrs {
+  ff_dim_t repartition_dim;
+  req<int> repartition_degree;
+};
+FF_VISITABLE_STRUCT(V1RepartitionAttrs, repartition_dim, repartition_degree);
+CHECK_IS_JSONABLE(V1RepartitionAttrs);
+
+V1RepartitionAttrs to_v1(RepartitionAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/replicate.h b/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
new file mode 100644
index 0000000000..43f2534b9c
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPLICATE_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPLICATE_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/replicate.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ReplicateAttrs {
+  ff_dim_t replicate_dim;
+  req<int> replicate_degree;
+};
+FF_VISITABLE_STRUCT(V1ReplicateAttrs, replicate_dim, replicate_degree);
+CHECK_IS_JSONABLE(V1ReplicateAttrs);
+
+V1ReplicateAttrs to_v1(ReplicateAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reshape.h b/lib/pcg/include/pcg/file_format/v1/ops/reshape.h
new file mode 100644
index 0000000000..64ef15e19f
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reshape.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_RESHAPE_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_RESHAPE_ATTRS_H
+
+#include "op-attrs/ops/reshape.h"
+#include "pcg/file_format/v1/tensor_shape.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ReshapeAttrs {
+  V1TensorShape shape;
+};
+FF_VISITABLE_STRUCT(V1ReshapeAttrs, shape);
+CHECK_IS_JSONABLE(V1ReshapeAttrs);
+
+V1ReshapeAttrs to_v1(ReshapeAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reverse.h b/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
new file mode 100644
index 0000000000..69985a485b
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REVERSE_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REVERSE_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/reverse.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ReverseAttrs {
+  ff_dim_t axis;
+};
+FF_VISITABLE_STRUCT(V1ReverseAttrs, axis);
+CHECK_IS_JSONABLE(V1ReverseAttrs);
+
+V1ReverseAttrs to_v1(ReverseAttrs const &);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/softmax.h b/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
new file mode 100644
index 0000000000..4ab60fcdcf
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SOFTMAX_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SOFTMAX_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/softmax.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1SoftmaxAttrs {
+  ff_dim_t dim;
+};
+FF_VISITABLE_STRUCT(V1SoftmaxAttrs, dim);
+CHECK_IS_JSONABLE(V1SoftmaxAttrs);
+
+V1SoftmaxAttrs to_v1(SoftmaxAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/split.h b/lib/pcg/include/pcg/file_format/v1/ops/split.h
new file mode 100644
index 0000000000..00ffd033d2
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/split.h
@@ -0,0 +1,21 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SPLIT_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SPLIT_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/split.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1SplitAttrs {
+  req<stack_vector<int, MAX_NUM_OUTPUTS>> splits;
+  ff_dim_t axis;
+};
+FF_VISITABLE_STRUCT(V1SplitAttrs, splits, axis);
+CHECK_IS_JSONABLE(V1SplitAttrs);
+
+V1SplitAttrs to_v1(SplitAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/topk.h b/lib/pcg/include/pcg/file_format/v1/ops/topk.h
new file mode 100644
index 0000000000..f5473e4082
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/topk.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_TOPK_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_TOPK_ATTRS_H
+
+#include "op-attrs/ops/topk.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1TopKAttrs {
+  req<int> k;
+  req<bool> sorted;
+};
+FF_VISITABLE_STRUCT(V1TopKAttrs, k, sorted);
+CHECK_IS_JSONABLE(V1TopKAttrs);
+
+V1TopKAttrs to_v1(TopKAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/transpose.h b/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
new file mode 100644
index 0000000000..f2f5d28c13
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
@@ -0,0 +1,25 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_TRANSPOSE_ATTRS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_TRANSPOSE_ATTRS_H
+
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/ops/transpose.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1TransposeAttrs {
+  // FIXME: stack_vector is probably causing a problem because it is not
+  // automatically (de)serializable, but need to ensure that one way or the
+  // other.
+  // stack_vector<ff_dim_t, MAX_TENSOR_DIM> axes;
+  // req<stack_vector<ff_dim_t, MAX_TENSOR_DIM>> perm;
+};
+FF_VISITABLE_STRUCT(V1TransposeAttrs// , perm
+                    );
+CHECK_IS_JSONABLE(V1TransposeAttrs);
+
+V1TransposeAttrs to_v1(TransposeAttrs const &attrs);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_dim.h b/lib/pcg/include/pcg/file_format/v1/parallel_dim.h
new file mode 100644
index 0000000000..6f9ff73ff6
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_dim.h
@@ -0,0 +1,22 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_DIM_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_DIM_H
+
+#include "op-attrs/parallel_dim.h"
+#include "utils/type_traits.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ParallelDim {
+  size_t size;
+  int degree;
+  req<bool> is_replica_dim;
+};
+FF_VISITABLE_STRUCT(V1ParallelDim, size, degree, is_replica_dim);
+CHECK_IS_JSONABLE(V1ParallelDim);
+
+V1ParallelDim to_v1(ParallelDim const &dim);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
index d8a2a00ee4..3fda7727a4 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
@@ -1,7 +1,7 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_H
 
-#include "data_type.h"
+#include "datatype.h"
 #include "initializer.h"
 #include "param_sync.h"
 #include "pcg/parallel_tensor.h"
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h
new file mode 100644
index 0000000000..b17a2e9285
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h
@@ -0,0 +1,20 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_DIMS_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_DIMS_H
+
+#include "op-attrs/parallel_tensor_dims.h"
+#include "parallel_dim.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ParallelTensorDims {
+  req<FFOrdered<V1ParallelDim>> data;
+};
+FF_VISITABLE_STRUCT(V1ParallelTensorDims, data);
+CHECK_IS_JSONABLE(V1ParallelTensorDims);
+
+V1ParallelTensorDims to_v1(ParallelTensorDims const &dims);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h
new file mode 100644
index 0000000000..6e39315538
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h
@@ -0,0 +1,22 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_SHAPE_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_SHAPE_H
+
+#include "datatype.h"
+#include "op-attrs/parallel_tensor_shape.h"
+#include "parallel_tensor_dims.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+struct V1ParallelTensorShape {
+  V1ParallelTensorDims dims;
+  V1DataType data_type;
+};
+FF_VISITABLE_STRUCT(V1ParallelTensorShape, dims, data_type);
+CHECK_IS_JSONABLE(V1ParallelTensorShape);
+
+V1ParallelTensorShape to_v1(ParallelTensorShape const &t);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor.h b/lib/pcg/include/pcg/file_format/v1/tensor.h
index 7aaf0012de..608bae3cc3 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor.h
@@ -1,25 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_H
 
-#include "data_type.h"
 #include "initializer.h"
-#include "op-attrs/tensor_shape.h"
+#include "tensor_shape.h"
 #include "param_sync.h"
 #include "pcg/tensor.h"
 #include "utils/visitable.h"
-#include <vector>
 
 namespace FlexFlow {
 
-struct V1TensorShape {
-  req<std::vector<size_t>> dims;
-  req<V1DataType> data_type;
-};
-FF_VISITABLE_STRUCT(V1TensorShape, dims, data_type);
-CHECK_IS_JSONABLE(V1TensorShape);
-
-V1TensorShape to_v1(TensorShape const &);
-
 struct V1Tensor {
   V1TensorShape shape;
   req<bool> create_gradients;
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
new file mode 100644
index 0000000000..309312e107
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
@@ -0,0 +1,28 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_SHAPE_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_SHAPE_H
+
+#include "datatype.h"
+#include "dim_ordered.h"
+#include "op-attrs/ff_dim.h"
+#include "op-attrs/tensor_shape.h"
+#include "utils/visitable.h"
+
+namespace FlexFlow {
+
+// using V1TensorDims = V1FFOrdered<size_t>;
+// CHECK_IS_JSONABLE(V1TensorDims);
+
+struct V1TensorShape {
+public:
+  // req<V1TensorDims> dims;
+  req<V1DataType> data_type;
+};
+FF_VISITABLE_STRUCT(V1TensorShape, // dims,
+                    data_type);
+CHECK_IS_JSONABLE(V1TensorShape);
+
+V1TensorShape to_v1(TensorShape const &t);
+
+} // namespace FlexFlow
+
+#endif

From 939ec2f664fc7bda857b9414974595f8f931a9b7 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Tue, 3 Oct 2023 16:38:01 -0600
Subject: [PATCH 05/15] Add definitions for to_v1 functions for most operators
 and data structures. Some other to_v1 methods have been provided but will
 error at runtime due to hitting a NOT_IMPLEMENTED macro. Disable some fields
 and types because of a bug where std::vector is reported as being not
 serializable to json. The sole test case builds, but fails because of hitting
 a a NOT_IMPLEMENTED assertion.

---
 .../include/pcg/file_format/v1/activation.h   |   3 +
 lib/pcg/include/pcg/file_format/v1/datatype.h |   3 +
 lib/pcg/include/pcg/file_format/v1/ff_dim.h   |  14 ++
 .../include/pcg/file_format/v1/initializer.h  |  10 +
 lib/pcg/include/pcg/file_format/v1/op.h       | 192 ++++++++++++++++++
 .../pcg/file_format/v1/operator_attrs.h       |  28 ++-
 .../pcg/file_format/v1/ops/broadcast.h        |   5 +-
 lib/pcg/include/pcg/file_format/v1/ops/cast.h |   5 +-
 .../include/pcg/file_format/v1/ops/combine.h  |   3 +-
 .../include/pcg/file_format/v1/ops/concat.h   |   4 +-
 .../include/pcg/file_format/v1/ops/conv_2d.h  |   4 +-
 .../pcg/file_format/v1/ops/element_binary.h   |   8 +-
 .../pcg/file_format/v1/ops/element_unary.h    |   6 +-
 .../pcg/file_format/v1/ops/embedding.h        |   2 +
 .../include/pcg/file_format/v1/ops/gather.h   |   3 +-
 .../include/pcg/file_format/v1/ops/input.h    |   1 +
 .../pcg/file_format/v1/ops/layer_norm.h       |  11 +-
 .../include/pcg/file_format/v1/ops/linear.h   |   2 +-
 lib/pcg/include/pcg/file_format/v1/ops/noop.h |   1 +
 .../include/pcg/file_format/v1/ops/pool_2d.h  |  17 +-
 .../include/pcg/file_format/v1/ops/reduce.h   |   8 +-
 .../pcg/file_format/v1/ops/reduction.h        |   4 +-
 .../pcg/file_format/v1/ops/repartition.h      |   4 +-
 .../pcg/file_format/v1/ops/replicate.h        |   4 +-
 .../include/pcg/file_format/v1/ops/reverse.h  |   5 +-
 .../include/pcg/file_format/v1/ops/softmax.h  |   3 +-
 .../include/pcg/file_format/v1/ops/split.h    |   6 +-
 .../pcg/file_format/v1/ops/transpose.h        |  12 +-
 .../include/pcg/file_format/v1/param_sync.h   |   4 +-
 .../include/pcg/file_format/v1/tensor_shape.h |   8 +
 lib/pcg/include/pcg/file_format/v1/v1.h       |  22 ++
 lib/pcg/src/file_format/v1/activation.cc      |   9 +
 lib/pcg/src/file_format/v1/datatype.cc        |   9 +
 lib/pcg/src/file_format/v1/ff_dim.cc          |   9 +
 lib/pcg/src/file_format/v1/graphs.cc          |   4 +
 lib/pcg/src/file_format/v1/initializer.cc     |  29 +++
 lib/pcg/src/file_format/v1/op.cc              |   9 +
 lib/pcg/src/file_format/v1/operator_attrs.cc  |  19 +-
 lib/pcg/src/file_format/v1/ops/aggregate.cc   |  10 +
 .../src/file_format/v1/ops/aggregate_spec.cc  |  10 +
 lib/pcg/src/file_format/v1/ops/attention.cc   |  17 ++
 .../src/file_format/v1/ops/batch_matmul.cc    |  10 +
 lib/pcg/src/file_format/v1/ops/batch_norm.cc  |  10 +
 lib/pcg/src/file_format/v1/ops/broadcast.cc   |  10 +
 lib/pcg/src/file_format/v1/ops/cast.cc        |  10 +
 lib/pcg/src/file_format/v1/ops/combine.cc     |  11 +
 lib/pcg/src/file_format/v1/ops/concat.cc      |  11 +
 lib/pcg/src/file_format/v1/ops/conv_2d.cc     |  19 ++
 lib/pcg/src/file_format/v1/ops/dropout.cc     |  10 +
 .../src/file_format/v1/ops/element_binary.cc  |  13 ++
 .../src/file_format/v1/ops/element_unary.cc   |  14 ++
 lib/pcg/src/file_format/v1/ops/embedding.cc   |  17 ++
 lib/pcg/src/file_format/v1/ops/flat.cc        |  12 ++
 lib/pcg/src/file_format/v1/ops/gather.cc      |  11 +
 lib/pcg/src/file_format/v1/ops/groupby.cc     |  10 +
 lib/pcg/src/file_format/v1/ops/input.cc       |  12 ++
 lib/pcg/src/file_format/v1/ops/layer_norm.cc  |  13 ++
 lib/pcg/src/file_format/v1/ops/linear.cc      |  26 +++
 lib/pcg/src/file_format/v1/ops/noop.cc        |  12 ++
 lib/pcg/src/file_format/v1/ops/pool_2d.cc     |  21 ++
 lib/pcg/src/file_format/v1/ops/reduce.cc      |  13 ++
 lib/pcg/src/file_format/v1/ops/reduction.cc   |  11 +
 lib/pcg/src/file_format/v1/ops/repartition.cc |  11 +
 lib/pcg/src/file_format/v1/ops/replicate.cc   |  11 +
 lib/pcg/src/file_format/v1/ops/reshape.cc     |  10 +
 lib/pcg/src/file_format/v1/ops/reverse.cc     |  11 +
 lib/pcg/src/file_format/v1/ops/softmax.cc     |  11 +
 lib/pcg/src/file_format/v1/ops/split.cc       |  11 +
 lib/pcg/src/file_format/v1/ops/topk.cc        |  10 +
 lib/pcg/src/file_format/v1/ops/transpose.cc   |  11 +
 lib/pcg/src/file_format/v1/parallel_tensor.cc |   9 +
 lib/pcg/src/file_format/v1/tensor_shape.cc    |   9 +
 72 files changed, 828 insertions(+), 79 deletions(-)
 create mode 100644 lib/pcg/include/pcg/file_format/v1/ff_dim.h
 create mode 100644 lib/pcg/include/pcg/file_format/v1/op.h
 create mode 100644 lib/pcg/src/file_format/v1/activation.cc
 create mode 100644 lib/pcg/src/file_format/v1/datatype.cc
 create mode 100644 lib/pcg/src/file_format/v1/ff_dim.cc
 create mode 100644 lib/pcg/src/file_format/v1/initializer.cc
 create mode 100644 lib/pcg/src/file_format/v1/op.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/aggregate.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/attention.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/batch_matmul.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/batch_norm.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/broadcast.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/cast.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/combine.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/concat.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/conv_2d.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/dropout.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/element_binary.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/element_unary.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/embedding.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/flat.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/gather.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/groupby.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/input.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/layer_norm.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/linear.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/noop.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/pool_2d.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/reduce.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/reduction.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/repartition.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/replicate.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/reshape.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/reverse.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/softmax.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/split.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/topk.cc
 create mode 100644 lib/pcg/src/file_format/v1/ops/transpose.cc
 create mode 100644 lib/pcg/src/file_format/v1/parallel_tensor.cc
 create mode 100644 lib/pcg/src/file_format/v1/tensor_shape.cc

diff --git a/lib/pcg/include/pcg/file_format/v1/activation.h b/lib/pcg/include/pcg/file_format/v1/activation.h
index 38a93021db..47ad6b6331 100644
--- a/lib/pcg/include/pcg/file_format/v1/activation.h
+++ b/lib/pcg/include/pcg/file_format/v1/activation.h
@@ -1,6 +1,7 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_ACTIVATION_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_ACTIVATION_H
 
+#include "op-attrs/activation.h"
 #include "utils/json.h"
 
 namespace FlexFlow {
@@ -13,6 +14,8 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1Activation,
                               {V1Activation::TANH, "TANH"},
                               {V1Activation::GELU, "GELU"}});
 
+V1Activation to_v1(Activation const &a);
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/file_format/v1/datatype.h b/lib/pcg/include/pcg/file_format/v1/datatype.h
index dad98e462d..8d05c7f889 100644
--- a/lib/pcg/include/pcg/file_format/v1/datatype.h
+++ b/lib/pcg/include/pcg/file_format/v1/datatype.h
@@ -1,6 +1,7 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_DATA_TYPE_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_DATA_TYPE_H
 
+#include "op-attrs/datatype.h"
 #include "utils/fp16.h"
 #include "utils/json.h"
 #include "utils/variant.h"
@@ -26,6 +27,8 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1DataType,
                               {V1DataType::FLOAT, "FLOAT"},
                               {V1DataType::DOUBLE, "DOUBLE"}});
 
+V1DataType to_v1(DataType const &d);
+
 } // namespace FlexFlow
 
 namespace nlohmann {
diff --git a/lib/pcg/include/pcg/file_format/v1/ff_dim.h b/lib/pcg/include/pcg/file_format/v1/ff_dim.h
new file mode 100644
index 0000000000..00e4491bea
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/ff_dim.h
@@ -0,0 +1,14 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_FF_DIM_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_FF_DIM_H
+
+#include "op-attrs/ff_dim.h"
+
+namespace FlexFlow {
+
+// ff_dim_t is a strong typedef of int. This is unlikely to change, but if it
+// does, this signature will need to be updated.
+int to_v1(ff_dim_t const &t);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/initializer.h b/lib/pcg/include/pcg/file_format/v1/initializer.h
index f69ce06439..dc3eada212 100644
--- a/lib/pcg/include/pcg/file_format/v1/initializer.h
+++ b/lib/pcg/include/pcg/file_format/v1/initializer.h
@@ -17,9 +17,13 @@ struct V1GlorotInitializer {
 FF_VISITABLE_STRUCT(V1GlorotInitializer, seed);
 CHECK_IS_JSONABLE(V1GlorotInitializer);
 
+V1GlorotInitializer to_v1(GlorotUniform const &i);
+
 struct V1ZeroInitializer {};
 FF_VISITABLE_STRUCT(V1ZeroInitializer);
 
+V1ZeroInitializer to_v1(ZeroInitializer const &i);
+
 struct V1UniformInitializer {
   req<int> seed;
   req<float> min_val;
@@ -28,6 +32,8 @@ struct V1UniformInitializer {
 FF_VISITABLE_STRUCT(V1UniformInitializer, seed, min_val, max_val);
 CHECK_IS_JSONABLE(V1UniformInitializer);
 
+V1UniformInitializer to_v1(UniformInitializer const &i);
+
 struct V1NormInitializer {
   req<int> seed;
   req<float> mean;
@@ -36,12 +42,16 @@ struct V1NormInitializer {
 FF_VISITABLE_STRUCT(V1NormInitializer, seed, mean, stddev);
 CHECK_IS_JSONABLE(V1NormInitializer);
 
+V1NormInitializer to_v1(NormInitializer const &i);
+
 struct V1ConstantInitializer {
   req<V1DataTypeValue> value;
 };
 FF_VISITABLE_STRUCT(V1ConstantInitializer, value);
 CHECK_IS_JSONABLE(V1ConstantInitializer);
 
+V1ConstantInitializer to_v1(ConstantInitializer const &i);
+
 using V1Initializer = variant<V1GlorotInitializer,
                               V1ZeroInitializer,
                               V1UniformInitializer,
diff --git a/lib/pcg/include/pcg/file_format/v1/op.h b/lib/pcg/include/pcg/file_format/v1/op.h
new file mode 100644
index 0000000000..ebd8decc12
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/op.h
@@ -0,0 +1,192 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OP_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OP_H
+
+#include "op-attrs/op.h"
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+enum class V1Op {
+  NOOP,
+  INPUT,
+  WEIGHT,
+  CONV2D,
+  DROPOUT,
+  LINEAR,
+  BATCHMATMUL,
+  POOL2D,
+  SCALAR_MULTIPLY,
+  SCALAR_ADD,
+  SCALAR_FLOOR_DIV,
+  SCALAR_TRUE_DIV,
+  SCALAR_SUB,
+  RELU,
+  IDENTITY,
+  SIGMOID,
+  TANH,
+  ELU,
+  FLAT,
+  SOFTMAX,
+  BATCHNORM,
+  CONCAT,
+  SPLIT,
+  EMBEDDING,
+  GROUP_BY,
+  CACHE,
+  AGGREGATE,
+  AGG_SPEC,
+  // OP_ELEMENTWISE,
+  RESHAPE,
+  REVERSE,
+  TRANSPOSE,
+  EW_ADD,
+  EW_MUL,
+  MATMUL,
+  MUL,
+  ENLARGE,
+  SQUEEZE,
+  UNSQUEEZE,
+  EW_SUB,
+  EW_DIV,
+  EW_EQUAL,
+  EW_GREATER,
+  EW_LESS,
+  EW_MAX,
+  EW_MIN,
+  REDUCE_ARGMAX,
+  REDUCE_ARGMIN,
+  REDUCE_MAX,
+  REDUCE_MEAN,
+  REDUCE_MIN,
+  REDUCE_PROD,
+  REDUCE_SUM,
+  PAD,
+  SHAPE,
+  SIZE,
+  TOPK,
+  WHERE,
+  CEIL,
+  CAST,
+  EXP,
+  ROUND,
+  LOG,
+  LOGICAL_NOT,
+  SQRT,
+  SIN,
+  COS,
+  LEAKYRELU,
+  SLICE,
+  RESIZE,
+  PRELU,
+  GELU,
+  MULTIHEAD_ATTENTION,
+  FUSED,
+  RSQRT,
+  POW,
+  MEAN,
+  LAYERNORM,
+  GATHER,
+  BROADCAST,
+  REPARTITION,
+  COMBINE,
+  REPLICATE,
+  REDUCTION,
+  BATCH,
+  PIPELINE,
+  FUSED_PARALLEL,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(V1Op,
+                             {{V1Op::NOOP, "NOOP"},
+                              {V1Op::INPUT, "INPUT"},
+                              {V1Op::WEIGHT, "WEIGHT"},
+                              {V1Op::CONV2D, "CONV2D"},
+                              {V1Op::DROPOUT, "DROPOUT"},
+                              {V1Op::LINEAR, "LINEAR"},
+                              {V1Op::BATCHMATMUL, "BATCHMATMUL"},
+                              {V1Op::POOL2D, "POOL2D"},
+                              {V1Op::SCALAR_MULTIPLY, "SCALAR_MULTIPLY"},
+                              {V1Op::SCALAR_ADD, "SCALAR_ADD"},
+                              {V1Op::SCALAR_FLOOR_DIV, "SCALAR_FLOOR_DIV"},
+                              {V1Op::SCALAR_TRUE_DIV, "SCALAR_TRUE_DIV"},
+                              {V1Op::SCALAR_SUB, "SCALAR_SUB"},
+                              {V1Op::RELU, "RELU"},
+                              {V1Op::IDENTITY, "IDENTITY"},
+                              {V1Op::SIGMOID, "SIGMOID"},
+                              {V1Op::TANH, "TANH"},
+                              {V1Op::ELU, "ELU"},
+                              {V1Op::FLAT, "FLAT"},
+                              {V1Op::SOFTMAX, "SOFTMAX"},
+                              {V1Op::BATCHNORM, "BATCHNORM"},
+                              {V1Op::CONCAT, "CONCAT"},
+                              {V1Op::SPLIT, "SPLIT"},
+                              {V1Op::EMBEDDING, "EMBEDDING"},
+                              {V1Op::GROUP_BY, "GROUP_BY"},
+                              {V1Op::CACHE, "CACHE"},
+                              {V1Op::AGGREGATE, "AGGREGATE"},
+                              {V1Op::AGG_SPEC, "AGG_SPEC"},
+                              {V1Op::RESHAPE, "RESHAPE"},
+                              {V1Op::REVERSE, "REVERSE"},
+                              {V1Op::TRANSPOSE, "TRANSPOSE"},
+                              {V1Op::EW_ADD, "EW_ADD"},
+                              {V1Op::EW_MUL, "EW_MUL"},
+                              {V1Op::MATMUL, "MATMUL"},
+                              {V1Op::MUL, "MUL"},
+                              {V1Op::ENLARGE, "ENLARGE"},
+                              {V1Op::SQUEEZE, "SQUEEZE"},
+                              {V1Op::UNSQUEEZE, "UNSQUEEZE"},
+                              {V1Op::EW_SUB, "EW_SUB"},
+                              {V1Op::EW_DIV, "EW_DIV"},
+                              {V1Op::EW_EQUAL, "EW_EQUAL"},
+                              {V1Op::EW_GREATER, "EW_GREATER"},
+                              {V1Op::EW_LESS, "EW_LESS"},
+                              {V1Op::EW_MAX, "EW_MAX"},
+                              {V1Op::EW_MIN, "EW_MIN"},
+                              {V1Op::REDUCE_ARGMAX, "REDUCE_ARGMAX"},
+                              {V1Op::REDUCE_ARGMIN, "REDUCE_ARGMIN"},
+                              {V1Op::REDUCE_MAX, "REDUCE_MAX"},
+                              {V1Op::REDUCE_MEAN, "REDUCE_MEAN"},
+                              {V1Op::REDUCE_MIN, "REDUCE_MIN"},
+                              {V1Op::REDUCE_PROD, "REDUCE_PROD"},
+                              {V1Op::REDUCE_SUM, "REDUCE_SUM"},
+                              {V1Op::PAD, "PAD"},
+                              {V1Op::SHAPE, "SHAPE"},
+                              {V1Op::SIZE, "SIZE"},
+                              {V1Op::TOPK, "TOPK"},
+                              {V1Op::WHERE, "WHERE"},
+                              {V1Op::CEIL, "CEIL"},
+                              {V1Op::CAST, "CAST"},
+                              {V1Op::EXP, "EXP"},
+                              {V1Op::ROUND, "ROUND"},
+                              {V1Op::LOG, "LOG"},
+                              {V1Op::LOGICAL_NOT, "LOGICAL_NOT"},
+                              {V1Op::SQRT, "SQRT"},
+                              {V1Op::SIN, "SIN"},
+                              {V1Op::COS, "COS"},
+                              {V1Op::LEAKYRELU, "LEAKYRELU"},
+                              {V1Op::SLICE, "SLICE"},
+                              {V1Op::RESIZE, "RESIZE"},
+                              {V1Op::PRELU, "PRELU"},
+                              {V1Op::GELU, "GELU"},
+                              {V1Op::MULTIHEAD_ATTENTION,
+                               "MULTIHEAD_ATTENTION"},
+                              {V1Op::FUSED, "FUSED"},
+                              {V1Op::RSQRT, "RSQRT"},
+                              {V1Op::POW, "POW"},
+                              {V1Op::MEAN, "MEAN"},
+                              {V1Op::LAYERNORM, "LAYERNORM"},
+                              {V1Op::GATHER, "GATHER"},
+                              {V1Op::BROADCAST, "BROADCAST"},
+                              {V1Op::REPARTITION, "REPARTITION"},
+                              {V1Op::COMBINE, "COMBINE"},
+                              {V1Op::REPLICATE, "REPLICATE"},
+                              {V1Op::REDUCTION, "REDUCTION"},
+                              {V1Op::BATCH, "BATCH"},
+                              {V1Op::PIPELINE, "PIPELINE"},
+                              {V1Op::FUSED_PARALLEL, "FUSED_PARALLEL"}});
+
+V1Op to_v1(Op const &op);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
index d3f1b9dc41..e3dda69c71 100644
--- a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
+++ b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
@@ -21,11 +21,15 @@
 #include "ops/gather.h"
 #include "ops/groupby.h"
 #include "ops/input.h"
-#include "ops/layer_norm.h"
+// FIXME: Re-enable this once the JSON issues with std::vector have been
+// resolved.
+// #include "ops/layer_norm.h"
 #include "ops/linear.h"
 #include "ops/noop.h"
 #include "ops/pool_2d.h"
-#include "ops/reduce.h"
+// FIXME: Re-enable this once the JSON issues with std::vector have been
+// resolved.
+// #include "ops/reduce.h"
 #include "ops/reduction.h"
 #include "ops/repartition.h"
 #include "ops/replicate.h"
@@ -34,12 +38,18 @@
 #include "ops/softmax.h"
 #include "ops/split.h"
 #include "ops/topk.h"
-#include "ops/transpose.h"
+// FIXME: Re-enable this once the JSON issues with std::vector have been
+// resolved.
+// #include "ops/transpose.h"
 #include "utils/json.h"
 #include "utils/variant.h"
 
 namespace FlexFlow {
 
+// TODO: Re-enable V1LayerNormAttrs, V1ReduceAttrs, V1TransposeAttrs are
+// disabled because they use std::vector which triggers an error saying that
+// it cannot be serialized to JSON (when it actually ought to be serializable).
+// To get this to build for the moment, they have been disabled.
 using V1SharedOperatorAttrs = variant<V1AggregateAttrs,
                                       V1AggregateSpecAttrs,
                                       V1BatchMatmulAttrs,
@@ -56,18 +66,19 @@ using V1SharedOperatorAttrs = variant<V1AggregateAttrs,
                                       V1GatherAttrs,
                                       V1Group_byAttrs,
                                       V1InputAttrs,
-                                      V1LayerNormAttrs,
+                                      // V1LayerNormAttrs,
                                       V1LinearAttrs,
                                       V1MultiHeadAttentionAttrs,
                                       V1NoopAttrs,
                                       V1Pool2DAttrs,
-                                      V1ReduceAttrs,
+                                      // V1ReduceAttrs,
                                       V1ReverseAttrs,
                                       V1ReshapeAttrs,
                                       V1SplitAttrs,
                                       V1SoftmaxAttrs,
-                                      V1TopKAttrs,
-                                      V1TransposeAttrs>;
+                                      V1TopKAttrs
+                                      // V1TransposeAttrs
+                                      >;
 
 using V1ParallelOperatorAttrs = variant<V1CombineAttrs,
                                         V1ReductionAttrs,
@@ -82,8 +93,7 @@ using V1PCGOperatorAttrs =
     variant_join<V1SharedOperatorAttrs, V1ParallelOperatorAttrs>;
 
 V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
-
-V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
+V1PCGOperatorAttrs to_v1(PCGOperatorAttrs const &attrs);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
index 424bc8eb61..bdd10c430e 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
@@ -1,13 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BROADCAST_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BROADCAST_H
 
-#include "utils/stack_vector.h"
+#include "op-attrs/ops/broadcast.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1BroadcastAttrs {
-  req<stack_vector<int, MAX_TENSOR_DIM>> target_dims;
+  // The size of this vector must be <= MAX_TENSOR_DIM
+  req<std::vector<int>> target_dims;
 };
 FF_VISITABLE_STRUCT(V1BroadcastAttrs, target_dims);
 CHECK_IS_JSONABLE(V1BroadcastAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/cast.h b/lib/pcg/include/pcg/file_format/v1/ops/cast.h
index c7e5201630..09035e5240 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/cast.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/cast.h
@@ -2,13 +2,14 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CAST_ATTRS_H
 
 #include "op-attrs/ops/cast.h"
-#include "op-attrs/datatype.h"
+#include "pcg/file_format/v1/datatype.h"
+#include "utils/json.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1CastAttrs {
-  req<DataType> dtype;
+  req<V1DataType> dtype;
 };
 FF_VISITABLE_STRUCT(V1CastAttrs, dtype);
 CHECK_IS_JSONABLE(V1CastAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/combine.h b/lib/pcg/include/pcg/file_format/v1/ops/combine.h
index d7f006584c..d120f17b95 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/combine.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/combine.h
@@ -1,14 +1,13 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_COMBINE_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_COMBINE_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/combine.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1CombineAttrs {
-  ff_dim_t combine_dim;
+  int combine_dim;
   req<int> combine_degree;
 };
 FF_VISITABLE_STRUCT(V1CombineAttrs, combine_dim, combine_degree);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/concat.h b/lib/pcg/include/pcg/file_format/v1/ops/concat.h
index f15abb9e99..0c498667b6 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/concat.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/concat.h
@@ -1,14 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONCAT_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONCAT_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/concat.h"
+#include "pcg/file_format/v1/ff_dim.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ConcatAttrs {
-  ff_dim_t axis;
+  req<int> axis;
 };
 FF_VISITABLE_STRUCT(V1ConcatAttrs, axis);
 CHECK_IS_JSONABLE(V1ConcatAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h b/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
index b995dbad32..6d047a3bd7 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
@@ -1,8 +1,8 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONV_2D_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_CONV_2D_ATTRS_H
 
-#include "op-attrs/activation.h"
 #include "op-attrs/ops/conv_2d.h"
+#include "pcg/file_format/v1/activation.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
@@ -10,7 +10,7 @@ namespace FlexFlow {
 struct V1Conv2DAttrs {
   req<int> out_channels, kernel_h, kernel_w, stride_h, stride_w, padding_h,
       padding_w, groups;
-  req<optional<Activation>> activation;
+  req<optional<V1Activation>> activation;
   req<bool> use_bias;
 };
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h b/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
index a01992d034..197c06ccbc 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
@@ -1,16 +1,16 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENT_BINARY_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENT_BINARY_ATTRS_H
 
-#include "op-attrs/datatype.h"
-#include "op-attrs/op.h"
 #include "op-attrs/ops/element_binary.h"
+#include "pcg/file_format/v1/datatype.h"
+#include "pcg/file_format/v1/op.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ElementBinaryAttrs {
-  req<Op> type;
-  req<DataType> compute_type;
+  req<V1Op> type;
+  req<V1DataType> compute_type;
   req<bool> should_broadcast_lhs;
   req<bool> should_broadcast_rhs;
 };
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h b/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
index a697fac940..1623f84d7f 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
@@ -1,14 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENTARY_UNARY_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_ELEMENTARY_UNARY_ATTRS_H
 
-#include "op-attrs/op.h"
 #include "op-attrs/ops/element_unary.h"
+#include "pcg/file_format/v1/op.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ElementScalarUnaryAttrs {
-  req<Op> op;
+  req<V1Op> op;
   req<float> scalar;
 };
 FF_VISITABLE_STRUCT(V1ElementScalarUnaryAttrs, op, scalar);
@@ -17,7 +17,7 @@ CHECK_IS_JSONABLE(V1ElementScalarUnaryAttrs);
 V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &attrs);
 
 struct V1ElementUnaryAttrs {
-  req<Op> op;
+  req<V1Op> op;
 };
 FF_VISITABLE_STRUCT(V1ElementUnaryAttrs, op);
 CHECK_IS_JSONABLE(V1ElementUnaryAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/embedding.h b/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
index 29c81bcb92..8d7cdc5dfd 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
@@ -16,6 +16,8 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1AggregateOp,
                              {{V1AggregateOp::SUM, "SUM"},
                               {V1AggregateOp::AVG, "AVG"}});
 
+V1AggregateOp to_v1(AggregateOp const &op);
+
 struct V1EmbeddingAttrs {
   req<int> num_entries, out_channels;
   req<V1AggregateOp> aggr;
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/gather.h b/lib/pcg/include/pcg/file_format/v1/ops/gather.h
index a8b8437ca8..1266bc04df 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/gather.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/gather.h
@@ -1,14 +1,13 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_GATHER_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_GATHER_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/gather.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1GatherAttrs {
-  ff_dim_t dim;
+  req<int> dim;
 };
 FF_VISITABLE_STRUCT(V1GatherAttrs, dim);
 CHECK_IS_JSONABLE(V1GatherAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/input.h b/lib/pcg/include/pcg/file_format/v1/ops/input.h
index b664a9a85b..2c831b2979 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/input.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/input.h
@@ -2,6 +2,7 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_INPUT_H
 
 #include "op-attrs/ops/input.h"
+#include "utils/json.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h b/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
index 4edbacfabd..2abd046af1 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
@@ -1,22 +1,19 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LAYER_NORM_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LAYER_NORM_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/layer_norm.h"
+#include "pcg/file_format/v1/ff_dim.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1LayerNormAttrs {
-  // FIXME: stack_vector is probably causing a problem because it is not
-  // automatically (de)serializable, but need to ensure that one way or the
-  // other.
-  // stack_vector<ff_dim_t, MAX_TENSOR_DIM> axes;
+  // The size of this vector must be <= MAX_TENSOR_DIMS
+  std::vector<int> axes;
   req<bool> elementwise_affine;
   req<float> eps;
 };
-FF_VISITABLE_STRUCT(V1LayerNormAttrs, // axes,
-                    elementwise_affine, eps);
+FF_VISITABLE_STRUCT(V1LayerNormAttrs, axes, elementwise_affine, eps);
 CHECK_IS_JSONABLE(V1LayerNormAttrs);
 
 V1LayerNormAttrs to_v1(LayerNormAttrs const &attrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/linear.h b/lib/pcg/include/pcg/file_format/v1/ops/linear.h
index 33f239d878..3a5c8f14a4 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/linear.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/linear.h
@@ -2,7 +2,6 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_LINEAR_ATTRS_H
 
 #include "op-attrs/ops/linear.h"
-#include "op-attrs/parallel_tensor_shape.h"
 #include "pcg/file_format/v1/activation.h"
 #include "pcg/file_format/v1/datatype.h"
 #include "utils/visitable.h"
@@ -26,6 +25,7 @@ CHECK_IS_JSONABLE(V1L2RegularizerAttrs);
 V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &attrs);
 
 using V1RegularizerAttrs = variant<V1L1RegularizerAttrs, V1L2RegularizerAttrs>;
+V1RegularizerAttrs to_v1(RegularizerAttrs const &);
 
 struct V1LinearAttrs {
   req<int> out_channels;
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/noop.h b/lib/pcg/include/pcg/file_format/v1/ops/noop.h
index afd7326710..dbdbaa18ad 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/noop.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/noop.h
@@ -2,6 +2,7 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_NOOP_H
 
 #include "op-attrs/ops/noop.h"
+#include "utils/json.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h b/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
index c27940ee03..fd6a2c7b0f 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
@@ -1,16 +1,27 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_POOL_2D_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_POOL_2D_ATTRS_H
 
-#include "op-attrs/activation.h"
 #include "op-attrs/ops/pool_2d.h"
+#include "pcg/file_format/v1/activation.h"
+#include "utils/json.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
+enum class V1PoolOp {
+  MAX,
+  AVG,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(V1PoolOp,
+                             {{V1PoolOp::MAX, "MAX"}, {V1PoolOp::AVG, "AVG"}});
+
+V1PoolOp to_v1(PoolOp const &op);
+
 struct V1Pool2DAttrs {
   req<int> kernel_h, kernel_w, stride_h, stride_w, padding_h, padding_w;
-  req<PoolOp> pool_type;
-  req<Activation> activation;
+  req<V1PoolOp> pool_type;
+  req<V1Activation> activation;
 };
 FF_VISITABLE_STRUCT(V1Pool2DAttrs,
                     kernel_h,
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reduce.h b/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
index 8b8baa741f..c675c65725 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
@@ -1,17 +1,17 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCE_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCE_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
-#include "op-attrs/op.h"
 #include "op-attrs/ops/reduce.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/op.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ReduceAttrs {
   // The size of this vector is <= MAX_TENSOR_DIMS.
-  req<std::vector<ff_dim_t>> axes;
-  req<Op> op_type;
+  req<std::vector<int>> axes;
+  req<V1Op> op_type;
   req<bool> keepdims;
 };
 FF_VISITABLE_STRUCT(V1ReduceAttrs, axes, op_type, keepdims);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reduction.h b/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
index 989b33871b..cfc012fdf5 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
@@ -1,14 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCTION_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REDUCTION_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/reduction.h"
+#include "pcg/file_format/v1/ff_dim.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ReductionAttrs {
-  ff_dim_t reduction_dim;
+  int reduction_dim;
   req<int> reduction_degree;
 };
 FF_VISITABLE_STRUCT(V1ReductionAttrs, reduction_dim, reduction_degree);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/repartition.h b/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
index c8bf22d64c..de46e6a69c 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
@@ -1,14 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPARTITION_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPARTITION_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/repartition.h"
+#include "pcg/file_format/v1/ff_dim.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1RepartitionAttrs {
-  ff_dim_t repartition_dim;
+  int repartition_dim;
   req<int> repartition_degree;
 };
 FF_VISITABLE_STRUCT(V1RepartitionAttrs, repartition_dim, repartition_degree);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/replicate.h b/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
index 43f2534b9c..21046b2cac 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
@@ -1,14 +1,14 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPLICATE_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REPLICATE_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/replicate.h"
+#include "pcg/file_format/v1/ff_dim.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ReplicateAttrs {
-  ff_dim_t replicate_dim;
+  int replicate_dim;
   req<int> replicate_degree;
 };
 FF_VISITABLE_STRUCT(V1ReplicateAttrs, replicate_dim, replicate_degree);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reverse.h b/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
index 69985a485b..4c03b85933 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
@@ -1,14 +1,15 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REVERSE_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_REVERSE_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/reverse.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "utils/json.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1ReverseAttrs {
-  ff_dim_t axis;
+  req<int> axis;
 };
 FF_VISITABLE_STRUCT(V1ReverseAttrs, axis);
 CHECK_IS_JSONABLE(V1ReverseAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/softmax.h b/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
index 4ab60fcdcf..193c9ca09f 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
@@ -1,14 +1,13 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SOFTMAX_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SOFTMAX_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/softmax.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1SoftmaxAttrs {
-  ff_dim_t dim;
+  req<int> dim;
 };
 FF_VISITABLE_STRUCT(V1SoftmaxAttrs, dim);
 CHECK_IS_JSONABLE(V1SoftmaxAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/split.h b/lib/pcg/include/pcg/file_format/v1/ops/split.h
index 00ffd033d2..658ca92149 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/split.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/split.h
@@ -1,15 +1,15 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SPLIT_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_SPLIT_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/split.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1SplitAttrs {
-  req<stack_vector<int, MAX_NUM_OUTPUTS>> splits;
-  ff_dim_t axis;
+  // The size of this vector must be <= MAX_TENSOR_DIM
+  std::vector<int> splits;
+  req<int> axis;
 };
 FF_VISITABLE_STRUCT(V1SplitAttrs, splits, axis);
 CHECK_IS_JSONABLE(V1SplitAttrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/transpose.h b/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
index f2f5d28c13..c53dcf85e1 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
@@ -1,21 +1,17 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_TRANSPOSE_ATTRS_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_TRANSPOSE_ATTRS_H
 
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/ops/transpose.h"
+#include "pcg/file_format/v1/ff_dim.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
 struct V1TransposeAttrs {
-  // FIXME: stack_vector is probably causing a problem because it is not
-  // automatically (de)serializable, but need to ensure that one way or the
-  // other.
-  // stack_vector<ff_dim_t, MAX_TENSOR_DIM> axes;
-  // req<stack_vector<ff_dim_t, MAX_TENSOR_DIM>> perm;
+  // The size of this vector must be <= MAX_TENSOR_DIMS
+  req<std::vector<int>> perm;
 };
-FF_VISITABLE_STRUCT(V1TransposeAttrs// , perm
-                    );
+FF_VISITABLE_STRUCT(V1TransposeAttrs, perm);
 CHECK_IS_JSONABLE(V1TransposeAttrs);
 
 V1TransposeAttrs to_v1(TransposeAttrs const &attrs);
diff --git a/lib/pcg/include/pcg/file_format/v1/param_sync.h b/lib/pcg/include/pcg/file_format/v1/param_sync.h
index 286abd9c11..d97a9d21b4 100644
--- a/lib/pcg/include/pcg/file_format/v1/param_sync.h
+++ b/lib/pcg/include/pcg/file_format/v1/param_sync.h
@@ -8,12 +8,12 @@ namespace FlexFlow {
 
 enum class V1ParamSync { PARAM_SERVER, NCCL };
 
-V1ParamSync to_v1(ParamSync const &);
-
 NLOHMANN_JSON_SERIALIZE_ENUM(V1ParamSync,
                              {{V1ParamSync::PARAM_SERVER, "PARAM_SERVER"},
                               {V1ParamSync::NCCL, "NCCL"}});
 
+V1ParamSync to_v1(ParamSync const &);
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
index 309312e107..4d3f72da7c 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
@@ -9,14 +9,22 @@
 
 namespace FlexFlow {
 
+// TODO: V1TensorDims has been commented out because std::vector causes a
+// strange error saying it cannot be serialized to JSON and we would like to
+// get this to build.
 // using V1TensorDims = V1FFOrdered<size_t>;
 // CHECK_IS_JSONABLE(V1TensorDims);
 
 struct V1TensorShape {
 public:
+  // TODO: This should be re-enabled. See the comment above the commented out
+  // definition of V1TensorDims.
   // req<V1TensorDims> dims;
   req<V1DataType> data_type;
 };
+// TODO: This should be re-enabled when the dims field of V1TensorShape is
+// re-enabled. See the comment above the commented out definition of
+// V1TensorDims.
 FF_VISITABLE_STRUCT(V1TensorShape, // dims,
                     data_type);
 CHECK_IS_JSONABLE(V1TensorShape);
diff --git a/lib/pcg/include/pcg/file_format/v1/v1.h b/lib/pcg/include/pcg/file_format/v1/v1.h
index afaa4f08b9..bb7b378f07 100644
--- a/lib/pcg/include/pcg/file_format/v1/v1.h
+++ b/lib/pcg/include/pcg/file_format/v1/v1.h
@@ -6,6 +6,17 @@
 
 namespace FlexFlow {
 
+template <typename T,
+          typename std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+T to_v1(T const &t) {
+  return t;
+}
+
+template <typename V1T, typename... Args>
+V1T to_v1(variant<Args...> const &v) {
+  NOT_IMPLEMENTED();
+}
+
 template <typename V1T, typename T>
 optional<V1T> to_v1(optional<T> const &t) {
   if (t.has_value()) {
@@ -15,6 +26,17 @@ optional<V1T> to_v1(optional<T> const &t) {
   }
 }
 
+template <typename T,
+          typename std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+T to_v1(req<T> const &t) {
+  return T(t);
+}
+
+template <typename V1T, typename T>
+V1T to_v1(req<T> const &t) {
+  return to_v1(*t);
+}
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/src/file_format/v1/activation.cc b/lib/pcg/src/file_format/v1/activation.cc
new file mode 100644
index 0000000000..6368dafa88
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/activation.cc
@@ -0,0 +1,9 @@
+#include "pcg/file_format/v1/activation.h"
+
+namespace FlexFlow {
+
+V1Activation to_v1(Activation const &a) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/datatype.cc b/lib/pcg/src/file_format/v1/datatype.cc
new file mode 100644
index 0000000000..4525f7d861
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/datatype.cc
@@ -0,0 +1,9 @@
+#include "pcg/file_format/v1/datatype.h"
+
+namespace FlexFlow {
+
+V1DataType to_v1(DataType const &dt) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ff_dim.cc b/lib/pcg/src/file_format/v1/ff_dim.cc
new file mode 100644
index 0000000000..2cea18f62a
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ff_dim.cc
@@ -0,0 +1,9 @@
+#include "pcg/file_format/v1/ff_dim.h"
+
+namespace FlexFlow {
+
+int to_v1(ff_dim_t const &t) {
+  return t.value();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/graphs.cc b/lib/pcg/src/file_format/v1/graphs.cc
index 02e2cc007b..9081fe2734 100644
--- a/lib/pcg/src/file_format/v1/graphs.cc
+++ b/lib/pcg/src/file_format/v1/graphs.cc
@@ -3,6 +3,10 @@
 
 namespace FlexFlow {
 
+V1Operator to_v1(Operator const &op) {
+  NOT_IMPLEMENTED();
+}
+
 V1Layer to_v1(Layer const &l) {
   return {to_v1(l.attrs), l.name};
 }
diff --git a/lib/pcg/src/file_format/v1/initializer.cc b/lib/pcg/src/file_format/v1/initializer.cc
new file mode 100644
index 0000000000..91855b0b84
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/initializer.cc
@@ -0,0 +1,29 @@
+#include "pcg/file_format/v1/initializer.h"
+
+namespace FlexFlow {
+
+V1GlorotInitializer to_v1(GlorotUniform const &i) {
+  NOT_IMPLEMENTED();
+}
+
+V1ZeroInitializer to_v1(ZeroInitializer const &i) {
+  NOT_IMPLEMENTED();
+}
+
+V1UniformInitializer to_v1(UniformInitializer const &i) {
+  NOT_IMPLEMENTED();
+}
+
+V1NormInitializer to_v1(NormInitializer const &i) {
+  NOT_IMPLEMENTED();
+}
+
+V1ConstantInitializer to_v1(ConstantInitializer const &i) {
+  NOT_IMPLEMENTED();
+}
+
+V1Initializer to_v1(Initializer const &) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/op.cc b/lib/pcg/src/file_format/v1/op.cc
new file mode 100644
index 0000000000..9e48c0bcda
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/op.cc
@@ -0,0 +1,9 @@
+#include "pcg/file_format/v1/op.h"
+
+namespace FlexFlow {
+
+V1Op to_v1(Op const &op) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/operator_attrs.cc b/lib/pcg/src/file_format/v1/operator_attrs.cc
index 5eaff7416a..d0839eda0f 100644
--- a/lib/pcg/src/file_format/v1/operator_attrs.cc
+++ b/lib/pcg/src/file_format/v1/operator_attrs.cc
@@ -3,19 +3,12 @@
 
 namespace FlexFlow {
 
-V1Conv2DAttrs to_v1(Conv2DAttrs const &attrs) {
-  return {
-    attrs.out_channels,
-    attrs.kernel_h,
-    attrs.kernel_w,
-    attrs.stride_h,
-    attrs.stride_w,
-    attrs.padding_h,
-    attrs.padding_w,
-    attrs.groups,
-    attrs.activation,
-    attrs.use_bias,
-  };
+V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs) {
+  NOT_IMPLEMENTED();
+}
+
+V1PCGOperatorAttrs to_v1(PCGOperatorAttrs const &attrs) {
+  NOT_IMPLEMENTED();
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/aggregate.cc b/lib/pcg/src/file_format/v1/ops/aggregate.cc
new file mode 100644
index 0000000000..207b0a3a95
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/aggregate.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/aggregate.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1AggregateAttrs to_v1(AggregateAttrs const &a) {
+  return {to_v1(a.n), to_v1(a.lambda_bal)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc b/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
new file mode 100644
index 0000000000..26d9184988
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/aggregate_spec.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1AggregateSpecAttrs to_v1(AggregateSpecAttrs const &a) {
+  return {to_v1(a.n), to_v1(a.lambda_bal)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/attention.cc b/lib/pcg/src/file_format/v1/ops/attention.cc
new file mode 100644
index 0000000000..4bb7a44b63
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/attention.cc
@@ -0,0 +1,17 @@
+#include "pcg/file_format/v1/ops/attention.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1MultiHeadAttentionAttrs to_v1(MultiHeadAttentionAttrs const &a) {
+  return {to_v1(a.embed_dim),
+          to_v1(a.num_heads),
+          to_v1(a.kdim),
+          to_v1(a.vdim),
+          to_v1(a.dropout),
+          to_v1(a.bias),
+          to_v1(a.add_bias_kv),
+          to_v1(a.add_zero_attn)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/batch_matmul.cc b/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
new file mode 100644
index 0000000000..8a99d36484
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/batch_matmul.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1BatchMatmulAttrs to_v1(BatchMatmulAttrs const &a) {
+  return {to_v1(a.a_seq_length_dim), to_v1(a.b_seq_length_dim)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/batch_norm.cc b/lib/pcg/src/file_format/v1/ops/batch_norm.cc
new file mode 100644
index 0000000000..4c25c170fc
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/batch_norm.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/batch_norm.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1BatchNormAttrs to_v1(BatchNormAttrs const &a) {
+  return {to_v1(a.relu)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/broadcast.cc b/lib/pcg/src/file_format/v1/ops/broadcast.cc
new file mode 100644
index 0000000000..3457be953f
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/broadcast.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/broadcast.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1BroadcastAttrs to_v1(BroadcastAttrs const &a) {
+  return {std::vector<int>(a.target_dims.begin(), a.target_dims.end())};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/cast.cc b/lib/pcg/src/file_format/v1/ops/cast.cc
new file mode 100644
index 0000000000..5a156698e5
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/cast.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/cast.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1CastAttrs to_v1(CastAttrs const &a) {
+  return {to_v1(a.dtype)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/combine.cc b/lib/pcg/src/file_format/v1/ops/combine.cc
new file mode 100644
index 0000000000..7a6d286e21
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/combine.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/combine.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1CombineAttrs to_v1(CombineAttrs const &a) {
+  return {to_v1(a.combine_dim), to_v1(a.combine_degree)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/concat.cc b/lib/pcg/src/file_format/v1/ops/concat.cc
new file mode 100644
index 0000000000..65621b5d27
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/concat.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/concat.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ConcatAttrs to_v1(ConcatAttrs const &a) {
+  return {to_v1(a.axis)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/conv_2d.cc b/lib/pcg/src/file_format/v1/ops/conv_2d.cc
new file mode 100644
index 0000000000..dfa7f2967e
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/conv_2d.cc
@@ -0,0 +1,19 @@
+#include "pcg/file_format/v1/ops/conv_2d.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1Conv2DAttrs to_v1(Conv2DAttrs const &a) {
+  return {to_v1(a.out_channels),
+          to_v1(a.kernel_h),
+          to_v1(a.kernel_w),
+          to_v1(a.stride_h),
+          to_v1(a.stride_w),
+          to_v1(a.padding_h),
+          to_v1(a.padding_w),
+          to_v1(a.groups),
+          to_v1<V1Activation>(a.activation),
+          to_v1(a.use_bias)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/dropout.cc b/lib/pcg/src/file_format/v1/ops/dropout.cc
new file mode 100644
index 0000000000..ef9a6a92eb
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/dropout.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/dropout.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1DropoutAttrs to_v1(DropoutAttrs const &a) {
+  return {to_v1(a.rate), to_v1(a.seed)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/element_binary.cc b/lib/pcg/src/file_format/v1/ops/element_binary.cc
new file mode 100644
index 0000000000..033fda5c41
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/element_binary.cc
@@ -0,0 +1,13 @@
+#include "pcg/file_format/v1/ops/element_binary.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ElementBinaryAttrs to_v1(ElementBinaryAttrs const &a) {
+  return {to_v1(a.type),
+          to_v1(a.compute_type),
+          to_v1(a.should_broadcast_lhs),
+          to_v1(a.should_broadcast_rhs)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/element_unary.cc b/lib/pcg/src/file_format/v1/ops/element_unary.cc
new file mode 100644
index 0000000000..c704860d47
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/element_unary.cc
@@ -0,0 +1,14 @@
+#include "pcg/file_format/v1/ops/element_unary.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &a) {
+  return {to_v1(a.op), to_v1(a.scalar)};
+}
+
+V1ElementUnaryAttrs to_v1(ElementUnaryAttrs const &a) {
+  return {to_v1(a.op)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/embedding.cc b/lib/pcg/src/file_format/v1/ops/embedding.cc
new file mode 100644
index 0000000000..4caefe6f39
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/embedding.cc
@@ -0,0 +1,17 @@
+#include "pcg/file_format/v1/ops/embedding.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1AggregateOp to_v1(AggregateOp const &op) {
+  NOT_IMPLEMENTED();
+}
+
+V1EmbeddingAttrs to_v1(EmbeddingAttrs const &a) {
+  return {to_v1(a.num_entries),
+          to_v1(a.out_channels),
+          to_v1(a.aggr),
+          to_v1(a.data_type)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/flat.cc b/lib/pcg/src/file_format/v1/ops/flat.cc
new file mode 100644
index 0000000000..7166cccde3
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/flat.cc
@@ -0,0 +1,12 @@
+#include "pcg/file_format/v1/ops/flat.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1FlatAttrs to_v1(FlatAttrs const &a) {
+  return {
+      // No fields in FlatAttrs
+  };
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/gather.cc b/lib/pcg/src/file_format/v1/ops/gather.cc
new file mode 100644
index 0000000000..2a93920955
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/gather.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/gather.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1GatherAttrs to_v1(GatherAttrs const &a) {
+  return {to_v1(a.dim)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/groupby.cc b/lib/pcg/src/file_format/v1/ops/groupby.cc
new file mode 100644
index 0000000000..75c7163049
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/groupby.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/groupby.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1Group_byAttrs to_v1(Group_byAttrs const &a) {
+  return {to_v1(a.n), to_v1(a.alpha)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/input.cc b/lib/pcg/src/file_format/v1/ops/input.cc
new file mode 100644
index 0000000000..8ef3462fc6
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/input.cc
@@ -0,0 +1,12 @@
+#include "pcg/file_format/v1/ops/input.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1InputAttrs to_v1(InputAttrs const &a) {
+  return {
+      // No fields in InputAttrs
+  };
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/layer_norm.cc b/lib/pcg/src/file_format/v1/ops/layer_norm.cc
new file mode 100644
index 0000000000..6e2efff5dc
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/layer_norm.cc
@@ -0,0 +1,13 @@
+#include "pcg/file_format/v1/ops/layer_norm.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1LayerNormAttrs to_v1(LayerNormAttrs const &a) {
+  return {std::vector<int>(a.axes.begin(), a.axes.end()),
+          to_v1(a.elementwise_affine),
+          to_v1(a.eps)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/linear.cc b/lib/pcg/src/file_format/v1/ops/linear.cc
new file mode 100644
index 0000000000..b732713fde
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/linear.cc
@@ -0,0 +1,26 @@
+#include "pcg/file_format/v1/ops/linear.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1L1RegularizerAttrs to_v1(L1RegularizerAttrs const &a) {
+  return {to_v1(a.lambda)};
+}
+
+V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &a) {
+  return {to_v1(a.lambda)};
+}
+
+V1RegularizerAttrs to_v1(RegularizerAttrs const &a) {
+  NOT_IMPLEMENTED();
+}
+
+V1LinearAttrs to_v1(LinearAttrs const &a) {
+  return {to_v1(a.out_channels),
+          to_v1(a.use_bias),
+          to_v1(a.data_type),
+          to_v1(a.activation),
+          to_v1<V1RegularizerAttrs>(a.regularizer)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/noop.cc b/lib/pcg/src/file_format/v1/ops/noop.cc
new file mode 100644
index 0000000000..6b48860c20
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/noop.cc
@@ -0,0 +1,12 @@
+#include "pcg/file_format/v1/ops/noop.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1NoopAttrs to_v1(NoopAttrs const &a) {
+  return {
+      // No fields in NoopAttrs.
+  };
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/pool_2d.cc b/lib/pcg/src/file_format/v1/ops/pool_2d.cc
new file mode 100644
index 0000000000..a84c52687c
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/pool_2d.cc
@@ -0,0 +1,21 @@
+#include "pcg/file_format/v1/ops/pool_2d.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1PoolOp to_v1(PoolOp const &op) {
+  NOT_IMPLEMENTED();
+}
+
+V1Pool2DAttrs to_v1(Pool2DAttrs const &a) {
+  return {to_v1(a.kernel_h),
+          to_v1(a.kernel_w),
+          to_v1(a.stride_h),
+          to_v1(a.stride_w),
+          to_v1(a.padding_h),
+          to_v1(a.padding_w),
+          to_v1(a.pool_type),
+          to_v1(a.activation)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reduce.cc b/lib/pcg/src/file_format/v1/ops/reduce.cc
new file mode 100644
index 0000000000..91bc8b1577
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/reduce.cc
@@ -0,0 +1,13 @@
+#include "pcg/file_format/v1/ops/reduce.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ReduceAttrs to_v1(ReduceAttrs const &a) {
+  return {std::vector<int>(a.axes.begin(), a.axes.end()),
+          to_v1(a.op_type),
+          to_v1(a.keepdims)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reduction.cc b/lib/pcg/src/file_format/v1/ops/reduction.cc
new file mode 100644
index 0000000000..8a8d6297e8
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/reduction.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/reduction.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ReductionAttrs to_v1(ReductionAttrs const &a) {
+  return {to_v1(a.reduction_dim), to_v1(a.reduction_degree)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/repartition.cc b/lib/pcg/src/file_format/v1/ops/repartition.cc
new file mode 100644
index 0000000000..7d3b40e559
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/repartition.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/repartition.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1RepartitionAttrs to_v1(RepartitionAttrs const &a) {
+  return {to_v1(a.repartition_dim), to_v1(a.repartition_degree)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/replicate.cc b/lib/pcg/src/file_format/v1/ops/replicate.cc
new file mode 100644
index 0000000000..9aa36c3c1b
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/replicate.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/replicate.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ReplicateAttrs to_v1(ReplicateAttrs const &a) {
+  return {to_v1(a.replicate_dim), to_v1(a.replicate_degree)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reshape.cc b/lib/pcg/src/file_format/v1/ops/reshape.cc
new file mode 100644
index 0000000000..1beb95fd22
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/reshape.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/reshape.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ReshapeAttrs to_v1(ReshapeAttrs const &a) {
+  return {to_v1(a.shape)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reverse.cc b/lib/pcg/src/file_format/v1/ops/reverse.cc
new file mode 100644
index 0000000000..86fde17f07
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/reverse.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/reverse.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1ReverseAttrs to_v1(ReverseAttrs const &a) {
+  return {to_v1(a.axis)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/softmax.cc b/lib/pcg/src/file_format/v1/ops/softmax.cc
new file mode 100644
index 0000000000..8cae6408aa
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/softmax.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/softmax.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1SoftmaxAttrs to_v1(SoftmaxAttrs const &a) {
+  return {to_v1(a.dim)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/split.cc b/lib/pcg/src/file_format/v1/ops/split.cc
new file mode 100644
index 0000000000..ffbc767475
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/split.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/split.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1SplitAttrs to_v1(SplitAttrs const &a) {
+  return {std::vector<int>(a.splits.begin(), a.splits.end()), to_v1(a.axis)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/topk.cc b/lib/pcg/src/file_format/v1/ops/topk.cc
new file mode 100644
index 0000000000..41cb08d9bd
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/topk.cc
@@ -0,0 +1,10 @@
+#include "pcg/file_format/v1/ops/topk.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1TopKAttrs to_v1(TopKAttrs const &a) {
+  return {to_v1(a.k), to_v1(a.sorted)};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/transpose.cc b/lib/pcg/src/file_format/v1/ops/transpose.cc
new file mode 100644
index 0000000000..9900a0f3e7
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/ops/transpose.cc
@@ -0,0 +1,11 @@
+#include "pcg/file_format/v1/ops/transpose.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1TransposeAttrs to_v1(TransposeAttrs const &a) {
+  return {std::vector<int>(a.perm.begin(), a.perm.end())};
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/parallel_tensor.cc b/lib/pcg/src/file_format/v1/parallel_tensor.cc
new file mode 100644
index 0000000000..fbcd2a949b
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/parallel_tensor.cc
@@ -0,0 +1,9 @@
+#include "pcg/file_format/v1/parallel_tensor.h"
+
+namespace FlexFlow {
+
+V1ParallelTensor to_v1(ParallelTensor const &t) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/tensor_shape.cc b/lib/pcg/src/file_format/v1/tensor_shape.cc
new file mode 100644
index 0000000000..f85a55ec12
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/tensor_shape.cc
@@ -0,0 +1,9 @@
+#include "pcg/file_format/v1/tensor_shape.h"
+
+namespace FlexFlow {
+
+V1TensorShape to_v1(TensorShape const &shape) {
+  NOT_IMPLEMENTED();
+}
+
+} // namespace FlexFlow

From 2e1a1a5eee5c31748a84a9282296822f9883cca2 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Tue, 3 Oct 2023 16:47:28 -0600
Subject: [PATCH 06/15] Remove reduntant template definition.

---
 lib/pcg/include/pcg/file_format/v1/v1.h | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/lib/pcg/include/pcg/file_format/v1/v1.h b/lib/pcg/include/pcg/file_format/v1/v1.h
index bb7b378f07..588f7fbe12 100644
--- a/lib/pcg/include/pcg/file_format/v1/v1.h
+++ b/lib/pcg/include/pcg/file_format/v1/v1.h
@@ -32,11 +32,6 @@ T to_v1(req<T> const &t) {
   return T(t);
 }
 
-template <typename V1T, typename T>
-V1T to_v1(req<T> const &t) {
-  return to_v1(*t);
-}
-
 } // namespace FlexFlow
 
 #endif

From 3b7d9d21b030e15f5eb92d694a1d1520aac320d3 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Tue, 3 Oct 2023 16:54:02 -0600
Subject: [PATCH 07/15] Run clang-format

---
 .../include/pcg/file_format/v1/dim_ordered.h  |  4 +-
 .../pcg/file_format/v1/ops/aggregate.h        |  2 +-
 lib/pcg/include/pcg/file_format/v1/tensor.h   |  2 +-
 lib/pcg/src/computation_graph_builder.cc      | 51 ++++++++++---------
 lib/pcg/test/test_tensor.cc                   |  7 ++-
 5 files changed, 36 insertions(+), 30 deletions(-)

diff --git a/lib/pcg/include/pcg/file_format/v1/dim_ordered.h b/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
index 5e4c767438..8b3e7bedf7 100644
--- a/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
+++ b/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
@@ -10,7 +10,7 @@ template <typename Idx, typename T>
 struct V1DimOrdered {
   std::vector<T> contents;
 
-  bool operator!=(const V1DimOrdered &o) {
+  bool operator!=(V1DimOrdered const &o) {
     return this->contents != o.contents;
   }
 };
@@ -22,7 +22,7 @@ template <typename T>
 using V1FFOrdered = V1DimOrdered<ff_dim_t, T>;
 
 template <typename T>
-V1FFOrdered<T> to_v1(FFOrdered<T> const& o);
+V1FFOrdered<T> to_v1(FFOrdered<T> const &o);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h b/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
index 385624f44b..8d75e49c26 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
@@ -2,8 +2,8 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_AGGREGATE_H
 
 #include "op-attrs/ops/aggregate.h"
-#include "utils/visitable.h"
 #include "utils/json.h"
+#include "utils/visitable.h"
 
 namespace FlexFlow {
 
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor.h b/lib/pcg/include/pcg/file_format/v1/tensor.h
index 608bae3cc3..984ebffde4 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor.h
@@ -2,9 +2,9 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_H
 
 #include "initializer.h"
-#include "tensor_shape.h"
 #include "param_sync.h"
 #include "pcg/tensor.h"
+#include "tensor_shape.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
diff --git a/lib/pcg/src/computation_graph_builder.cc b/lib/pcg/src/computation_graph_builder.cc
index ad335f1930..fae0829e60 100644
--- a/lib/pcg/src/computation_graph_builder.cc
+++ b/lib/pcg/src/computation_graph_builder.cc
@@ -356,51 +356,52 @@ Tensor ComputationGraphBuilder::batch_norm(
   return this->add_layer(layer, {input}, {}, output_shape);
 }
 
-Tensor ComputationGraphBuilder::dense(Tensor const &input,
-             int outDim,
-             optional<Activation> activation,
-             bool use_bias,
-             DataType data_type,
-             optional<Initializer const &> kernel_initializer,
-             optional<Initializer const &> bias_initializer,
-             optional<std::string> const &name) {
+Tensor ComputationGraphBuilder::dense(
+    Tensor const &input,
+    int outDim,
+    optional<Activation> activation,
+    bool use_bias,
+    DataType data_type,
+    optional<Initializer const &> kernel_initializer,
+    optional<Initializer const &> bias_initializer,
+    optional<std::string> const &name) {
   NOT_IMPLEMENTED();
 }
 
 Tensor ComputationGraphBuilder::cast(Tensor const &input,
-            DataType dtype,
-            optional<std::string> const &name) {
+                                     DataType dtype,
+                                     optional<std::string> const &name) {
   NOT_IMPLEMENTED();
 }
 
 Tensor ComputationGraphBuilder::concat(int n,
-              std::vector<Tensor> const &tensors,
-              int axis,
-              optional<std::string> const &name) {
+                                       std::vector<Tensor> const &tensors,
+                                       int axis,
+                                       optional<std::string> const &name) {
   NOT_IMPLEMENTED();
 }
 
 Tensor ComputationGraphBuilder::mean(Tensor const &input,
-            std::vector<int> const &dims,
-            bool keepdims,
-            char const *name) {
+                                     std::vector<int> const &dims,
+                                     bool keepdims,
+                                     char const *name) {
   NOT_IMPLEMENTED();
 }
 
 Tensor ComputationGraphBuilder::moe(Tensor const &input,
-           int num_exp,
-           int num_select,
-           int expert_hidden_size,
-           float alpha,
-           float lambda) {
+                                    int num_exp,
+                                    int num_select,
+                                    int expert_hidden_size,
+                                    float alpha,
+                                    float lambda) {
   NOT_IMPLEMENTED();
 }
 
 void ComputationGraphBuilder::split(Tensor const &input,
-           Tensor *outputs,
-           std::vector<int> const &split,
-           int axis,
-           optional<std::string> const &name) {
+                                    Tensor *outputs,
+                                    std::vector<int> const &split,
+                                    int axis,
+                                    optional<std::string> const &name) {
   NOT_IMPLEMENTED();
 }
 
diff --git a/lib/pcg/test/test_tensor.cc b/lib/pcg/test/test_tensor.cc
index 0a15fd22e1..a7789f8f08 100644
--- a/lib/pcg/test/test_tensor.cc
+++ b/lib/pcg/test/test_tensor.cc
@@ -9,6 +9,11 @@
 using namespace FlexFlow;
 
 TEST_CASE("Tensor") {
-  Tensor t{{3, 4, 5}, DataType::FLOAT, false, nullopt, nullopt, std::string("tensor")};
+  Tensor t{{3, 4, 5},
+           DataType::FLOAT,
+           false,
+           nullopt,
+           nullopt,
+           std::string("tensor")};
   to_v1(t);
 }

From 9e85fef4ecbaa4a9fb88202f2d54727290f351bc Mon Sep 17 00:00:00 2001
From: Colin Unger <lockshaw@lockshaw.net>
Date: Tue, 3 Oct 2023 16:03:34 -0700
Subject: [PATCH 08/15] Add json (de)serialization for strong_typedef

---
 lib/utils/include/utils/strong_typedef.h | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/lib/utils/include/utils/strong_typedef.h b/lib/utils/include/utils/strong_typedef.h
index f700a20c79..cba8880b37 100644
--- a/lib/utils/include/utils/strong_typedef.h
+++ b/lib/utils/include/utils/strong_typedef.h
@@ -5,6 +5,7 @@
 #include <functional>
 #include <string>
 #include <type_traits>
+#include "utils/json.h"
 
 namespace FlexFlow {
 
@@ -193,8 +194,28 @@ struct numerical_typedef : strong_typedef<StrongTypedef, T> {
   }
 };
 
+template <typename T, typename Enable = void> struct is_strong_typedef : std::false_type {};
+
+template <typename T>
+struct is_strong_typedef<T, std::void_t<underlying_type_t<T>>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_strong_typedef_v = is_strong_typedef<T>::value;
 } // namespace FlexFlow
 
+namespace nlohmann {
+template <typename T>
+struct adl_serializer<T, std::enable_if_t<::FlexFlow::is_strong_typedef_v<T>>> {
+  static T from_json(json const &j) {
+    return {j.template get<::FlexFlow::underlying_type_t<T>>()};
+  }
+
+  static void to_json(json &j, T const &t) {
+    j = static_cast<::FlexFlow::underlying_type_t<T>>(t);
+  }
+};
+} // namespace nlohmann
+
 #define MAKE_TYPEDEF_HASHABLE(TYPEDEF_NAME)                                    \
   namespace std {                                                              \
   template <>                                                                  \

From 5ced4b27c7f1a65c4e2a2fdb40e28991914756a7 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Tue, 3 Oct 2023 17:05:21 -0600
Subject: [PATCH 09/15] Run clang-format.

---
 .../src/parallel_dim_mapping_record_solver.cc |  1 -
 lib/utils/include/utils/required.h            |  8 ++--
 lib/utils/include/utils/required_core.h       | 47 +++++++++++-------
 lib/utils/include/utils/test_types.h          | 12 ++---
 lib/utils/include/utils/type_traits_core.h    | 17 +++----
 lib/utils/test/src/test_required.cc           | 48 ++++++++++++-------
 6 files changed, 74 insertions(+), 59 deletions(-)

diff --git a/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc b/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc
index 622ceccbcc..c36cd8c59a 100644
--- a/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc
+++ b/lib/op-attrs/src/parallel_dim_mapping_record_solver.cc
@@ -369,5 +369,4 @@ ParallelDimMappingSolution solve_parallel_dim_mappings(
   NOT_IMPLEMENTED();
 }
 
-
 } // namespace FlexFlow
diff --git a/lib/utils/include/utils/required.h b/lib/utils/include/utils/required.h
index 4165b442fa..7af22db3d4 100644
--- a/lib/utils/include/utils/required.h
+++ b/lib/utils/include/utils/required.h
@@ -45,11 +45,9 @@ CHECK_FMTABLE(req<int>);
 CHECK_FMTABLE(std::vector<std::string>);
 CHECK_FMTABLE(required_inheritance_impl<std::vector<std::string>>);
 static_assert(
-  std::is_base_of<
-    required_inheritance_impl<std::vector<std::string>>,
-    req<std::vector<std::string>>
-  >::value, ""
-);
+    std::is_base_of<required_inheritance_impl<std::vector<std::string>>,
+                    req<std::vector<std::string>>>::value,
+    "");
 CHECK_FMTABLE(req<std::vector<std::string>>);
 
 } // namespace FlexFlow
diff --git a/lib/utils/include/utils/required_core.h b/lib/utils/include/utils/required_core.h
index 8d20597efc..5677e84b7d 100644
--- a/lib/utils/include/utils/required_core.h
+++ b/lib/utils/include/utils/required_core.h
@@ -1,11 +1,11 @@
 #ifndef _FLEXFLOW_UTILS_INCLUDE_UTILS_REQUIRED_CORE_H
 #define _FLEXFLOW_UTILS_INCLUDE_UTILS_REQUIRED_CORE_H
 
+#include "fmt.decl.h"
 #include "hash-utils-core.h"
+#include "test_types.h"
 #include "type_traits_core.h"
 #include <vector>
-#include "test_types.h"
-#include "fmt.decl.h"
 
 namespace FlexFlow {
 
@@ -16,7 +16,8 @@ template <typename T, typename... Args>
 struct enable_if_valid<T, void_t<Args...>, Args...> : type_identity<T> {};
 
 /* required_wrapper_impl<decltype(std::declval<T>() + std::declval<T>())>> */
-/* operator+(required_wrapper_impl<T> const &lhs, required_wrapper_impl<T> const &rhs) { */
+/* operator+(required_wrapper_impl<T> const &lhs, required_wrapper_impl<T> const
+ * &rhs) { */
 /*   /1* return 1; *1/ */
 /* } */
 
@@ -61,13 +62,13 @@ struct required_wrapper_impl {
 
   template <typename TT = T>
   enable_if_t<is_neq_comparable<TT>::value, bool>
-  operator==(required_wrapper_impl const &rhs) const {
+      operator==(required_wrapper_impl const &rhs) const {
     return this->m_value == rhs.m_value;
   }
 
   template <typename TT = T>
   enable_if_t<is_neq_comparable<TT>::value, bool>
-  operator==(TT const &rhs) const {
+      operator==(TT const &rhs) const {
     return this->m_value == rhs;
   }
 
@@ -83,12 +84,14 @@ struct required_wrapper_impl {
 
   template <typename TT = T>
   enable_if_t<is_neq_comparable<TT>::value, bool>
-  operator!=(required_wrapper_impl const &rhs) const {
+      operator!=(required_wrapper_impl const &rhs) const {
     return this->m_value != rhs.m_value;
   }
 
-  /* friend enable_if_t<is_plusable<T>::value, required_wrapper_impl<decltype(std::declval<T>() + std::declval<T>())>> */
-  /* operator+(required_wrapper_impl<T> const &lhs, required_wrapper_impl<T> const &rhs) { */
+  /* friend enable_if_t<is_plusable<T>::value,
+   * required_wrapper_impl<decltype(std::declval<T>() + std::declval<T>())>> */
+  /* operator+(required_wrapper_impl<T> const &lhs, required_wrapper_impl<T>
+   * const &rhs) { */
   /*   /1* return 1; *1/ */
   /* } */
   /* required_wrapper_impl<Out> */
@@ -133,16 +136,20 @@ struct required_inheritance_impl : public T {
   required_inheritance_impl(required_inheritance_impl<T> const &) = default;
   required_inheritance_impl(required_inheritance_impl<T> &&) = default;
 
-  required_inheritance_impl<T> &operator=(required_inheritance_impl<T> const &) = default;
-  required_inheritance_impl<T> &operator=(required_inheritance_impl<T> &&) = default;
+  required_inheritance_impl<T> &
+      operator=(required_inheritance_impl<T> const &) = default;
+  required_inheritance_impl<T> &
+      operator=(required_inheritance_impl<T> &&) = default;
 
   friend enable_if_t<is_equal_comparable<T>::value, bool>
-    operator==(required_inheritance_impl<T> const &lhs, required_inheritance_impl<T> const &rhs) {
+      operator==(required_inheritance_impl<T> const &lhs,
+                 required_inheritance_impl<T> const &rhs) {
     return static_cast<T>(lhs) == static_cast<T>(rhs);
   }
 
   friend enable_if_t<is_neq_comparable<T>::value, bool>
-    operator!=(required_inheritance_impl<T> const &lhs, required_inheritance_impl<T> const &rhs) {
+      operator!=(required_inheritance_impl<T> const &lhs,
+                 required_inheritance_impl<T> const &rhs) {
     return static_cast<T>(lhs) != static_cast<T>(rhs);
   }
 
@@ -196,11 +203,17 @@ struct remove_req<req<T>> {
 template <typename T>
 using remove_req_t = typename remove_req<T>::type;
 
-static_assert(is_equal_comparable<required_inheritance_impl<std::vector<int>>>::value, "");
-CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(required_inheritance_impl<test_types::well_behaved_value_type>);
-CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(required_wrapper_impl<test_types::well_behaved_value_type>);
-
-/* static_assert(std::is_same<decltype(std::declval<required_wrapper_impl<int>>() + std::declval<required_wrapper_impl<int>>()), required_wrapper_impl<int>>::value, ""); */
+static_assert(
+    is_equal_comparable<required_inheritance_impl<std::vector<int>>>::value,
+    "");
+CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(
+    required_inheritance_impl<test_types::well_behaved_value_type>);
+CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(
+    required_wrapper_impl<test_types::well_behaved_value_type>);
+
+/* static_assert(std::is_same<decltype(std::declval<required_wrapper_impl<int>>()
+ * + std::declval<required_wrapper_impl<int>>()),
+ * required_wrapper_impl<int>>::value, ""); */
 
 static_assert(std::is_copy_constructible<req<int>>::value, "");
 
diff --git a/lib/utils/include/utils/test_types.h b/lib/utils/include/utils/test_types.h
index 308bd61428..984c0bc60d 100644
--- a/lib/utils/include/utils/test_types.h
+++ b/lib/utils/include/utils/test_types.h
@@ -129,13 +129,11 @@ using cmp = test_type_t<CMP>;
 using hash_cmp = test_type_t<HASHABLE, CMP>;
 using plusable = test_type_t<PLUS, PLUSEQ>;
 using fmtable = test_type_t<FMT>;
-using well_behaved_value_type = test_type_t<
-  EQ, 
-  COPY_CONSTRUCTIBLE,
-  MOVE_CONSTRUCTIBLE,
-  COPY_ASSIGNABLE,
-  MOVE_ASSIGNABLE
->;
+using well_behaved_value_type = test_type_t<EQ,
+                                            COPY_CONSTRUCTIBLE,
+                                            MOVE_CONSTRUCTIBLE,
+                                            COPY_ASSIGNABLE,
+                                            MOVE_ASSIGNABLE>;
 
 } // namespace test_types
 } // namespace FlexFlow
diff --git a/lib/utils/include/utils/type_traits_core.h b/lib/utils/include/utils/type_traits_core.h
index 7eccccb431..8f55344d1f 100644
--- a/lib/utils/include/utils/type_traits_core.h
+++ b/lib/utils/include/utils/type_traits_core.h
@@ -146,10 +146,10 @@ template <typename T>
 struct is_equal_comparable<
     T,
     void_t<decltype(std::declval<T>() == std::declval<T>())>>
-      /* std::is_same< */
-      /*   decltype(), */
-      /*   bool */
-      /* >::value */
+    /* std::is_same< */
+    /*   decltype(), */
+    /*   bool */
+    /* >::value */
     /* >> */
     : std::true_type {};
 
@@ -175,9 +175,8 @@ template <typename T, typename Enable = void>
 struct is_plusable : std::false_type {};
 
 template <typename T>
-struct is_plusable<
-    T,
-    void_t<decltype((T)(std::declval<T>() + std::declval<T>()))>>
+struct is_plusable<T,
+                   void_t<decltype((T)(std::declval<T>() + std::declval<T>()))>>
     : std::true_type {};
 
 static_assert(is_plusable<int>::value, "");
@@ -200,9 +199,6 @@ struct is_timesable<
     void_t<decltype((T)(std::declval<T>() * std::declval<T>()))>>
     : std::true_type {};
 
-
-
-
 template <typename T>
 struct is_well_behaved_value_type_no_hash
     : conjunction<is_equal_comparable<T>,
@@ -241,7 +237,6 @@ struct is_well_behaved_value_type
   CHECK_WELL_BEHAVED_VALUE_TYPE_NO_HASH(__VA_ARGS__);                          \
   CHECK_HASHABLE(__VA_ARGS__)
 
-
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/utils/test/src/test_required.cc b/lib/utils/test/src/test_required.cc
index 206267631f..d21db53945 100644
--- a/lib/utils/test/src/test_required.cc
+++ b/lib/utils/test/src/test_required.cc
@@ -1,15 +1,13 @@
 #include "test/utils/doctest.h"
-#include "utils/required.h"
 #include "test/utils/rapidcheck/doctest.h"
+#include "utils/required.h"
 
 using namespace FlexFlow;
 
 struct default_constructible_example {
   int member;
 
-  default_constructible_example()
-    : member(1234)
-  { }
+  default_constructible_example() : member(1234) {}
 
   friend bool operator==(default_constructible_example const &lhs,
                          default_constructible_example const &rhs) {
@@ -22,20 +20,32 @@ struct default_constructible_example {
   }
 };
 
-TEST_CASE_TEMPLATE("required_wrapper_impl is not default constructible", T, int, float, double, char) {
+TEST_CASE_TEMPLATE("required_wrapper_impl is not default constructible",
+                   T,
+                   int,
+                   float,
+                   double,
+                   char) {
   STATIC_CHECK(std::is_default_constructible<T>::value);
-  STATIC_CHECK_FALSE(std::is_default_constructible<required_wrapper_impl<T>>::value);
+  STATIC_CHECK_FALSE(
+      std::is_default_constructible<required_wrapper_impl<T>>::value);
 }
 
-TEST_CASE_TEMPLATE("required_inheritance_impl is not default constructible", 
-                   T, 
+TEST_CASE_TEMPLATE("required_inheritance_impl is not default constructible",
+                   T,
                    std::vector<std::vector<int>>,
                    std::unordered_map<std::string, float>) {
   STATIC_CHECK(std::is_default_constructible<T>::value);
-  STATIC_CHECK_FALSE(std::is_default_constructible<required_wrapper_impl<T>>::value);
+  STATIC_CHECK_FALSE(
+      std::is_default_constructible<required_wrapper_impl<T>>::value);
 }
 
-TEST_CASE_TEMPLATE("required_wrapper_impl supports expected operations", T, int, float, double, char) {
+TEST_CASE_TEMPLATE("required_wrapper_impl supports expected operations",
+                   T,
+                   int,
+                   float,
+                   double,
+                   char) {
   rc::dc_check("copy constructible", [&](T t) {
     required_wrapper_impl<T> r{t};
     required_wrapper_impl<T> r2(r);
@@ -49,17 +59,20 @@ TEST_CASE_TEMPLATE("required_wrapper_impl supports expected operations", T, int,
   /* rc::dc_check("ops", [&](T t1, T t2) { */
   /*   required_wrapper_impl<T> r1{t1}; */
   /*   required_wrapper_impl<T> r2{t2}; */
-  /*   STATIC_CHECK(std::is_same<decltype(std::declval<required_wrapper_impl<T>>() + std::declval<required_wrapper_impl<T>>()), required_wrapper_impl<decltype(t1 + t2)>>::value); */
+  /*   STATIC_CHECK(std::is_same<decltype(std::declval<required_wrapper_impl<T>>()
+   * + std::declval<required_wrapper_impl<T>>()),
+   * required_wrapper_impl<decltype(t1 + t2)>>::value); */
   /*   CHECK(static_cast<T>(r1 + r2) == t1 + t2); */
   /*   CHECK(static_cast<T>(r1 - r2) == t1 - t2); */
   /*   CHECK(static_cast<T>(r1 * r2) == t1 * t2); */
   /* }); */
 }
 
-TEST_CASE_TEMPLATE("required_inheritance_impl supports expected operations (generic)",
-                   T, 
-                   std::vector<int>,
-                   std::string) {
+TEST_CASE_TEMPLATE(
+    "required_inheritance_impl supports expected operations (generic)",
+    T,
+    std::vector<int>,
+    std::string) {
   rc::dc_check("copy constructible", [&](T t) {
     required_inheritance_impl<T> r{t};
     required_inheritance_impl<T> r2(r);
@@ -87,6 +100,5 @@ TEST_CASE_TEMPLATE("required_inheritance_impl supports expected operations (gene
   });
 }
 
-
-TEST_CASE("required_inheritance_impl supports expected operations (std::vector<int>)") {
-}
+TEST_CASE("required_inheritance_impl supports expected operations "
+          "(std::vector<int>)") {}

From 137c22b444f9c896e211a9d15097584a336c29ae Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Wed, 4 Oct 2023 16:36:04 -0600
Subject: [PATCH 10/15] Implement many of the unimplemented to_v1 functions.
 Re-enable the disabled attrs since the std::vector bug has been fixed. Make
 the Tensor and ParallelTensor more consistent. The test builds, but doesn't
 actually test anything.

---
 .../include/pcg/file_format/v1/create_grad.h  |  19 ++
 lib/pcg/include/pcg/file_format/v1/datatype.h |   1 +
 lib/pcg/include/pcg/file_format/v1/graphs.h   |   9 +-
 .../pcg/file_format/v1/operator_attrs.h       |  26 +--
 .../pcg/file_format/v1/ops/broadcast.h        |   1 +
 .../pcg/file_format/v1/parallel_tensor.h      |   9 +-
 lib/pcg/include/pcg/file_format/v1/tensor.h   |   3 +-
 .../include/pcg/file_format/v1/tensor_shape.h |  18 +-
 lib/pcg/include/pcg/file_format/v1/v1.h       |  11 +-
 lib/pcg/include/pcg/parallel_tensor.h         |  39 ++--
 lib/pcg/include/pcg/strided_rectangle.h       |   1 -
 lib/pcg/include/pcg/tensor.h                  |   2 +-
 lib/pcg/src/file_format/v1/activation.cc      |  14 +-
 lib/pcg/src/file_format/v1/create_grad.cc     |  17 ++
 lib/pcg/src/file_format/v1/datatype.cc        |  39 +++-
 lib/pcg/src/file_format/v1/graphs.cc          |   2 +-
 lib/pcg/src/file_format/v1/initializer.cc     |  28 ++-
 lib/pcg/src/file_format/v1/op.cc              | 178 +++++++++++++++++-
 lib/pcg/src/file_format/v1/operator_attrs.cc  | 130 ++++++++++++-
 lib/pcg/src/file_format/v1/ops/aggregate.cc   |   3 +-
 .../src/file_format/v1/ops/aggregate_spec.cc  |   3 +-
 lib/pcg/src/file_format/v1/ops/attention.cc   |  17 +-
 .../src/file_format/v1/ops/batch_matmul.cc    |   2 +-
 lib/pcg/src/file_format/v1/ops/batch_norm.cc  |   3 +-
 lib/pcg/src/file_format/v1/ops/combine.cc     |   3 +-
 lib/pcg/src/file_format/v1/ops/conv_2d.cc     |  18 +-
 lib/pcg/src/file_format/v1/ops/dropout.cc     |   3 +-
 .../src/file_format/v1/ops/element_binary.cc  |   5 +-
 .../src/file_format/v1/ops/element_unary.cc   |   3 +-
 lib/pcg/src/file_format/v1/ops/embedding.cc   |  15 +-
 lib/pcg/src/file_format/v1/ops/groupby.cc     |   3 +-
 lib/pcg/src/file_format/v1/ops/layer_norm.cc  |   4 +-
 lib/pcg/src/file_format/v1/ops/linear.cc      |  16 +-
 lib/pcg/src/file_format/v1/ops/pool_2d.cc     |  22 ++-
 lib/pcg/src/file_format/v1/ops/reduce.cc      |   3 +-
 lib/pcg/src/file_format/v1/ops/reduction.cc   |   3 +-
 lib/pcg/src/file_format/v1/ops/repartition.cc |   3 +-
 lib/pcg/src/file_format/v1/ops/replicate.cc   |   3 +-
 lib/pcg/src/file_format/v1/ops/reverse.cc     |   1 -
 lib/pcg/src/file_format/v1/ops/topk.cc        |   3 +-
 lib/pcg/src/file_format/v1/parallel_tensor.cc |  19 +-
 lib/pcg/src/file_format/v1/param_sync.cc      |   3 +-
 lib/pcg/src/file_format/v1/tensor.cc          |  12 +-
 lib/pcg/src/file_format/v1/tensor_shape.cc    |   3 +-
 lib/pcg/src/file_format/v1/v1.cc              |   8 +-
 lib/pcg/src/parallel_tensor.cc                |  21 +++
 lib/pcg/src/tensor.cc                         |   4 +-
 lib/pcg/test/CMakeLists.txt                   |   2 -
 lib/pcg/test/test_tensor.cc                   |   2 +-
 lib/utils/include/utils/exception.decl.h      |  16 +-
 lib/utils/src/exception.cc                    |  12 +-
 51 files changed, 605 insertions(+), 180 deletions(-)
 create mode 100644 lib/pcg/include/pcg/file_format/v1/create_grad.h
 create mode 100644 lib/pcg/src/file_format/v1/create_grad.cc
 create mode 100644 lib/pcg/src/parallel_tensor.cc

diff --git a/lib/pcg/include/pcg/file_format/v1/create_grad.h b/lib/pcg/include/pcg/file_format/v1/create_grad.h
new file mode 100644
index 0000000000..c83eb93f31
--- /dev/null
+++ b/lib/pcg/include/pcg/file_format/v1/create_grad.h
@@ -0,0 +1,19 @@
+#ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_CREATE_GRAD_H
+#define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_CREATE_GRAD_H
+
+#include "pcg/create_grad.h"
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+enum class V1CreateGrad { YES, NO };
+
+NLOHMANN_JSON_SERIALIZE_ENUM(V1CreateGrad,
+                             {{V1CreateGrad::YES, "YES"},
+                              {V1CreateGrad::NO, "NO"}});
+
+V1CreateGrad to_v1(CreateGrad const &cg);
+
+} // namespace FlexFlow
+
+#endif
diff --git a/lib/pcg/include/pcg/file_format/v1/datatype.h b/lib/pcg/include/pcg/file_format/v1/datatype.h
index 8d05c7f889..c85fcf4beb 100644
--- a/lib/pcg/include/pcg/file_format/v1/datatype.h
+++ b/lib/pcg/include/pcg/file_format/v1/datatype.h
@@ -28,6 +28,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1DataType,
                               {V1DataType::DOUBLE, "DOUBLE"}});
 
 V1DataType to_v1(DataType const &d);
+V1DataTypeValue to_v1(DataTypeValue const &dv);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/graphs.h b/lib/pcg/include/pcg/file_format/v1/graphs.h
index 09d6f1ad0e..3628af7591 100644
--- a/lib/pcg/include/pcg/file_format/v1/graphs.h
+++ b/lib/pcg/include/pcg/file_format/v1/graphs.h
@@ -16,7 +16,6 @@ struct V1GraphOutput {
   req<size_t> srcNode;
   req<size_t> srcIdx;
 };
-
 FF_VISITABLE_STRUCT(V1GraphOutput, srcNode, srcIdx);
 CHECK_IS_JSONABLE(V1GraphOutput);
 
@@ -38,6 +37,7 @@ struct V1MultiDiGraph {
 
 FF_VISITABLE_STRUCT(V1MultiDiGraph, nodes, ports, edges);
 CHECK_IS_JSONABLE(V1MultiDiGraph);
+
 V1MultiDiGraph to_v1(MultiDiGraphView const &);
 V1MultiDiGraph to_v1(MultiDiGraphView const &,
                      std::unordered_map<Node, size_t> const &,
@@ -58,30 +58,31 @@ struct V1Layer {
   V1CompGraphOperatorAttrs attrs;
   req<optional<std::string>> name;
 };
-
 FF_VISITABLE_STRUCT(V1Layer, attrs, name);
+
 V1Layer to_v1(Layer const &);
 
 using V1ComputationGraph = V1JsonableGraph<V1Layer, V1Tensor>;
 FF_VISITABLE_STRUCT(
     V1ComputationGraph, node_labels, outputs, output_labels, graph);
 CHECK_IS_JSONABLE(V1ComputationGraph);
+
 V1ComputationGraph to_v1(ComputationGraph const &);
 
 struct V1Operator {
   V1PCGOperatorAttrs attrs;
   req<optional<std::string>> name;
 };
-
 FF_VISITABLE_STRUCT(V1Operator, attrs, name);
+
 V1Operator to_v1(Operator const &);
 
 using V1ParallelComputationGraph =
     V1JsonableGraph<V1Operator, V1ParallelTensor>;
-
 FF_VISITABLE_STRUCT(
     V1ParallelComputationGraph, node_labels, outputs, output_labels, graph);
 CHECK_IS_JSONABLE(V1ParallelComputationGraph);
+
 V1ParallelComputationGraph to_v1(ParallelComputationGraph const &);
 
 } // namespace FlexFlow
diff --git a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
index e3dda69c71..fe63038426 100644
--- a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
+++ b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
@@ -2,7 +2,6 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPERATOR_ATTRS_H
 
 #include "op-attrs/operator_attrs.h"
-#include "op-attrs/ops/core.h"
 #include "ops/aggregate.h"
 #include "ops/aggregate_spec.h"
 #include "ops/attention.h"
@@ -21,15 +20,11 @@
 #include "ops/gather.h"
 #include "ops/groupby.h"
 #include "ops/input.h"
-// FIXME: Re-enable this once the JSON issues with std::vector have been
-// resolved.
-// #include "ops/layer_norm.h"
+#include "ops/layer_norm.h"
 #include "ops/linear.h"
 #include "ops/noop.h"
 #include "ops/pool_2d.h"
-// FIXME: Re-enable this once the JSON issues with std::vector have been
-// resolved.
-// #include "ops/reduce.h"
+#include "ops/reduce.h"
 #include "ops/reduction.h"
 #include "ops/repartition.h"
 #include "ops/replicate.h"
@@ -38,18 +33,12 @@
 #include "ops/softmax.h"
 #include "ops/split.h"
 #include "ops/topk.h"
-// FIXME: Re-enable this once the JSON issues with std::vector have been
-// resolved.
-// #include "ops/transpose.h"
+#include "ops/transpose.h"
 #include "utils/json.h"
 #include "utils/variant.h"
 
 namespace FlexFlow {
 
-// TODO: Re-enable V1LayerNormAttrs, V1ReduceAttrs, V1TransposeAttrs are
-// disabled because they use std::vector which triggers an error saying that
-// it cannot be serialized to JSON (when it actually ought to be serializable).
-// To get this to build for the moment, they have been disabled.
 using V1SharedOperatorAttrs = variant<V1AggregateAttrs,
                                       V1AggregateSpecAttrs,
                                       V1BatchMatmulAttrs,
@@ -66,19 +55,18 @@ using V1SharedOperatorAttrs = variant<V1AggregateAttrs,
                                       V1GatherAttrs,
                                       V1Group_byAttrs,
                                       V1InputAttrs,
-                                      // V1LayerNormAttrs,
+                                      V1LayerNormAttrs,
                                       V1LinearAttrs,
                                       V1MultiHeadAttentionAttrs,
                                       V1NoopAttrs,
                                       V1Pool2DAttrs,
-                                      // V1ReduceAttrs,
+                                      V1ReduceAttrs,
                                       V1ReverseAttrs,
                                       V1ReshapeAttrs,
                                       V1SplitAttrs,
                                       V1SoftmaxAttrs,
-                                      V1TopKAttrs
-                                      // V1TransposeAttrs
-                                      >;
+                                      V1TopKAttrs,
+                                      V1TransposeAttrs>;
 
 using V1ParallelOperatorAttrs = variant<V1CombineAttrs,
                                         V1ReductionAttrs,
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
index bdd10c430e..7f7cfa3e02 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
@@ -2,6 +2,7 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_OPS_BROADCAST_H
 
 #include "op-attrs/ops/broadcast.h"
+#include "utils/json.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
index 3fda7727a4..f917dc2198 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
@@ -1,6 +1,7 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_PARALLEL_TENSOR_H
 
+#include "create_grad.h"
 #include "datatype.h"
 #include "initializer.h"
 #include "param_sync.h"
@@ -16,31 +17,31 @@ struct V1ParallelDim {
   req<int> degree;
   req<bool> is_replica_dim;
 };
-
 FF_VISITABLE_STRUCT(V1ParallelDim, size, degree, is_replica_dim);
 CHECK_IS_JSONABLE(V1ParallelDim);
+
 V1ParallelDim to_v1(ParallelDim const &);
 
 struct V1ParallelTensorShape {
   req<std::vector<V1ParallelDim>> dims;
   req<V1DataType> data_type;
 };
-
 FF_VISITABLE_STRUCT(V1ParallelTensorShape, dims, data_type);
 CHECK_IS_JSONABLE(V1ParallelTensorShape);
+
 V1ParallelTensorShape to_v1(ParallelTensorShape const &);
 
 struct V1ParallelTensor {
   V1ParallelTensorShape shape;
-  req<bool> create_gradients;
+  req<V1CreateGrad> create_gradients;
   req<optional<V1Initializer>> initializer;
   req<optional<V1ParamSync>> sync_type;
   req<optional<std::string>> name;
 };
-
 FF_VISITABLE_STRUCT(
     V1ParallelTensor, shape, create_gradients, initializer, sync_type, name);
 CHECK_IS_JSONABLE(V1ParallelTensor);
+
 V1ParallelTensor to_v1(ParallelTensor const &);
 
 } // namespace FlexFlow
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor.h b/lib/pcg/include/pcg/file_format/v1/tensor.h
index 984ebffde4..bc8903c78c 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor.h
@@ -1,6 +1,7 @@
 #ifndef _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_H
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_H
 
+#include "create_grad.h"
 #include "initializer.h"
 #include "param_sync.h"
 #include "pcg/tensor.h"
@@ -11,7 +12,7 @@ namespace FlexFlow {
 
 struct V1Tensor {
   V1TensorShape shape;
-  req<bool> create_gradients;
+  req<V1CreateGrad> create_gradients;
   req<optional<V1Initializer>> initializer;
   req<optional<V1ParamSync>> sync_type;
   req<optional<std::string>> name;
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
index 4d3f72da7c..4bc6895ea7 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
@@ -2,31 +2,17 @@
 #define _FLEXFLOW_PCG_INCLUDE_PCG_FILE_FORMAT_V1_TENSOR_SHAPE_H
 
 #include "datatype.h"
-#include "dim_ordered.h"
-#include "op-attrs/ff_dim.h"
 #include "op-attrs/tensor_shape.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
 
-// TODO: V1TensorDims has been commented out because std::vector causes a
-// strange error saying it cannot be serialized to JSON and we would like to
-// get this to build.
-// using V1TensorDims = V1FFOrdered<size_t>;
-// CHECK_IS_JSONABLE(V1TensorDims);
-
 struct V1TensorShape {
 public:
-  // TODO: This should be re-enabled. See the comment above the commented out
-  // definition of V1TensorDims.
-  // req<V1TensorDims> dims;
+  req<std::vector<size_t>> dims;
   req<V1DataType> data_type;
 };
-// TODO: This should be re-enabled when the dims field of V1TensorShape is
-// re-enabled. See the comment above the commented out definition of
-// V1TensorDims.
-FF_VISITABLE_STRUCT(V1TensorShape, // dims,
-                    data_type);
+FF_VISITABLE_STRUCT(V1TensorShape, dims, data_type);
 CHECK_IS_JSONABLE(V1TensorShape);
 
 V1TensorShape to_v1(TensorShape const &t);
diff --git a/lib/pcg/include/pcg/file_format/v1/v1.h b/lib/pcg/include/pcg/file_format/v1/v1.h
index 588f7fbe12..780b008970 100644
--- a/lib/pcg/include/pcg/file_format/v1/v1.h
+++ b/lib/pcg/include/pcg/file_format/v1/v1.h
@@ -12,10 +12,7 @@ T to_v1(T const &t) {
   return t;
 }
 
-template <typename V1T, typename... Args>
-V1T to_v1(variant<Args...> const &v) {
-  NOT_IMPLEMENTED();
-}
+std::string to_v1(std::string const &s);
 
 template <typename V1T, typename T>
 optional<V1T> to_v1(optional<T> const &t) {
@@ -26,12 +23,6 @@ optional<V1T> to_v1(optional<T> const &t) {
   }
 }
 
-template <typename T,
-          typename std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
-T to_v1(req<T> const &t) {
-  return T(t);
-}
-
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/parallel_tensor.h b/lib/pcg/include/pcg/parallel_tensor.h
index 1a83edc93f..fa3faae999 100644
--- a/lib/pcg/include/pcg/parallel_tensor.h
+++ b/lib/pcg/include/pcg/parallel_tensor.h
@@ -25,6 +25,7 @@
 #include "initializer.h"
 #include "op-attrs/parallel_tensor_shape.h"
 #include "op-attrs/param_sync.h"
+#include "utils/visitable.h"
 
 namespace FlexFlow {
 
@@ -34,39 +35,31 @@ namespace FlexFlow {
  * @details Parallel tensor is the fundamental component to support the
  * representation and exploration of parallelization strategies.
  */
-struct ParallelTensor : public use_visitable_cmp<ParallelTensor> {
-  ParallelTensor() = delete;
+struct ParallelTensor {
+  size_t get_volume() const;
+  ParallelTensorShape get_shape() const;
+  int num_dims() const;
 
-  ParallelTensor(ParallelTensorShape const &,
-                 CreateGrad create_gradients,
-                 optional<ParamSync> sync_type = nullopt,
-                 optional<Initializer> initializer = nullopt);
-  ParallelTensor(ParallelTensorDims const &,
-                 DataType,
-                 CreateGrad create_gradients,
-                 optional<ParamSync> sync_type = nullopt,
-                 optional<Initializer> initializer = nullopt);
+  operator ParallelTensorShape() const;
 
 public:
   ParallelTensorDims dims;
   DataType data_type;
   CreateGrad create_gradients;
-  optional<ParamSync> sync_type = nullopt;
-  optional<Initializer> initializer = nullopt;
-  optional<std::string> name = nullopt;
+  req<optional<ParamSync>> sync_type;
+  req<optional<Initializer>> initializer;
+  req<optional<std::string>> name;
 };
+FF_VISITABLE_STRUCT(ParallelTensor,
+                    dims,
+                    data_type,
+                    create_gradients,
+                    sync_type,
+                    initializer,
+                    name);
 
 using ParallelParameter = ParallelTensor;
 
 } // namespace FlexFlow
 
-VISITABLE_STRUCT(::FlexFlow::ParallelTensor,
-                 dims,
-                 data_type,
-                 sync_type,
-                 initializer,
-                 create_gradients,
-                 name);
-MAKE_VISIT_HASHABLE(::FlexFlow::ParallelTensor);
-
 #endif
diff --git a/lib/pcg/include/pcg/strided_rectangle.h b/lib/pcg/include/pcg/strided_rectangle.h
index d8188c13b4..4fabf0f9f7 100644
--- a/lib/pcg/include/pcg/strided_rectangle.h
+++ b/lib/pcg/include/pcg/strided_rectangle.h
@@ -3,7 +3,6 @@
 
 #include "op-attrs/dim_ordered.h"
 #include "op-attrs/ff_dim.h"
-#include "utils/stack_vector.h"
 #include "utils/strong_typedef.h"
 #include "utils/visitable.h"
 
diff --git a/lib/pcg/include/pcg/tensor.h b/lib/pcg/include/pcg/tensor.h
index 706516bd15..b5032e4097 100644
--- a/lib/pcg/include/pcg/tensor.h
+++ b/lib/pcg/include/pcg/tensor.h
@@ -18,7 +18,7 @@ struct Tensor {
 public:
   TensorDims dims;
   DataType data_type;
-  req<bool> create_gradients;
+  CreateGrad create_gradients;
   req<optional<Initializer>> initializer;
   req<optional<ParamSync>> sync_type;
   req<optional<std::string>> name;
diff --git a/lib/pcg/src/file_format/v1/activation.cc b/lib/pcg/src/file_format/v1/activation.cc
index 6368dafa88..e6a7da9dcb 100644
--- a/lib/pcg/src/file_format/v1/activation.cc
+++ b/lib/pcg/src/file_format/v1/activation.cc
@@ -3,7 +3,19 @@
 namespace FlexFlow {
 
 V1Activation to_v1(Activation const &a) {
-  NOT_IMPLEMENTED();
+  // There should be a better way of doing this.
+  switch (a) {
+    case Activation::RELU:
+      return V1Activation::RELU;
+    case Activation::SIGMOID:
+      return V1Activation::SIGMOID;
+    case Activation::TANH:
+      return V1Activation::TANH;
+    case Activation::GELU:
+      return V1Activation::GELU;
+    default:
+      NOT_REACHABLE();
+  }
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/create_grad.cc b/lib/pcg/src/file_format/v1/create_grad.cc
new file mode 100644
index 0000000000..70adfecfcf
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/create_grad.cc
@@ -0,0 +1,17 @@
+#include "pcg/file_format/v1/create_grad.h"
+#include "pcg/file_format/v1/v1.h"
+
+namespace FlexFlow {
+
+V1CreateGrad to_v1(CreateGrad const &cg) {
+  switch (cg) {
+    case CreateGrad::YES:
+      return V1CreateGrad::YES;
+    case CreateGrad::NO:
+      return V1CreateGrad::NO;
+    default:
+      NOT_REACHABLE();
+  }
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/datatype.cc b/lib/pcg/src/file_format/v1/datatype.cc
index 4525f7d861..d0d5ffe7c3 100644
--- a/lib/pcg/src/file_format/v1/datatype.cc
+++ b/lib/pcg/src/file_format/v1/datatype.cc
@@ -3,7 +3,44 @@
 namespace FlexFlow {
 
 V1DataType to_v1(DataType const &dt) {
-  NOT_IMPLEMENTED();
+  switch (dt) {
+    case DataType::BOOL:
+      return V1DataType::BOOL;
+    case DataType::INT32:
+      return V1DataType::INT32;
+    case DataType::INT64:
+      return V1DataType::INT64;
+    case DataType::HALF:
+      return V1DataType::HALF;
+    case DataType::FLOAT:
+      return V1DataType::FLOAT;
+    case DataType::DOUBLE:
+      return V1DataType::DOUBLE;
+  default:
+    // Should never get here unless a new element was added to the DataType enum
+    // that was not handled here.
+    NOT_REACHABLE();
+  }
+}
+
+V1DataTypeValue to_v1(DataTypeValue const &dv) {
+  // There has to be a better way of doing this.
+  if (const auto* b = get_if<bool>(&dv))
+    return *b;
+  else if (const auto* i32 = get_if<int32_t>(&dv))
+    return *i32;
+  else if (const auto* i64 = get_if<int64_t>(&dv))
+    return *i64;
+  else if (const auto* flt = get_if<float>(&dv))
+    return *flt;
+  else if (const auto* dbl = get_if<double>(&dv))
+    return *dbl;
+  else if (const auto* hlf = get_if<half>(&dv))
+    return *hlf;
+  else
+    // Should never get here unless a new type was added into the DataTypeValue
+    // variant which was not handled here.
+    NOT_REACHABLE();
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/graphs.cc b/lib/pcg/src/file_format/v1/graphs.cc
index 9081fe2734..ffc473c2da 100644
--- a/lib/pcg/src/file_format/v1/graphs.cc
+++ b/lib/pcg/src/file_format/v1/graphs.cc
@@ -4,7 +4,7 @@
 namespace FlexFlow {
 
 V1Operator to_v1(Operator const &op) {
-  NOT_IMPLEMENTED();
+  return {to_v1(op.attrs), op.name};
 }
 
 V1Layer to_v1(Layer const &l) {
diff --git a/lib/pcg/src/file_format/v1/initializer.cc b/lib/pcg/src/file_format/v1/initializer.cc
index 91855b0b84..cf26123409 100644
--- a/lib/pcg/src/file_format/v1/initializer.cc
+++ b/lib/pcg/src/file_format/v1/initializer.cc
@@ -3,27 +3,41 @@
 namespace FlexFlow {
 
 V1GlorotInitializer to_v1(GlorotUniform const &i) {
-  NOT_IMPLEMENTED();
+  return {i.seed};
 }
 
 V1ZeroInitializer to_v1(ZeroInitializer const &i) {
-  NOT_IMPLEMENTED();
+  return {
+      // No fields in ZeroInitializer.
+  };
 }
 
 V1UniformInitializer to_v1(UniformInitializer const &i) {
-  NOT_IMPLEMENTED();
+  return {i.seed, i.min_val, i.max_val};
 }
 
 V1NormInitializer to_v1(NormInitializer const &i) {
-  NOT_IMPLEMENTED();
+  return {i.seed, i.mean, i.stddev};
 }
 
 V1ConstantInitializer to_v1(ConstantInitializer const &i) {
-  NOT_IMPLEMENTED();
+  return {to_v1(i.value)};
 }
 
-V1Initializer to_v1(Initializer const &) {
-  NOT_IMPLEMENTED();
+V1Initializer to_v1(Initializer const &i) {
+  // There is surely a better way of doing this ...
+  if (const auto* glorot = get_if<GlorotUniform>(&i))
+    return to_v1(*glorot);
+  else if (const auto* zero = get_if<ZeroInitializer>(&i))
+    return to_v1(*zero);
+  else if (const auto* uniform = get_if<UniformInitializer>(&i))
+    return to_v1(*uniform);
+  else if (const auto* norm = get_if<NormInitializer>(&i))
+    return to_v1(*norm);
+  else if (const auto* constant = get_if<ConstantInitializer>(&i))
+    return to_v1(*constant);
+  else
+    NOT_REACHABLE();
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/op.cc b/lib/pcg/src/file_format/v1/op.cc
index 9e48c0bcda..4ef528a4c3 100644
--- a/lib/pcg/src/file_format/v1/op.cc
+++ b/lib/pcg/src/file_format/v1/op.cc
@@ -3,7 +3,183 @@
 namespace FlexFlow {
 
 V1Op to_v1(Op const &op) {
-  NOT_IMPLEMENTED();
+  // There should be a better way of doing this.
+  switch (op) {
+    case Op::NOOP:
+      return V1Op::NOOP;
+    case Op::INPUT:
+      return V1Op::INPUT;
+    case Op::WEIGHT:
+      return V1Op::WEIGHT;
+    case Op::CONV2D:
+      return V1Op::CONV2D;
+    case Op::DROPOUT:
+      return V1Op::DROPOUT;
+    case Op::LINEAR:
+      return V1Op::LINEAR;
+    case Op::BATCHMATMUL:
+      return V1Op::BATCHMATMUL;
+    case Op::POOL2D:
+      return V1Op::POOL2D;
+    case Op::SCALAR_MULTIPLY:
+      return V1Op::SCALAR_MULTIPLY;
+    case Op::SCALAR_ADD:
+      return V1Op::SCALAR_ADD;
+    case Op::SCALAR_FLOOR_DIV:
+      return V1Op::SCALAR_FLOOR_DIV;
+    case Op::SCALAR_TRUE_DIV:
+      return V1Op::SCALAR_TRUE_DIV;
+    case Op::SCALAR_SUB:
+      return V1Op::SCALAR_SUB;
+    case Op::RELU:
+      return V1Op::RELU;
+    case Op::IDENTITY:
+      return V1Op::IDENTITY;
+    case Op::SIGMOID:
+      return V1Op::SIGMOID;
+    case Op::TANH:
+      return V1Op::TANH;
+    case Op::ELU:
+      return V1Op::ELU;
+    case Op::FLAT:
+      return V1Op::FLAT;
+    case Op::SOFTMAX:
+      return V1Op::SOFTMAX;
+    case Op::BATCHNORM:
+      return V1Op::BATCHNORM;
+    case Op::CONCAT:
+      return V1Op::CONCAT;
+    case Op::SPLIT:
+      return V1Op::SPLIT;
+    case Op::EMBEDDING:
+      return V1Op::EMBEDDING;
+    case Op::GROUP_BY:
+      return V1Op::GROUP_BY;
+    case Op::CACHE:
+      return V1Op::CACHE;
+    case Op::AGGREGATE:
+      return V1Op::AGGREGATE;
+    case Op::AGG_SPEC:
+      return V1Op::AGG_SPEC;
+    case Op::RESHAPE:
+      return V1Op::RESHAPE;
+    case Op::REVERSE:
+      return V1Op::REVERSE;
+    case Op::TRANSPOSE:
+      return V1Op::TRANSPOSE;
+    case Op::EW_ADD:
+      return V1Op::EW_ADD;
+    case Op::EW_MUL:
+      return V1Op::EW_MUL;
+    case Op::MATMUL:
+      return V1Op::MATMUL;
+    case Op::MUL:
+      return V1Op::MUL;
+    case Op::ENLARGE:
+      return V1Op::ENLARGE;
+    case Op::SQUEEZE:
+      return V1Op::SQUEEZE;
+    case Op::UNSQUEEZE:
+      return V1Op::UNSQUEEZE;
+    case Op::EW_SUB:
+      return V1Op::EW_SUB;
+    case Op::EW_DIV:
+      return V1Op::EW_DIV;
+    case Op::EW_EQUAL:
+      return V1Op::EW_EQUAL;
+    case Op::EW_GREATER:
+      return V1Op::EW_GREATER;
+    case Op::EW_LESS:
+      return V1Op::EW_LESS;
+    case Op::EW_MAX:
+      return V1Op::EW_MAX;
+    case Op::EW_MIN:
+      return V1Op::EW_MIN;
+    case Op::REDUCE_ARGMAX:
+      return V1Op::REDUCE_ARGMAX;
+    case Op::REDUCE_ARGMIN:
+      return V1Op::REDUCE_ARGMIN;
+    case Op::REDUCE_MAX:
+      return V1Op::REDUCE_MAX;
+    case Op::REDUCE_MEAN:
+      return V1Op::REDUCE_MEAN;
+    case Op::REDUCE_MIN:
+      return V1Op::REDUCE_MIN;
+    case Op::REDUCE_PROD:
+      return V1Op::REDUCE_PROD;
+    case Op::REDUCE_SUM:
+      return V1Op::REDUCE_SUM;
+    case Op::PAD:
+      return V1Op::PAD;
+    case Op::SHAPE:
+      return V1Op::SHAPE;
+    case Op::SIZE:
+      return V1Op::SIZE;
+    case Op::TOPK:
+      return V1Op::TOPK;
+    case Op::WHERE:
+      return V1Op::WHERE;
+    case Op::CEIL:
+      return V1Op::CEIL;
+    case Op::CAST:
+      return V1Op::CAST;
+    case Op::EXP:
+      return V1Op::EXP;
+    case Op::ROUND:
+      return V1Op::ROUND;
+    case Op::LOG:
+      return V1Op::LOG;
+    case Op::LOGICAL_NOT:
+      return V1Op::LOGICAL_NOT;
+    case Op::SQRT:
+      return V1Op::SQRT;
+    case Op::SIN:
+      return V1Op::SIN;
+    case Op::COS:
+      return V1Op::COS;
+    case Op::LEAKYRELU:
+      return V1Op::LEAKYRELU;
+    case Op::SLICE:
+      return V1Op::SLICE;
+    case Op::RESIZE:
+      return V1Op::RESIZE;
+    case Op::PRELU:
+      return V1Op::PRELU;
+    case Op::GELU:
+      return V1Op::GELU;
+    case Op::MULTIHEAD_ATTENTION:
+      return V1Op::MULTIHEAD_ATTENTION;
+    case Op::FUSED:
+      return V1Op::FUSED;
+    case Op::RSQRT:
+      return V1Op::RSQRT;
+    case Op::POW:
+      return V1Op::POW;
+    case Op::MEAN:
+      return V1Op::MEAN;
+    case Op::LAYERNORM:
+      return V1Op::LAYERNORM;
+    case Op::GATHER:
+      return V1Op::GATHER;
+    case Op::BROADCAST:
+      return V1Op::BROADCAST;
+    case Op::REPARTITION:
+      return V1Op::REPARTITION;
+    case Op::COMBINE:
+      return V1Op::COMBINE;
+    case Op::REPLICATE:
+      return V1Op::REPLICATE;
+    case Op::REDUCTION:
+      return V1Op::REDUCTION;
+    case Op::BATCH:
+      return V1Op::BATCH;
+    case Op::PIPELINE:
+      return V1Op::PIPELINE;
+    case Op::FUSED_PARALLEL:
+      return V1Op::FUSED_PARALLEL;
+    default:
+      NOT_REACHABLE();
+  }
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/operator_attrs.cc b/lib/pcg/src/file_format/v1/operator_attrs.cc
index d0839eda0f..683c8116b1 100644
--- a/lib/pcg/src/file_format/v1/operator_attrs.cc
+++ b/lib/pcg/src/file_format/v1/operator_attrs.cc
@@ -4,11 +4,137 @@
 namespace FlexFlow {
 
 V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs) {
-  NOT_IMPLEMENTED();
+  if (auto const *aggr = get_if<AggregateAttrs>(&attrs)) {
+    return to_v1(*aggr);
+  } else if (auto const *aggrSpec = get_if<AggregateSpecAttrs>(&attrs)) {
+    return to_v1(*aggrSpec);
+  } else if (auto const *batchMm = get_if<BatchMatmulAttrs>(&attrs)) {
+    return to_v1(*batchMm);
+  } else if (auto const *batchNorm = get_if<BatchNormAttrs>(&attrs)) {
+    return to_v1(*batchNorm);
+  } else if (auto const *cast = get_if<CastAttrs>(&attrs)) {
+    return to_v1(*cast);
+  } else if (auto const *concat = get_if<ConcatAttrs>(&attrs)) {
+    return to_v1(*concat);
+  } else if (auto const *conv2d = get_if<Conv2DAttrs>(&attrs)) {
+    return to_v1(*conv2d);
+  } else if (auto const *dropout = get_if<DropoutAttrs>(&attrs)) {
+    return to_v1(*dropout);
+  } else if (auto const *elemBin = get_if<ElementBinaryAttrs>(&attrs)) {
+    return to_v1(*elemBin);
+  } else if (auto const *elemUnSc = get_if<ElementScalarUnaryAttrs>(&attrs)) {
+    return to_v1(*elemUnSc);
+  } else if (auto const *elemUn = get_if<ElementUnaryAttrs>(&attrs)) {
+    return to_v1(*elemUn);
+  } else if (auto const *emb = get_if<EmbeddingAttrs>(&attrs)) {
+    return to_v1(*emb);
+  } else if (auto const *flat = get_if<FlatAttrs>(&attrs)) {
+    return to_v1(*flat);
+  } else if (auto const *gather = get_if<GatherAttrs>(&attrs)) {
+    return to_v1(*gather);
+  } else if (auto const *group = get_if<Group_byAttrs>(&attrs)) {
+    return to_v1(*group);
+  } else if (auto const *inp = get_if<InputAttrs>(&attrs)) {
+    return to_v1(*inp);
+  } else if (auto const *layerNorm = get_if<LayerNormAttrs>(&attrs)) {
+    return to_v1(*layerNorm);
+  } else if (auto const *lin = get_if<LinearAttrs>(&attrs)) {
+    return to_v1(*lin);
+  } else if (auto const *att = get_if<MultiHeadAttentionAttrs>(&attrs)) {
+    return to_v1(*att);
+  } else if (auto const *noop = get_if<NoopAttrs>(&attrs)) {
+    return to_v1(*noop);
+  } else if (auto const *pool2d = get_if<Pool2DAttrs>(&attrs)) {
+    return to_v1(*pool2d);
+  } else if (auto const *reduce = get_if<ReduceAttrs>(&attrs)) {
+    return to_v1(*reduce);
+  } else if (auto const *reverse = get_if<ReverseAttrs>(&attrs)) {
+    return to_v1(*reverse);
+  } else if (auto const *reshape = get_if<ReshapeAttrs>(&attrs)) {
+    return to_v1(*reshape);
+  } else if (auto const *split = get_if<SplitAttrs>(&attrs)) {
+    return to_v1(*split);
+  } else if (auto const *soft = get_if<SoftmaxAttrs>(&attrs)) {
+    return to_v1(*soft);
+  } else if (auto const *topk = get_if<TopKAttrs>(&attrs)) {
+    return to_v1(*topk);
+  } else if (auto const *trans = get_if<TransposeAttrs>(&attrs)) {
+    return to_v1(*trans);
+  } else if (auto const *bcast = get_if<BroadcastAttrs>(&attrs)) {
+    return to_v1(*bcast);
+  } else {
+    NOT_REACHABLE();
+  }
 }
 
 V1PCGOperatorAttrs to_v1(PCGOperatorAttrs const &attrs) {
-  NOT_IMPLEMENTED();
+  if (auto const *aggr = get_if<AggregateAttrs>(&attrs)) {
+    return to_v1(*aggr);
+  } else if (auto const *aggrSpec = get_if<AggregateSpecAttrs>(&attrs)) {
+    return to_v1(*aggrSpec);
+  } else if (auto const *batchMm = get_if<BatchMatmulAttrs>(&attrs)) {
+    return to_v1(*batchMm);
+  } else if (auto const *batchNorm = get_if<BatchNormAttrs>(&attrs)) {
+    return to_v1(*batchNorm);
+  } else if (auto const *cast = get_if<CastAttrs>(&attrs)) {
+    return to_v1(*cast);
+  } else if (auto const *concat = get_if<ConcatAttrs>(&attrs)) {
+    return to_v1(*concat);
+  } else if (auto const *conv2d = get_if<Conv2DAttrs>(&attrs)) {
+    return to_v1(*conv2d);
+  } else if (auto const *dropout = get_if<DropoutAttrs>(&attrs)) {
+    return to_v1(*dropout);
+  } else if (auto const *elemBin = get_if<ElementBinaryAttrs>(&attrs)) {
+    return to_v1(*elemBin);
+  } else if (auto const *elemUnSc = get_if<ElementScalarUnaryAttrs>(&attrs)) {
+    return to_v1(*elemUnSc);
+  } else if (auto const *elemUn = get_if<ElementUnaryAttrs>(&attrs)) {
+    return to_v1(*elemUn);
+  } else if (auto const *emb = get_if<EmbeddingAttrs>(&attrs)) {
+    return to_v1(*emb);
+  } else if (auto const *flat = get_if<FlatAttrs>(&attrs)) {
+    return to_v1(*flat);
+  } else if (auto const *gather = get_if<GatherAttrs>(&attrs)) {
+    return to_v1(*gather);
+  } else if (auto const *group = get_if<Group_byAttrs>(&attrs)) {
+    return to_v1(*group);
+  } else if (auto const *inp = get_if<InputAttrs>(&attrs)) {
+    return to_v1(*inp);
+  } else if (auto const *layerNorm = get_if<LayerNormAttrs>(&attrs)) {
+    return to_v1(*layerNorm);
+  } else if (auto const *lin = get_if<LinearAttrs>(&attrs)) {
+    return to_v1(*lin);
+  } else if (auto const *att = get_if<MultiHeadAttentionAttrs>(&attrs)) {
+    return to_v1(*att);
+  } else if (auto const *noop = get_if<NoopAttrs>(&attrs)) {
+    return to_v1(*noop);
+  } else if (auto const *pool2d = get_if<Pool2DAttrs>(&attrs)) {
+    return to_v1(*pool2d);
+  } else if (auto const *reduce = get_if<ReduceAttrs>(&attrs)) {
+    return to_v1(*reduce);
+  } else if (auto const *reverse = get_if<ReverseAttrs>(&attrs)) {
+    return to_v1(*reverse);
+  } else if (auto const *reshape = get_if<ReshapeAttrs>(&attrs)) {
+    return to_v1(*reshape);
+  } else if (auto const *split = get_if<SplitAttrs>(&attrs)) {
+    return to_v1(*split);
+  } else if (auto const *soft = get_if<SoftmaxAttrs>(&attrs)) {
+    return to_v1(*soft);
+  } else if (auto const *topk = get_if<TopKAttrs>(&attrs)) {
+    return to_v1(*topk);
+  } else if (auto const *trans = get_if<TransposeAttrs>(&attrs)) {
+    return to_v1(*trans);
+  } else if (auto const *combine = get_if<CombineAttrs>(&attrs)) {
+    return to_v1(*combine);
+  } else if (auto const *red = get_if<ReductionAttrs>(&attrs)) {
+    return to_v1(*red);
+  } else if (auto const *repart = get_if<RepartitionAttrs>(&attrs)) {
+    return to_v1(*repart);
+  } else if (auto const *repl = get_if<ReplicateAttrs>(&attrs)) {
+    return to_v1(*repl);
+  } else {
+    NOT_REACHABLE();
+  }
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/aggregate.cc b/lib/pcg/src/file_format/v1/ops/aggregate.cc
index 207b0a3a95..0a6818e676 100644
--- a/lib/pcg/src/file_format/v1/ops/aggregate.cc
+++ b/lib/pcg/src/file_format/v1/ops/aggregate.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/aggregate.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1AggregateAttrs to_v1(AggregateAttrs const &a) {
-  return {to_v1(a.n), to_v1(a.lambda_bal)};
+  return {a.n, a.lambda_bal};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc b/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
index 26d9184988..29f17109d5 100644
--- a/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
+++ b/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/aggregate_spec.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1AggregateSpecAttrs to_v1(AggregateSpecAttrs const &a) {
-  return {to_v1(a.n), to_v1(a.lambda_bal)};
+  return {a.n, a.lambda_bal};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/attention.cc b/lib/pcg/src/file_format/v1/ops/attention.cc
index 4bb7a44b63..553106330d 100644
--- a/lib/pcg/src/file_format/v1/ops/attention.cc
+++ b/lib/pcg/src/file_format/v1/ops/attention.cc
@@ -1,17 +1,16 @@
 #include "pcg/file_format/v1/ops/attention.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1MultiHeadAttentionAttrs to_v1(MultiHeadAttentionAttrs const &a) {
-  return {to_v1(a.embed_dim),
-          to_v1(a.num_heads),
-          to_v1(a.kdim),
-          to_v1(a.vdim),
-          to_v1(a.dropout),
-          to_v1(a.bias),
-          to_v1(a.add_bias_kv),
-          to_v1(a.add_zero_attn)};
+  return {a.embed_dim,
+          a.num_heads,
+          a.kdim,
+          a.vdim,
+          a.dropout,
+          a.bias,
+          a.add_bias_kv,
+          a.add_zero_attn};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/batch_matmul.cc b/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
index 8a99d36484..48324a4672 100644
--- a/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
+++ b/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
@@ -4,7 +4,7 @@
 namespace FlexFlow {
 
 V1BatchMatmulAttrs to_v1(BatchMatmulAttrs const &a) {
-  return {to_v1(a.a_seq_length_dim), to_v1(a.b_seq_length_dim)};
+  return {a.a_seq_length_dim, a.b_seq_length_dim};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/batch_norm.cc b/lib/pcg/src/file_format/v1/ops/batch_norm.cc
index 4c25c170fc..f06cbffa89 100644
--- a/lib/pcg/src/file_format/v1/ops/batch_norm.cc
+++ b/lib/pcg/src/file_format/v1/ops/batch_norm.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/batch_norm.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1BatchNormAttrs to_v1(BatchNormAttrs const &a) {
-  return {to_v1(a.relu)};
+  return {a.relu};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/combine.cc b/lib/pcg/src/file_format/v1/ops/combine.cc
index 7a6d286e21..a80ecd869d 100644
--- a/lib/pcg/src/file_format/v1/ops/combine.cc
+++ b/lib/pcg/src/file_format/v1/ops/combine.cc
@@ -1,11 +1,10 @@
 #include "pcg/file_format/v1/ops/combine.h"
 #include "pcg/file_format/v1/ff_dim.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1CombineAttrs to_v1(CombineAttrs const &a) {
-  return {to_v1(a.combine_dim), to_v1(a.combine_degree)};
+  return {to_v1(a.combine_dim), a.combine_degree};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/conv_2d.cc b/lib/pcg/src/file_format/v1/ops/conv_2d.cc
index dfa7f2967e..8993dc0da4 100644
--- a/lib/pcg/src/file_format/v1/ops/conv_2d.cc
+++ b/lib/pcg/src/file_format/v1/ops/conv_2d.cc
@@ -4,16 +4,16 @@
 namespace FlexFlow {
 
 V1Conv2DAttrs to_v1(Conv2DAttrs const &a) {
-  return {to_v1(a.out_channels),
-          to_v1(a.kernel_h),
-          to_v1(a.kernel_w),
-          to_v1(a.stride_h),
-          to_v1(a.stride_w),
-          to_v1(a.padding_h),
-          to_v1(a.padding_w),
-          to_v1(a.groups),
+  return {a.out_channels,
+          a.kernel_h,
+          a.kernel_w,
+          a.stride_h,
+          a.stride_w,
+          a.padding_h,
+          a.padding_w,
+          a.groups,
           to_v1<V1Activation>(a.activation),
-          to_v1(a.use_bias)};
+          a.use_bias};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/dropout.cc b/lib/pcg/src/file_format/v1/ops/dropout.cc
index ef9a6a92eb..2b6d482cc9 100644
--- a/lib/pcg/src/file_format/v1/ops/dropout.cc
+++ b/lib/pcg/src/file_format/v1/ops/dropout.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/dropout.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1DropoutAttrs to_v1(DropoutAttrs const &a) {
-  return {to_v1(a.rate), to_v1(a.seed)};
+  return {a.rate, a.seed};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/element_binary.cc b/lib/pcg/src/file_format/v1/ops/element_binary.cc
index 033fda5c41..a763d9e35a 100644
--- a/lib/pcg/src/file_format/v1/ops/element_binary.cc
+++ b/lib/pcg/src/file_format/v1/ops/element_binary.cc
@@ -1,13 +1,12 @@
 #include "pcg/file_format/v1/ops/element_binary.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1ElementBinaryAttrs to_v1(ElementBinaryAttrs const &a) {
   return {to_v1(a.type),
           to_v1(a.compute_type),
-          to_v1(a.should_broadcast_lhs),
-          to_v1(a.should_broadcast_rhs)};
+          a.should_broadcast_lhs,
+          a.should_broadcast_rhs};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/element_unary.cc b/lib/pcg/src/file_format/v1/ops/element_unary.cc
index c704860d47..f4f69fbd7d 100644
--- a/lib/pcg/src/file_format/v1/ops/element_unary.cc
+++ b/lib/pcg/src/file_format/v1/ops/element_unary.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/element_unary.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &a) {
-  return {to_v1(a.op), to_v1(a.scalar)};
+  return {to_v1(a.op), a.scalar};
 }
 
 V1ElementUnaryAttrs to_v1(ElementUnaryAttrs const &a) {
diff --git a/lib/pcg/src/file_format/v1/ops/embedding.cc b/lib/pcg/src/file_format/v1/ops/embedding.cc
index 4caefe6f39..91b093c928 100644
--- a/lib/pcg/src/file_format/v1/ops/embedding.cc
+++ b/lib/pcg/src/file_format/v1/ops/embedding.cc
@@ -4,14 +4,19 @@
 namespace FlexFlow {
 
 V1AggregateOp to_v1(AggregateOp const &op) {
-  NOT_IMPLEMENTED();
+  // There should be a better way of doing this.
+  switch (op) {
+    case AggregateOp::SUM:
+      return V1AggregateOp::SUM;
+    case AggregateOp::AVG:
+      return V1AggregateOp::AVG;
+    default:
+      NOT_REACHABLE();
+  }
 }
 
 V1EmbeddingAttrs to_v1(EmbeddingAttrs const &a) {
-  return {to_v1(a.num_entries),
-          to_v1(a.out_channels),
-          to_v1(a.aggr),
-          to_v1(a.data_type)};
+  return {a.num_entries, a.out_channels, to_v1(a.aggr), to_v1(a.data_type)};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/groupby.cc b/lib/pcg/src/file_format/v1/ops/groupby.cc
index 75c7163049..652e7e63b2 100644
--- a/lib/pcg/src/file_format/v1/ops/groupby.cc
+++ b/lib/pcg/src/file_format/v1/ops/groupby.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/groupby.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1Group_byAttrs to_v1(Group_byAttrs const &a) {
-  return {to_v1(a.n), to_v1(a.alpha)};
+  return {a.n, a.alpha};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/layer_norm.cc b/lib/pcg/src/file_format/v1/ops/layer_norm.cc
index 6e2efff5dc..97713c2d4a 100644
--- a/lib/pcg/src/file_format/v1/ops/layer_norm.cc
+++ b/lib/pcg/src/file_format/v1/ops/layer_norm.cc
@@ -6,8 +6,8 @@ namespace FlexFlow {
 
 V1LayerNormAttrs to_v1(LayerNormAttrs const &a) {
   return {std::vector<int>(a.axes.begin(), a.axes.end()),
-          to_v1(a.elementwise_affine),
-          to_v1(a.eps)};
+          a.elementwise_affine,
+          a.eps};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/linear.cc b/lib/pcg/src/file_format/v1/ops/linear.cc
index b732713fde..f0ee521029 100644
--- a/lib/pcg/src/file_format/v1/ops/linear.cc
+++ b/lib/pcg/src/file_format/v1/ops/linear.cc
@@ -4,20 +4,26 @@
 namespace FlexFlow {
 
 V1L1RegularizerAttrs to_v1(L1RegularizerAttrs const &a) {
-  return {to_v1(a.lambda)};
+  return {a.lambda};
 }
 
 V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &a) {
-  return {to_v1(a.lambda)};
+  return {a.lambda};
 }
 
 V1RegularizerAttrs to_v1(RegularizerAttrs const &a) {
-  NOT_IMPLEMENTED();
+  // There should be a better way of doing this.
+  if (const auto* l1 = get_if<L1RegularizerAttrs>(&a))
+    return to_v1(*l1);
+  else if (const auto* l2 = get_if<L2RegularizerAttrs>(&a))
+    return to_v1(*l2);
+  else
+    NOT_REACHABLE();
 }
 
 V1LinearAttrs to_v1(LinearAttrs const &a) {
-  return {to_v1(a.out_channels),
-          to_v1(a.use_bias),
+  return {a.out_channels,
+          a.use_bias,
           to_v1(a.data_type),
           to_v1(a.activation),
           to_v1<V1RegularizerAttrs>(a.regularizer)};
diff --git a/lib/pcg/src/file_format/v1/ops/pool_2d.cc b/lib/pcg/src/file_format/v1/ops/pool_2d.cc
index a84c52687c..1d37aede8d 100644
--- a/lib/pcg/src/file_format/v1/ops/pool_2d.cc
+++ b/lib/pcg/src/file_format/v1/ops/pool_2d.cc
@@ -4,16 +4,24 @@
 namespace FlexFlow {
 
 V1PoolOp to_v1(PoolOp const &op) {
-  NOT_IMPLEMENTED();
+  // There should be a better way of doing this.
+  switch (op) {
+    case PoolOp::MAX:
+      return V1PoolOp::MAX;
+    case PoolOp::AVG:
+      return V1PoolOp::AVG;
+    default:
+      NOT_REACHABLE();
+  }
 }
 
 V1Pool2DAttrs to_v1(Pool2DAttrs const &a) {
-  return {to_v1(a.kernel_h),
-          to_v1(a.kernel_w),
-          to_v1(a.stride_h),
-          to_v1(a.stride_w),
-          to_v1(a.padding_h),
-          to_v1(a.padding_w),
+  return {a.kernel_h,
+          a.kernel_w,
+          a.stride_h,
+          a.stride_w,
+          a.padding_h,
+          a.padding_w,
           to_v1(a.pool_type),
           to_v1(a.activation)};
 }
diff --git a/lib/pcg/src/file_format/v1/ops/reduce.cc b/lib/pcg/src/file_format/v1/ops/reduce.cc
index 91bc8b1577..cd6eac6e6a 100644
--- a/lib/pcg/src/file_format/v1/ops/reduce.cc
+++ b/lib/pcg/src/file_format/v1/ops/reduce.cc
@@ -1,13 +1,12 @@
 #include "pcg/file_format/v1/ops/reduce.h"
 #include "pcg/file_format/v1/ff_dim.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1ReduceAttrs to_v1(ReduceAttrs const &a) {
   return {std::vector<int>(a.axes.begin(), a.axes.end()),
           to_v1(a.op_type),
-          to_v1(a.keepdims)};
+          a.keepdims};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reduction.cc b/lib/pcg/src/file_format/v1/ops/reduction.cc
index 8a8d6297e8..2f086b1817 100644
--- a/lib/pcg/src/file_format/v1/ops/reduction.cc
+++ b/lib/pcg/src/file_format/v1/ops/reduction.cc
@@ -1,11 +1,10 @@
 #include "pcg/file_format/v1/ops/reduction.h"
 #include "pcg/file_format/v1/ff_dim.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1ReductionAttrs to_v1(ReductionAttrs const &a) {
-  return {to_v1(a.reduction_dim), to_v1(a.reduction_degree)};
+  return {to_v1(a.reduction_dim), a.reduction_degree};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/repartition.cc b/lib/pcg/src/file_format/v1/ops/repartition.cc
index 7d3b40e559..629aa89045 100644
--- a/lib/pcg/src/file_format/v1/ops/repartition.cc
+++ b/lib/pcg/src/file_format/v1/ops/repartition.cc
@@ -1,11 +1,10 @@
 #include "pcg/file_format/v1/ops/repartition.h"
 #include "pcg/file_format/v1/ff_dim.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1RepartitionAttrs to_v1(RepartitionAttrs const &a) {
-  return {to_v1(a.repartition_dim), to_v1(a.repartition_degree)};
+  return {to_v1(a.repartition_dim), a.repartition_degree};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/replicate.cc b/lib/pcg/src/file_format/v1/ops/replicate.cc
index 9aa36c3c1b..a1a369e417 100644
--- a/lib/pcg/src/file_format/v1/ops/replicate.cc
+++ b/lib/pcg/src/file_format/v1/ops/replicate.cc
@@ -1,11 +1,10 @@
 #include "pcg/file_format/v1/ops/replicate.h"
 #include "pcg/file_format/v1/ff_dim.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1ReplicateAttrs to_v1(ReplicateAttrs const &a) {
-  return {to_v1(a.replicate_dim), to_v1(a.replicate_degree)};
+  return {to_v1(a.replicate_dim), a.replicate_degree};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reverse.cc b/lib/pcg/src/file_format/v1/ops/reverse.cc
index 86fde17f07..1ee500c881 100644
--- a/lib/pcg/src/file_format/v1/ops/reverse.cc
+++ b/lib/pcg/src/file_format/v1/ops/reverse.cc
@@ -1,6 +1,5 @@
 #include "pcg/file_format/v1/ops/reverse.h"
 #include "pcg/file_format/v1/ff_dim.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
diff --git a/lib/pcg/src/file_format/v1/ops/topk.cc b/lib/pcg/src/file_format/v1/ops/topk.cc
index 41cb08d9bd..2735f0ac20 100644
--- a/lib/pcg/src/file_format/v1/ops/topk.cc
+++ b/lib/pcg/src/file_format/v1/ops/topk.cc
@@ -1,10 +1,9 @@
 #include "pcg/file_format/v1/ops/topk.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
 V1TopKAttrs to_v1(TopKAttrs const &a) {
-  return {to_v1(a.k), to_v1(a.sorted)};
+  return {a.k, a.sorted};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/parallel_tensor.cc b/lib/pcg/src/file_format/v1/parallel_tensor.cc
index fbcd2a949b..e04d89d512 100644
--- a/lib/pcg/src/file_format/v1/parallel_tensor.cc
+++ b/lib/pcg/src/file_format/v1/parallel_tensor.cc
@@ -1,9 +1,26 @@
 #include "pcg/file_format/v1/parallel_tensor.h"
+#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
+V1ParallelDim to_v1(ParallelDim const &dim) {
+  return {dim.size, dim.degree, dim.is_replica_dim};
+}
+
+V1ParallelTensorShape to_v1(ParallelTensorShape const &shp) {
+  std::vector<V1ParallelDim> pdims;
+  for (ParallelDim const &pdim : shp.dims) {
+    pdims.emplace_back(to_v1(pdim));
+  }
+  return {pdims, to_v1(shp.data_type)};
+}
+
 V1ParallelTensor to_v1(ParallelTensor const &t) {
-  NOT_IMPLEMENTED();
+  return {to_v1(t.get_shape()),
+          to_v1(t.create_gradients),
+          to_v1<V1Initializer>(t.initializer),
+          to_v1<V1ParamSync>(t.sync_type),
+          t.name};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/param_sync.cc b/lib/pcg/src/file_format/v1/param_sync.cc
index 5972b10f54..f9f75171cd 100644
--- a/lib/pcg/src/file_format/v1/param_sync.cc
+++ b/lib/pcg/src/file_format/v1/param_sync.cc
@@ -1,5 +1,4 @@
 #include "pcg/file_format/v1/param_sync.h"
-#include "pcg/file_format/v1/v1.h"
 
 namespace FlexFlow {
 
@@ -10,7 +9,7 @@ V1ParamSync to_v1(ParamSync const &p) {
     case ParamSync::NCCL:
       return V1ParamSync::NCCL;
     default:
-      NOT_IMPLEMENTED();
+      NOT_REACHABLE();
   };
 }
 
diff --git a/lib/pcg/src/file_format/v1/tensor.cc b/lib/pcg/src/file_format/v1/tensor.cc
index 55bc71ce0d..4d891a5a78 100644
--- a/lib/pcg/src/file_format/v1/tensor.cc
+++ b/lib/pcg/src/file_format/v1/tensor.cc
@@ -4,13 +4,11 @@
 namespace FlexFlow {
 
 V1Tensor to_v1(Tensor const &t) {
-  return {
-      to_v1(t.get_shape()),
-      t.create_gradients,
-      to_v1<V1Initializer>(t.initializer),
-      to_v1<V1ParamSync>(t.sync_type),
-      t.name,
-  };
+  return {to_v1(t.get_shape()),
+          to_v1(t.create_gradients),
+          to_v1<V1Initializer>(t.initializer),
+          to_v1<V1ParamSync>(t.sync_type),
+          t.name};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/tensor_shape.cc b/lib/pcg/src/file_format/v1/tensor_shape.cc
index f85a55ec12..6c75ffd446 100644
--- a/lib/pcg/src/file_format/v1/tensor_shape.cc
+++ b/lib/pcg/src/file_format/v1/tensor_shape.cc
@@ -3,7 +3,8 @@
 namespace FlexFlow {
 
 V1TensorShape to_v1(TensorShape const &shape) {
-  NOT_IMPLEMENTED();
+  return {std::vector<size_t>(shape.dims.begin(), shape.dims.end()),
+          to_v1(shape.data_type)};
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/v1.cc b/lib/pcg/src/file_format/v1/v1.cc
index 530d3955ec..6c748a45e9 100644
--- a/lib/pcg/src/file_format/v1/v1.cc
+++ b/lib/pcg/src/file_format/v1/v1.cc
@@ -1,3 +1,9 @@
 #include "pcg/file_format/v1/v1.h"
 
-namespace FlexFlow {}
+namespace FlexFlow {
+
+std::string to_v1(std::string const &s) {
+  return s;
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/parallel_tensor.cc b/lib/pcg/src/parallel_tensor.cc
new file mode 100644
index 0000000000..f63f31224a
--- /dev/null
+++ b/lib/pcg/src/parallel_tensor.cc
@@ -0,0 +1,21 @@
+#include "pcg/parallel_tensor.h"
+
+namespace FlexFlow {
+
+size_t ParallelTensor::get_volume() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensorShape ParallelTensor::get_shape() const {
+  return {dims, data_type};
+}
+
+int ParallelTensor::num_dims() const {
+  NOT_IMPLEMENTED();
+}
+
+ParallelTensor::operator ParallelTensorShape() const {
+  return get_shape();
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/tensor.cc b/lib/pcg/src/tensor.cc
index 2b61ab5c03..f5de632c71 100644
--- a/lib/pcg/src/tensor.cc
+++ b/lib/pcg/src/tensor.cc
@@ -6,7 +6,7 @@ size_t Tensor::get_volume() const {
 }
 
 TensorShape Tensor::get_shape() const {
-  NOT_IMPLEMENTED();
+  return {dims, data_type};
 }
 
 int Tensor::num_dims() const {
@@ -14,7 +14,7 @@ int Tensor::num_dims() const {
 }
 
 Tensor::operator TensorShape() const {
-  NOT_IMPLEMENTED();
+  return get_shape();
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/test/CMakeLists.txt b/lib/pcg/test/CMakeLists.txt
index df1321f05f..6dc844a25b 100644
--- a/lib/pcg/test/CMakeLists.txt
+++ b/lib/pcg/test/CMakeLists.txt
@@ -21,8 +21,6 @@ target_link_libraries(
 set_target_properties(
   ${test_target}
   PROPERTIES
-    CXX_STANDARD 11
-    CXX_STANDARD_REQUIRED YES
     CXX_EXTENSIONS NO
 )
 doctest_discover_tests(${test_target})
diff --git a/lib/pcg/test/test_tensor.cc b/lib/pcg/test/test_tensor.cc
index a7789f8f08..95365e0762 100644
--- a/lib/pcg/test/test_tensor.cc
+++ b/lib/pcg/test/test_tensor.cc
@@ -11,7 +11,7 @@ using namespace FlexFlow;
 TEST_CASE("Tensor") {
   Tensor t{{3, 4, 5},
            DataType::FLOAT,
-           false,
+           CreateGrad::NO,
            nullopt,
            nullopt,
            std::string("tensor")};
diff --git a/lib/utils/include/utils/exception.decl.h b/lib/utils/include/utils/exception.decl.h
index d27174f474..1e60e99987 100644
--- a/lib/utils/include/utils/exception.decl.h
+++ b/lib/utils/include/utils/exception.decl.h
@@ -9,12 +9,24 @@ namespace FlexFlow {
 #ifdef FF_REQUIRE_IMPLEMENTED
 #define NOT_IMPLEMENTED() static_assert(false, "Function not yet implemented");
 #else
-#define NOT_IMPLEMENTED() throw not_implemented();
+#define NOT_IMPLEMENTED() throw not_implemented(__FILE__, __LINE__);
 #endif
 
 class not_implemented : public std::logic_error {
 public:
-  not_implemented();
+  not_implemented(char const *file, unsigned line);
+};
+
+// This macro should only be used when code is known to be unreachable under
+// normal circumstances but may get hit because of a *developer* (not user)
+// error. An example of this would be adding a member to an enum but not
+// updating all switch statements that use the enum. It is primarily provided
+// to squelch compiler warnings about such situations.
+#define NOT_REACHABLE() throw not_reachable(__FILE__, __LINE__);
+
+class not_reachable : public std::logic_error {
+public:
+  not_reachable(char const *file, unsigned line);
 };
 
 template <typename... T>
diff --git a/lib/utils/src/exception.cc b/lib/utils/src/exception.cc
index 7dccdc3074..1c401a934e 100644
--- a/lib/utils/src/exception.cc
+++ b/lib/utils/src/exception.cc
@@ -1,8 +1,14 @@
 #include "utils/exception.h"
+#include "utils/fmt.decl.h"
 
 namespace FlexFlow {
 
-not_implemented::not_implemented()
-    : std::logic_error("Function not yet implemented"){};
+not_implemented::not_implemented(char const *file, unsigned line)
+    : std::logic_error(
+          fmt::format("Function not yet implemented: {}:{}", file, line)) {}
 
-}
+not_reachable::not_reachable(char const *file, unsigned line)
+    : std::logic_error(
+          fmt::format("Unreachable code was reached: {}:{}", file, line)) {}
+
+} // namespace FlexFlow

From 60b60a9e400a5d356e1672e5759229313fef668b Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Thu, 5 Oct 2023 15:59:49 -0600
Subject: [PATCH 11/15] Add from_v1 functions for most of the types. A couple
 of stubs of from_v1 still remain for the graph as a whole. Add a test for
 json in lib/utils. Fix some of the parallel tensor classes in op-attrs to be
 a bit more consistent with the serial tensor, but that may need some changing
 as well.

---
 .../include/op-attrs/parallel_tensor_dims.h   |   4 +
 .../include/op-attrs/parallel_tensor_shape.h  |  10 +-
 .../include/pcg/file_format/v1/activation.h   |   1 +
 .../include/pcg/file_format/v1/create_grad.h  |   1 +
 lib/pcg/include/pcg/file_format/v1/datatype.h |   3 +
 .../include/pcg/file_format/v1/dim_ordered.h  |   6 +
 lib/pcg/include/pcg/file_format/v1/ff_dim.h   |   1 +
 lib/pcg/include/pcg/file_format/v1/graphs.h   |   7 +
 .../include/pcg/file_format/v1/initializer.h  |   8 +-
 lib/pcg/include/pcg/file_format/v1/op.h       |   1 +
 .../pcg/file_format/v1/operator_attrs.h       |   5 +-
 .../pcg/file_format/v1/ops/aggregate.h        |   3 +-
 .../pcg/file_format/v1/ops/aggregate_spec.h   |   3 +-
 .../pcg/file_format/v1/ops/attention.h        |   3 +-
 .../pcg/file_format/v1/ops/batch_matmul.h     |   3 +-
 .../pcg/file_format/v1/ops/batch_norm.h       |   3 +-
 .../pcg/file_format/v1/ops/broadcast.h        |   3 +-
 lib/pcg/include/pcg/file_format/v1/ops/cast.h |   3 +-
 .../include/pcg/file_format/v1/ops/combine.h  |   3 +-
 .../include/pcg/file_format/v1/ops/concat.h   |   3 +-
 .../include/pcg/file_format/v1/ops/conv_2d.h  |   3 +-
 .../include/pcg/file_format/v1/ops/dropout.h  |   3 +-
 .../pcg/file_format/v1/ops/element_binary.h   |   3 +-
 .../pcg/file_format/v1/ops/element_unary.h    |   6 +-
 .../pcg/file_format/v1/ops/embedding.h        |   4 +-
 lib/pcg/include/pcg/file_format/v1/ops/flat.h |   3 +-
 .../include/pcg/file_format/v1/ops/gather.h   |   3 +-
 .../include/pcg/file_format/v1/ops/groupby.h  |   3 +-
 .../include/pcg/file_format/v1/ops/input.h    |   3 +-
 .../pcg/file_format/v1/ops/layer_norm.h       |   3 +-
 .../include/pcg/file_format/v1/ops/linear.h   |  14 +-
 lib/pcg/include/pcg/file_format/v1/ops/noop.h |   3 +-
 .../include/pcg/file_format/v1/ops/pool_2d.h  |   4 +-
 .../include/pcg/file_format/v1/ops/reduce.h   |   3 +-
 .../pcg/file_format/v1/ops/reduction.h        |   3 +-
 .../pcg/file_format/v1/ops/repartition.h      |   3 +-
 .../pcg/file_format/v1/ops/replicate.h        |   3 +-
 .../include/pcg/file_format/v1/ops/reshape.h  |   3 +-
 .../include/pcg/file_format/v1/ops/reverse.h  |   3 +-
 .../include/pcg/file_format/v1/ops/softmax.h  |   3 +-
 .../include/pcg/file_format/v1/ops/split.h    |   3 +-
 lib/pcg/include/pcg/file_format/v1/ops/topk.h |   3 +-
 .../pcg/file_format/v1/ops/transpose.h        |   3 +-
 .../include/pcg/file_format/v1/parallel_dim.h |   1 +
 .../pcg/file_format/v1/parallel_tensor.h      |  24 +--
 .../pcg/file_format/v1/parallel_tensor_dims.h |   3 +-
 .../file_format/v1/parallel_tensor_shape.h    |   3 +-
 .../include/pcg/file_format/v1/param_sync.h   |   3 +-
 lib/pcg/include/pcg/file_format/v1/tensor.h   |   1 +
 .../include/pcg/file_format/v1/tensor_shape.h |   6 +-
 lib/pcg/include/pcg/file_format/v1/v1.h       |  16 ++
 lib/pcg/include/pcg/parallel_tensor.h         |   4 +-
 lib/pcg/src/computation_graph_builder.cc      |  11 +-
 lib/pcg/src/file_format/v1/activation.cc      |  15 ++
 lib/pcg/src/file_format/v1/create_grad.cc     |  11 ++
 lib/pcg/src/file_format/v1/datatype.cc        |  65 +++++--
 lib/pcg/src/file_format/v1/ff_dim.cc          |   4 +
 lib/pcg/src/file_format/v1/graphs.cc          |  16 ++
 lib/pcg/src/file_format/v1/initializer.cc     |  52 ++++-
 lib/pcg/src/file_format/v1/op.cc              | 180 ++++++++++++++++++
 lib/pcg/src/file_format/v1/operator_attrs.cc  | 134 +++++++++++++
 lib/pcg/src/file_format/v1/ops/aggregate.cc   |   4 +
 .../src/file_format/v1/ops/aggregate_spec.cc  |   4 +
 lib/pcg/src/file_format/v1/ops/attention.cc   |  11 ++
 .../src/file_format/v1/ops/batch_matmul.cc    |   4 +
 lib/pcg/src/file_format/v1/ops/batch_norm.cc  |   4 +
 lib/pcg/src/file_format/v1/ops/broadcast.cc   |   7 +
 lib/pcg/src/file_format/v1/ops/cast.cc        |   4 +
 lib/pcg/src/file_format/v1/ops/combine.cc     |   4 +
 lib/pcg/src/file_format/v1/ops/concat.cc      |   4 +
 lib/pcg/src/file_format/v1/ops/conv_2d.cc     |  13 ++
 lib/pcg/src/file_format/v1/ops/dropout.cc     |   4 +
 .../src/file_format/v1/ops/element_binary.cc  |   7 +
 .../src/file_format/v1/ops/element_unary.cc   |   8 +
 lib/pcg/src/file_format/v1/ops/embedding.cc   |  17 ++
 lib/pcg/src/file_format/v1/ops/flat.cc        |   6 +
 lib/pcg/src/file_format/v1/ops/gather.cc      |   4 +
 lib/pcg/src/file_format/v1/ops/groupby.cc     |   4 +
 lib/pcg/src/file_format/v1/ops/input.cc       |   6 +
 lib/pcg/src/file_format/v1/ops/layer_norm.cc  |   8 +
 lib/pcg/src/file_format/v1/ops/linear.cc      |  34 +++-
 lib/pcg/src/file_format/v1/ops/noop.cc        |   6 +
 lib/pcg/src/file_format/v1/ops/pool_2d.cc     |  23 +++
 lib/pcg/src/file_format/v1/ops/reduce.cc      |   8 +
 lib/pcg/src/file_format/v1/ops/reduction.cc   |   4 +
 lib/pcg/src/file_format/v1/ops/repartition.cc |   4 +
 lib/pcg/src/file_format/v1/ops/replicate.cc   |   4 +
 lib/pcg/src/file_format/v1/ops/reshape.cc     |   4 +
 lib/pcg/src/file_format/v1/ops/reverse.cc     |   4 +
 lib/pcg/src/file_format/v1/ops/softmax.cc     |   4 +
 lib/pcg/src/file_format/v1/ops/split.cc       |   8 +
 lib/pcg/src/file_format/v1/ops/topk.cc        |   4 +
 lib/pcg/src/file_format/v1/ops/transpose.cc   |   8 +
 lib/pcg/src/file_format/v1/parallel_tensor.cc |  18 ++
 .../file_format/v1/parallel_tensor_dims.cc    |  21 ++
 lib/pcg/src/file_format/v1/param_sync.cc      |  11 ++
 lib/pcg/src/file_format/v1/tensor.cc          |  10 +
 lib/pcg/src/file_format/v1/tensor_shape.cc    |   5 +
 lib/pcg/src/file_format/v1/v1.cc              |   4 +
 lib/pcg/test/test_tensor.cc                   |   8 +-
 lib/utils/test/src/test_json.cc               |  21 ++
 101 files changed, 949 insertions(+), 95 deletions(-)
 create mode 100644 lib/pcg/src/file_format/v1/parallel_tensor_dims.cc
 create mode 100644 lib/utils/test/src/test_json.cc

diff --git a/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h b/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
index d7b25aecd5..a32b1ecb33 100644
--- a/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
+++ b/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
@@ -2,6 +2,7 @@
 #define _FLEXFLOW_OP_ATTRS_INCLUDE_OP_ATTRS_PARALLEL_TENSOR_DIMS_H
 
 #include "parallel_dim.h"
+#include "tensor_shape.h"
 #include "utils/visitable.h"
 
 namespace FlexFlow {
@@ -9,6 +10,9 @@ namespace FlexFlow {
 struct ParallelTensorDims {
   explicit ParallelTensorDims(TensorDims const &);
 
+  template <typename Dims>
+  ParallelTensorDims(std::vector<Dims> const &dims) : data(dims) {}
+
   size_t get_volume() const;
   size_t num_dims() const;
 
diff --git a/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h b/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
index 7ebfa947de..a9c52baaca 100644
--- a/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
+++ b/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
@@ -17,14 +17,12 @@ namespace FlexFlow {
  * @brief Represent the shape of a ParallelTensor.
  */
 struct ParallelTensorShape {
-  ParallelTensorShape() = delete;
+  ParallelTensorShape(TensorShape const &);
 
   template <typename Dims>
   ParallelTensorShape(Dims const &dims, DataType data_type)
       : dims(dims), data_type(data_type) {}
 
-  ParallelTensorShape(TensorShape const &);
-
   int num_dims() const;
 
   ParallelDim const &at(ff_dim_t const &) const;
@@ -33,10 +31,10 @@ struct ParallelTensorShape {
   ParallelDim &operator[](ff_dim_t const &);
 
 public:
-  ParallelTensorDims dims;
-  DataType data_type;
+  req<ParallelTensorDims> dims;
+  req<DataType> data_type;
 };
-FF_VISITABLE_STRUCT(ParallelTensorShape, dims, data_type);
+FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(ParallelTensorShape, dims, data_type);
 
 TensorShape get_piece_shape(ParallelTensorShape const &);
 int get_num_replica_dims(ParallelTensorShape const &);
diff --git a/lib/pcg/include/pcg/file_format/v1/activation.h b/lib/pcg/include/pcg/file_format/v1/activation.h
index 47ad6b6331..ca12f27a56 100644
--- a/lib/pcg/include/pcg/file_format/v1/activation.h
+++ b/lib/pcg/include/pcg/file_format/v1/activation.h
@@ -15,6 +15,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1Activation,
                               {V1Activation::GELU, "GELU"}});
 
 V1Activation to_v1(Activation const &a);
+Activation from_v1(V1Activation const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/create_grad.h b/lib/pcg/include/pcg/file_format/v1/create_grad.h
index c83eb93f31..de6678f6e4 100644
--- a/lib/pcg/include/pcg/file_format/v1/create_grad.h
+++ b/lib/pcg/include/pcg/file_format/v1/create_grad.h
@@ -13,6 +13,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1CreateGrad,
                               {V1CreateGrad::NO, "NO"}});
 
 V1CreateGrad to_v1(CreateGrad const &cg);
+CreateGrad from_v1(V1CreateGrad const &vcg);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/datatype.h b/lib/pcg/include/pcg/file_format/v1/datatype.h
index c85fcf4beb..a15a04945a 100644
--- a/lib/pcg/include/pcg/file_format/v1/datatype.h
+++ b/lib/pcg/include/pcg/file_format/v1/datatype.h
@@ -28,7 +28,10 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1DataType,
                               {V1DataType::DOUBLE, "DOUBLE"}});
 
 V1DataType to_v1(DataType const &d);
+DataType from_v1(V1DataType const &vd);
+
 V1DataTypeValue to_v1(DataTypeValue const &dv);
+DataTypeValue from_v1(V1DataTypeValue const &vdv);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/dim_ordered.h b/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
index 8b3e7bedf7..d175005c5a 100644
--- a/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
+++ b/lib/pcg/include/pcg/file_format/v1/dim_ordered.h
@@ -18,12 +18,18 @@ struct V1DimOrdered {
 template <typename Idx, typename T>
 V1DimOrdered<Idx, T> to_v1(DimOrdered<Idx, T> const &dim);
 
+template <typename Idx, typename T>
+DimOrdered<Idx, T> from_v1(V1DimOrdered<Idx, T> const &vdim);
+
 template <typename T>
 using V1FFOrdered = V1DimOrdered<ff_dim_t, T>;
 
 template <typename T>
 V1FFOrdered<T> to_v1(FFOrdered<T> const &o);
 
+template <typename T>
+FFOrdered<T> from_v1(V1FFOrdered<T> const &vo);
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/file_format/v1/ff_dim.h b/lib/pcg/include/pcg/file_format/v1/ff_dim.h
index 00e4491bea..8e84599024 100644
--- a/lib/pcg/include/pcg/file_format/v1/ff_dim.h
+++ b/lib/pcg/include/pcg/file_format/v1/ff_dim.h
@@ -8,6 +8,7 @@ namespace FlexFlow {
 // ff_dim_t is a strong typedef of int. This is unlikely to change, but if it
 // does, this signature will need to be updated.
 int to_v1(ff_dim_t const &t);
+ff_dim_t from_v1(int const &vt);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/graphs.h b/lib/pcg/include/pcg/file_format/v1/graphs.h
index 3628af7591..c243f6613e 100644
--- a/lib/pcg/include/pcg/file_format/v1/graphs.h
+++ b/lib/pcg/include/pcg/file_format/v1/graphs.h
@@ -39,9 +39,12 @@ FF_VISITABLE_STRUCT(V1MultiDiGraph, nodes, ports, edges);
 CHECK_IS_JSONABLE(V1MultiDiGraph);
 
 V1MultiDiGraph to_v1(MultiDiGraphView const &);
+// FIXME: Add a from_v1 for a MultiDiGraph.
+
 V1MultiDiGraph to_v1(MultiDiGraphView const &,
                      std::unordered_map<Node, size_t> const &,
                      std::unordered_map<NodePort, size_t> const &);
+// FIXME: Do we need to add an equivalent from_v1 for this?
 
 template <typename NodeT, typename TensorT>
 struct V1JsonableGraph {
@@ -61,6 +64,7 @@ struct V1Layer {
 FF_VISITABLE_STRUCT(V1Layer, attrs, name);
 
 V1Layer to_v1(Layer const &);
+Layer from_v1(V1Layer const &);
 
 using V1ComputationGraph = V1JsonableGraph<V1Layer, V1Tensor>;
 FF_VISITABLE_STRUCT(
@@ -68,6 +72,7 @@ FF_VISITABLE_STRUCT(
 CHECK_IS_JSONABLE(V1ComputationGraph);
 
 V1ComputationGraph to_v1(ComputationGraph const &);
+ComputationGraph from_V1(V1ComputationGraph const &);
 
 struct V1Operator {
   V1PCGOperatorAttrs attrs;
@@ -76,6 +81,7 @@ struct V1Operator {
 FF_VISITABLE_STRUCT(V1Operator, attrs, name);
 
 V1Operator to_v1(Operator const &);
+Operator from_v1(V1Operator const &);
 
 using V1ParallelComputationGraph =
     V1JsonableGraph<V1Operator, V1ParallelTensor>;
@@ -84,6 +90,7 @@ FF_VISITABLE_STRUCT(
 CHECK_IS_JSONABLE(V1ParallelComputationGraph);
 
 V1ParallelComputationGraph to_v1(ParallelComputationGraph const &);
+ParallelComputationGraph from_v1(V1ParallelComputationGraph const &);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/initializer.h b/lib/pcg/include/pcg/file_format/v1/initializer.h
index dc3eada212..08f001e7a7 100644
--- a/lib/pcg/include/pcg/file_format/v1/initializer.h
+++ b/lib/pcg/include/pcg/file_format/v1/initializer.h
@@ -18,11 +18,13 @@ FF_VISITABLE_STRUCT(V1GlorotInitializer, seed);
 CHECK_IS_JSONABLE(V1GlorotInitializer);
 
 V1GlorotInitializer to_v1(GlorotUniform const &i);
+GlorotUniform from_v1(V1GlorotInitializer const &vi);
 
 struct V1ZeroInitializer {};
 FF_VISITABLE_STRUCT(V1ZeroInitializer);
 
 V1ZeroInitializer to_v1(ZeroInitializer const &i);
+ZeroInitializer from_v1(V1ZeroInitializer const &vi);
 
 struct V1UniformInitializer {
   req<int> seed;
@@ -33,6 +35,7 @@ FF_VISITABLE_STRUCT(V1UniformInitializer, seed, min_val, max_val);
 CHECK_IS_JSONABLE(V1UniformInitializer);
 
 V1UniformInitializer to_v1(UniformInitializer const &i);
+UniformInitializer from_v1(V1UniformInitializer const &vi);
 
 struct V1NormInitializer {
   req<int> seed;
@@ -43,6 +46,7 @@ FF_VISITABLE_STRUCT(V1NormInitializer, seed, mean, stddev);
 CHECK_IS_JSONABLE(V1NormInitializer);
 
 V1NormInitializer to_v1(NormInitializer const &i);
+NormInitializer from_v1(V1NormInitializer const &vi);
 
 struct V1ConstantInitializer {
   req<V1DataTypeValue> value;
@@ -51,6 +55,7 @@ FF_VISITABLE_STRUCT(V1ConstantInitializer, value);
 CHECK_IS_JSONABLE(V1ConstantInitializer);
 
 V1ConstantInitializer to_v1(ConstantInitializer const &i);
+ConstantInitializer from_v1(V1ConstantInitializer const &vi);
 
 using V1Initializer = variant<V1GlorotInitializer,
                               V1ZeroInitializer,
@@ -58,7 +63,8 @@ using V1Initializer = variant<V1GlorotInitializer,
                               V1NormInitializer,
                               V1ConstantInitializer>;
 
-V1Initializer to_v1(Initializer const &);
+V1Initializer to_v1(Initializer const &i);
+Initializer from_v1(V1Initializer const &vi);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/op.h b/lib/pcg/include/pcg/file_format/v1/op.h
index ebd8decc12..e4010b10aa 100644
--- a/lib/pcg/include/pcg/file_format/v1/op.h
+++ b/lib/pcg/include/pcg/file_format/v1/op.h
@@ -186,6 +186,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1Op,
                               {V1Op::FUSED_PARALLEL, "FUSED_PARALLEL"}});
 
 V1Op to_v1(Op const &op);
+Op from_v1(V1Op const &vop);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
index fe63038426..71dd4e4ce6 100644
--- a/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
+++ b/lib/pcg/include/pcg/file_format/v1/operator_attrs.h
@@ -77,11 +77,14 @@ using V1ComputationGraphAttrs =
     variant_join<V1SharedOperatorAttrs, variant<V1BroadcastAttrs>>;
 using V1CompGraphOperatorAttrs = V1ComputationGraphAttrs;
 
+V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
+CompGraphOperatorAttrs from_v1(V1CompGraphOperatorAttrs const &attrs);
+
 using V1PCGOperatorAttrs =
     variant_join<V1SharedOperatorAttrs, V1ParallelOperatorAttrs>;
 
-V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs);
 V1PCGOperatorAttrs to_v1(PCGOperatorAttrs const &attrs);
+PCGOperatorAttrs from_v1(V1PCGOperatorAttrs const &attrs);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h b/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
index 8d75e49c26..f65350d70d 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/aggregate.h
@@ -14,7 +14,8 @@ struct V1AggregateAttrs {
 FF_VISITABLE_STRUCT(V1AggregateAttrs, n, lambda_bal);
 CHECK_IS_JSONABLE(V1AggregateAttrs);
 
-V1AggregateAttrs to_v1(AggregateAttrs const &attrs);
+V1AggregateAttrs to_v1(AggregateAttrs const &a);
+AggregateAttrs from_v1(V1AggregateAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h b/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h
index 294e395568..1ad7c823bb 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/aggregate_spec.h
@@ -14,7 +14,8 @@ struct V1AggregateSpecAttrs {
 FF_VISITABLE_STRUCT(V1AggregateSpecAttrs, n, lambda_bal);
 CHECK_IS_JSONABLE(V1AggregateSpecAttrs);
 
-V1AggregateSpecAttrs to_v1(AggregateSpecAttrs const &attrs);
+V1AggregateSpecAttrs to_v1(AggregateSpecAttrs const &a);
+AggregateSpecAttrs from_v1(V1AggregateSpecAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/attention.h b/lib/pcg/include/pcg/file_format/v1/ops/attention.h
index 2c5b298fb8..25e66e7813 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/attention.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/attention.h
@@ -22,7 +22,8 @@ FF_VISITABLE_STRUCT(V1MultiHeadAttentionAttrs,
                     add_zero_attn);
 CHECK_IS_JSONABLE(V1MultiHeadAttentionAttrs);
 
-V1MultiHeadAttentionAttrs to_v1(MultiHeadAttentionAttrs const &attrs);
+V1MultiHeadAttentionAttrs to_v1(MultiHeadAttentionAttrs const &a);
+MultiHeadAttentionAttrs from_v1(V1MultiHeadAttentionAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h b/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h
index c7a9b8fd69..744cebba52 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/batch_matmul.h
@@ -12,7 +12,8 @@ struct V1BatchMatmulAttrs {
 FF_VISITABLE_STRUCT(V1BatchMatmulAttrs, a_seq_length_dim, b_seq_length_dim);
 CHECK_IS_JSONABLE(V1BatchMatmulAttrs);
 
-V1BatchMatmulAttrs to_v1(BatchMatmulAttrs const &attrs);
+V1BatchMatmulAttrs to_v1(BatchMatmulAttrs const &a);
+BatchMatmulAttrs from_v1(V1BatchMatmulAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h b/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h
index 89f611bd4d..b78fc8eace 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/batch_norm.h
@@ -12,7 +12,8 @@ struct V1BatchNormAttrs {
 FF_VISITABLE_STRUCT(V1BatchNormAttrs, relu);
 CHECK_IS_JSONABLE(V1BatchNormAttrs);
 
-V1BatchNormAttrs to_v1(BatchNormAttrs const &attrs);
+V1BatchNormAttrs to_v1(BatchNormAttrs const &a);
+BatchNormAttrs from_v1(V1BatchNormAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
index 7f7cfa3e02..cb5b25bf12 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/broadcast.h
@@ -14,7 +14,8 @@ struct V1BroadcastAttrs {
 FF_VISITABLE_STRUCT(V1BroadcastAttrs, target_dims);
 CHECK_IS_JSONABLE(V1BroadcastAttrs);
 
-V1BroadcastAttrs to_v1(BroadcastAttrs const &attrs);
+V1BroadcastAttrs to_v1(BroadcastAttrs const &a);
+BroadcastAttrs from_v1(V1BroadcastAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/cast.h b/lib/pcg/include/pcg/file_format/v1/ops/cast.h
index 09035e5240..54a343ef6d 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/cast.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/cast.h
@@ -14,7 +14,8 @@ struct V1CastAttrs {
 FF_VISITABLE_STRUCT(V1CastAttrs, dtype);
 CHECK_IS_JSONABLE(V1CastAttrs);
 
-V1CastAttrs to_v1(CastAttrs const &attrs);
+V1CastAttrs to_v1(CastAttrs const &a);
+CastAttrs from_v1(V1CastAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/combine.h b/lib/pcg/include/pcg/file_format/v1/ops/combine.h
index d120f17b95..a029aa72c8 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/combine.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/combine.h
@@ -13,7 +13,8 @@ struct V1CombineAttrs {
 FF_VISITABLE_STRUCT(V1CombineAttrs, combine_dim, combine_degree);
 CHECK_IS_JSONABLE(V1CombineAttrs);
 
-V1CombineAttrs to_v1(CombineAttrs const &attrs);
+V1CombineAttrs to_v1(CombineAttrs const &a);
+CombineAttrs from_v1(V1CombineAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/concat.h b/lib/pcg/include/pcg/file_format/v1/ops/concat.h
index 0c498667b6..a3d657ea33 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/concat.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/concat.h
@@ -13,7 +13,8 @@ struct V1ConcatAttrs {
 FF_VISITABLE_STRUCT(V1ConcatAttrs, axis);
 CHECK_IS_JSONABLE(V1ConcatAttrs);
 
-V1ConcatAttrs to_v1(ConcatAttrs const &attrs);
+V1ConcatAttrs to_v1(ConcatAttrs const &a);
+ConcatAttrs from_v1(V1ConcatAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h b/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
index 6d047a3bd7..1d6b7fc7c7 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/conv_2d.h
@@ -27,7 +27,8 @@ FF_VISITABLE_STRUCT(V1Conv2DAttrs,
                     use_bias);
 CHECK_IS_JSONABLE(V1Conv2DAttrs);
 
-V1Conv2DAttrs to_v1(Conv2DAttrs const &attrs);
+V1Conv2DAttrs to_v1(Conv2DAttrs const &a);
+Conv2DAttrs from_v1(V1Conv2DAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/dropout.h b/lib/pcg/include/pcg/file_format/v1/ops/dropout.h
index 5d0eace907..73641d7a78 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/dropout.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/dropout.h
@@ -13,7 +13,8 @@ struct V1DropoutAttrs {
 FF_VISITABLE_STRUCT(V1DropoutAttrs, rate, seed);
 CHECK_IS_JSONABLE(V1DropoutAttrs);
 
-V1DropoutAttrs to_v1(DropoutAttrs const &attrs);
+V1DropoutAttrs to_v1(DropoutAttrs const &a);
+DropoutAttrs from_v1(V1DropoutAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h b/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
index 197c06ccbc..a22aadc370 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/element_binary.h
@@ -21,7 +21,8 @@ FF_VISITABLE_STRUCT(V1ElementBinaryAttrs,
                     should_broadcast_rhs);
 CHECK_IS_JSONABLE(V1ElementBinaryAttrs);
 
-V1ElementBinaryAttrs to_v1(ElementBinaryAttrs const &attrs);
+V1ElementBinaryAttrs to_v1(ElementBinaryAttrs const &a);
+ElementBinaryAttrs from_v1(V1ElementBinaryAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h b/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
index 1623f84d7f..46ac27921a 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/element_unary.h
@@ -14,7 +14,8 @@ struct V1ElementScalarUnaryAttrs {
 FF_VISITABLE_STRUCT(V1ElementScalarUnaryAttrs, op, scalar);
 CHECK_IS_JSONABLE(V1ElementScalarUnaryAttrs);
 
-V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &attrs);
+V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &a);
+ElementScalarUnaryAttrs from_v1(V1ElementScalarUnaryAttrs const &va);
 
 struct V1ElementUnaryAttrs {
   req<V1Op> op;
@@ -22,7 +23,8 @@ struct V1ElementUnaryAttrs {
 FF_VISITABLE_STRUCT(V1ElementUnaryAttrs, op);
 CHECK_IS_JSONABLE(V1ElementUnaryAttrs);
 
-V1ElementUnaryAttrs to_v1(ElementUnaryAttrs const &attrs);
+V1ElementUnaryAttrs to_v1(ElementUnaryAttrs const &a);
+ElementUnaryAttrs from_v1(V1ElementUnaryAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/embedding.h b/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
index 8d7cdc5dfd..8f1299b0e1 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/embedding.h
@@ -17,6 +17,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1AggregateOp,
                               {V1AggregateOp::AVG, "AVG"}});
 
 V1AggregateOp to_v1(AggregateOp const &op);
+AggregateOp from_v1(V1AggregateOp const &vop);
 
 struct V1EmbeddingAttrs {
   req<int> num_entries, out_channels;
@@ -27,7 +28,8 @@ FF_VISITABLE_STRUCT(
     V1EmbeddingAttrs, num_entries, out_channels, aggr, data_type);
 CHECK_IS_JSONABLE(V1EmbeddingAttrs);
 
-V1EmbeddingAttrs to_v1(EmbeddingAttrs const &attrs);
+V1EmbeddingAttrs to_v1(EmbeddingAttrs const &a);
+EmbeddingAttrs from_v1(V1EmbeddingAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/flat.h b/lib/pcg/include/pcg/file_format/v1/ops/flat.h
index 999d0c5473..e736b992ed 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/flat.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/flat.h
@@ -10,7 +10,8 @@ struct V1FlatAttrs {};
 FF_VISITABLE_STRUCT(V1FlatAttrs);
 CHECK_IS_JSONABLE(V1FlatAttrs);
 
-V1FlatAttrs to_v1(FlatAttrs const &attrs);
+V1FlatAttrs to_v1(FlatAttrs const &a);
+FlatAttrs from_v1(V1FlatAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/gather.h b/lib/pcg/include/pcg/file_format/v1/ops/gather.h
index 1266bc04df..22944893ba 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/gather.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/gather.h
@@ -12,7 +12,8 @@ struct V1GatherAttrs {
 FF_VISITABLE_STRUCT(V1GatherAttrs, dim);
 CHECK_IS_JSONABLE(V1GatherAttrs);
 
-V1GatherAttrs to_v1(GatherAttrs const &attrs);
+V1GatherAttrs to_v1(GatherAttrs const &a);
+GatherAttrs from_v1(V1GatherAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/groupby.h b/lib/pcg/include/pcg/file_format/v1/ops/groupby.h
index 76dfe7bd48..01b17876fe 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/groupby.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/groupby.h
@@ -13,7 +13,8 @@ struct V1Group_byAttrs {
 FF_VISITABLE_STRUCT(V1Group_byAttrs, n, alpha);
 CHECK_IS_JSONABLE(V1Group_byAttrs);
 
-V1Group_byAttrs to_v1(Group_byAttrs const &attrs);
+V1Group_byAttrs to_v1(Group_byAttrs const &a);
+Group_byAttrs from_v1(V1Group_byAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/input.h b/lib/pcg/include/pcg/file_format/v1/ops/input.h
index 2c831b2979..41cb178c84 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/input.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/input.h
@@ -11,7 +11,8 @@ struct V1InputAttrs {};
 FF_VISITABLE_STRUCT(V1InputAttrs);
 CHECK_IS_JSONABLE(V1InputAttrs);
 
-V1InputAttrs to_v1(InputAttrs const &attrs);
+V1InputAttrs to_v1(InputAttrs const &a);
+InputAttrs from_v1(V1InputAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h b/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
index 2abd046af1..15acc64b0c 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/layer_norm.h
@@ -16,7 +16,8 @@ struct V1LayerNormAttrs {
 FF_VISITABLE_STRUCT(V1LayerNormAttrs, axes, elementwise_affine, eps);
 CHECK_IS_JSONABLE(V1LayerNormAttrs);
 
-V1LayerNormAttrs to_v1(LayerNormAttrs const &attrs);
+V1LayerNormAttrs to_v1(LayerNormAttrs const &a);
+LayerNormAttrs from_v1(V1LayerNormAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/linear.h b/lib/pcg/include/pcg/file_format/v1/ops/linear.h
index 3a5c8f14a4..6b28f6fd95 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/linear.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/linear.h
@@ -14,7 +14,8 @@ struct V1L1RegularizerAttrs {
 FF_VISITABLE_STRUCT(V1L1RegularizerAttrs, lambda);
 CHECK_IS_JSONABLE(V1L1RegularizerAttrs);
 
-V1L1RegularizerAttrs to_v1(L1RegularizerAttrs const &attrs);
+V1L1RegularizerAttrs to_v1(L1RegularizerAttrs const &a);
+L1RegularizerAttrs from_v1(V1L1RegularizerAttrs const &va);
 
 struct V1L2RegularizerAttrs {
   req<float> lambda;
@@ -22,10 +23,14 @@ struct V1L2RegularizerAttrs {
 FF_VISITABLE_STRUCT(V1L2RegularizerAttrs, lambda);
 CHECK_IS_JSONABLE(V1L2RegularizerAttrs);
 
-V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &attrs);
+V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &a);
+L2RegularizerAttrs from_v1(V1L2RegularizerAttrs const &va);
 
 using V1RegularizerAttrs = variant<V1L1RegularizerAttrs, V1L2RegularizerAttrs>;
-V1RegularizerAttrs to_v1(RegularizerAttrs const &);
+CHECK_IS_JSONABLE(V1RegularizerAttrs);
+
+V1RegularizerAttrs to_v1(RegularizerAttrs const &a);
+RegularizerAttrs from_v1(V1RegularizerAttrs const &va);
 
 struct V1LinearAttrs {
   req<int> out_channels;
@@ -38,7 +43,8 @@ FF_VISITABLE_STRUCT(
     V1LinearAttrs, out_channels, use_bias, data_type, activation, regularizer);
 CHECK_IS_JSONABLE(V1LinearAttrs);
 
-V1LinearAttrs to_v1(LinearAttrs const &attrs);
+V1LinearAttrs to_v1(LinearAttrs const &a);
+LinearAttrs from_v1(V1LinearAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/noop.h b/lib/pcg/include/pcg/file_format/v1/ops/noop.h
index dbdbaa18ad..de313467f7 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/noop.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/noop.h
@@ -11,7 +11,8 @@ struct V1NoopAttrs {};
 FF_VISITABLE_STRUCT(V1NoopAttrs);
 CHECK_IS_JSONABLE(NoopAttrs);
 
-V1NoopAttrs to_v1(NoopAttrs const &attrs);
+V1NoopAttrs to_v1(NoopAttrs const &a);
+NoopAttrs from_v1(V1NoopAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h b/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
index fd6a2c7b0f..0777f9e496 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/pool_2d.h
@@ -17,6 +17,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1PoolOp,
                              {{V1PoolOp::MAX, "MAX"}, {V1PoolOp::AVG, "AVG"}});
 
 V1PoolOp to_v1(PoolOp const &op);
+PoolOp from_v1(V1PoolOp const &vop);
 
 struct V1Pool2DAttrs {
   req<int> kernel_h, kernel_w, stride_h, stride_w, padding_h, padding_w;
@@ -34,7 +35,8 @@ FF_VISITABLE_STRUCT(V1Pool2DAttrs,
                     activation);
 CHECK_IS_JSONABLE(V1Pool2DAttrs);
 
-V1Pool2DAttrs to_v1(Pool2DAttrs const &attrs);
+V1Pool2DAttrs to_v1(Pool2DAttrs const &a);
+Pool2DAttrs from_v1(V1Pool2DAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reduce.h b/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
index c675c65725..fbbaeb6594 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reduce.h
@@ -17,7 +17,8 @@ struct V1ReduceAttrs {
 FF_VISITABLE_STRUCT(V1ReduceAttrs, axes, op_type, keepdims);
 CHECK_IS_JSONABLE(V1ReduceAttrs);
 
-V1ReduceAttrs to_v1(ReduceAttrs const &attrs);
+V1ReduceAttrs to_v1(ReduceAttrs const &a);
+ReduceAttrs from_v1(V1ReduceAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reduction.h b/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
index cfc012fdf5..9afe9e9cfd 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reduction.h
@@ -14,7 +14,8 @@ struct V1ReductionAttrs {
 FF_VISITABLE_STRUCT(V1ReductionAttrs, reduction_dim, reduction_degree);
 CHECK_IS_JSONABLE(V1ReductionAttrs);
 
-V1ReductionAttrs to_v1(ReductionAttrs const &attrs);
+V1ReductionAttrs to_v1(ReductionAttrs const &a);
+ReductionAttrs from_v1(V1ReductionAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/repartition.h b/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
index de46e6a69c..f1aa75ed54 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/repartition.h
@@ -14,7 +14,8 @@ struct V1RepartitionAttrs {
 FF_VISITABLE_STRUCT(V1RepartitionAttrs, repartition_dim, repartition_degree);
 CHECK_IS_JSONABLE(V1RepartitionAttrs);
 
-V1RepartitionAttrs to_v1(RepartitionAttrs const &attrs);
+V1RepartitionAttrs to_v1(RepartitionAttrs const &a);
+RepartitionAttrs from_v1(V1RepartitionAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/replicate.h b/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
index 21046b2cac..6175a28074 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/replicate.h
@@ -14,7 +14,8 @@ struct V1ReplicateAttrs {
 FF_VISITABLE_STRUCT(V1ReplicateAttrs, replicate_dim, replicate_degree);
 CHECK_IS_JSONABLE(V1ReplicateAttrs);
 
-V1ReplicateAttrs to_v1(ReplicateAttrs const &attrs);
+V1ReplicateAttrs to_v1(ReplicateAttrs const &a);
+ReplicateAttrs from_v1(V1ReplicateAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reshape.h b/lib/pcg/include/pcg/file_format/v1/ops/reshape.h
index 64ef15e19f..1e2b289945 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reshape.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reshape.h
@@ -13,7 +13,8 @@ struct V1ReshapeAttrs {
 FF_VISITABLE_STRUCT(V1ReshapeAttrs, shape);
 CHECK_IS_JSONABLE(V1ReshapeAttrs);
 
-V1ReshapeAttrs to_v1(ReshapeAttrs const &attrs);
+V1ReshapeAttrs to_v1(ReshapeAttrs const &a);
+ReshapeAttrs from_v1(V1ReshapeAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/reverse.h b/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
index 4c03b85933..5dfab7f8c9 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/reverse.h
@@ -14,7 +14,8 @@ struct V1ReverseAttrs {
 FF_VISITABLE_STRUCT(V1ReverseAttrs, axis);
 CHECK_IS_JSONABLE(V1ReverseAttrs);
 
-V1ReverseAttrs to_v1(ReverseAttrs const &);
+V1ReverseAttrs to_v1(ReverseAttrs const &a);
+ReverseAttrs from_v1(V1ReverseAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/softmax.h b/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
index 193c9ca09f..1c7fc94326 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/softmax.h
@@ -12,7 +12,8 @@ struct V1SoftmaxAttrs {
 FF_VISITABLE_STRUCT(V1SoftmaxAttrs, dim);
 CHECK_IS_JSONABLE(V1SoftmaxAttrs);
 
-V1SoftmaxAttrs to_v1(SoftmaxAttrs const &attrs);
+V1SoftmaxAttrs to_v1(SoftmaxAttrs const &a);
+SoftmaxAttrs from_v1(V1SoftmaxAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/split.h b/lib/pcg/include/pcg/file_format/v1/ops/split.h
index 658ca92149..cfd5e92d08 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/split.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/split.h
@@ -14,7 +14,8 @@ struct V1SplitAttrs {
 FF_VISITABLE_STRUCT(V1SplitAttrs, splits, axis);
 CHECK_IS_JSONABLE(V1SplitAttrs);
 
-V1SplitAttrs to_v1(SplitAttrs const &attrs);
+V1SplitAttrs to_v1(SplitAttrs const &a);
+SplitAttrs from_v1(V1SplitAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/topk.h b/lib/pcg/include/pcg/file_format/v1/ops/topk.h
index f5473e4082..b02037c4dd 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/topk.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/topk.h
@@ -13,7 +13,8 @@ struct V1TopKAttrs {
 FF_VISITABLE_STRUCT(V1TopKAttrs, k, sorted);
 CHECK_IS_JSONABLE(V1TopKAttrs);
 
-V1TopKAttrs to_v1(TopKAttrs const &attrs);
+V1TopKAttrs to_v1(TopKAttrs const &a);
+TopKAttrs from_v1(V1TopKAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/ops/transpose.h b/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
index c53dcf85e1..66e1a0c871 100644
--- a/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
+++ b/lib/pcg/include/pcg/file_format/v1/ops/transpose.h
@@ -14,7 +14,8 @@ struct V1TransposeAttrs {
 FF_VISITABLE_STRUCT(V1TransposeAttrs, perm);
 CHECK_IS_JSONABLE(V1TransposeAttrs);
 
-V1TransposeAttrs to_v1(TransposeAttrs const &attrs);
+V1TransposeAttrs to_v1(TransposeAttrs const &a);
+TransposeAttrs from_v1(V1TransposeAttrs const &va);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_dim.h b/lib/pcg/include/pcg/file_format/v1/parallel_dim.h
index 6f9ff73ff6..7f035f326f 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_dim.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_dim.h
@@ -16,6 +16,7 @@ FF_VISITABLE_STRUCT(V1ParallelDim, size, degree, is_replica_dim);
 CHECK_IS_JSONABLE(V1ParallelDim);
 
 V1ParallelDim to_v1(ParallelDim const &dim);
+ParallelDim from_v1(V1ParallelDim const &vdim);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
index f917dc2198..bef2188ca6 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor.h
@@ -4,6 +4,8 @@
 #include "create_grad.h"
 #include "datatype.h"
 #include "initializer.h"
+#include "parallel_tensor_dims.h"
+#include "parallel_tensor_shape.h"
 #include "param_sync.h"
 #include "pcg/parallel_tensor.h"
 #include "utils/json.h"
@@ -12,25 +14,6 @@
 
 namespace FlexFlow {
 
-struct V1ParallelDim {
-  req<size_t> size;
-  req<int> degree;
-  req<bool> is_replica_dim;
-};
-FF_VISITABLE_STRUCT(V1ParallelDim, size, degree, is_replica_dim);
-CHECK_IS_JSONABLE(V1ParallelDim);
-
-V1ParallelDim to_v1(ParallelDim const &);
-
-struct V1ParallelTensorShape {
-  req<std::vector<V1ParallelDim>> dims;
-  req<V1DataType> data_type;
-};
-FF_VISITABLE_STRUCT(V1ParallelTensorShape, dims, data_type);
-CHECK_IS_JSONABLE(V1ParallelTensorShape);
-
-V1ParallelTensorShape to_v1(ParallelTensorShape const &);
-
 struct V1ParallelTensor {
   V1ParallelTensorShape shape;
   req<V1CreateGrad> create_gradients;
@@ -42,7 +25,8 @@ FF_VISITABLE_STRUCT(
     V1ParallelTensor, shape, create_gradients, initializer, sync_type, name);
 CHECK_IS_JSONABLE(V1ParallelTensor);
 
-V1ParallelTensor to_v1(ParallelTensor const &);
+V1ParallelTensor to_v1(ParallelTensor const &t);
+ParallelTensor from_v1(V1ParallelTensor const &vt);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h
index b17a2e9285..c4a44bf968 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_dims.h
@@ -8,12 +8,13 @@
 namespace FlexFlow {
 
 struct V1ParallelTensorDims {
-  req<FFOrdered<V1ParallelDim>> data;
+  req<std::vector<V1ParallelDim>> data;
 };
 FF_VISITABLE_STRUCT(V1ParallelTensorDims, data);
 CHECK_IS_JSONABLE(V1ParallelTensorDims);
 
 V1ParallelTensorDims to_v1(ParallelTensorDims const &dims);
+ParallelTensorDims from_v1(V1ParallelTensorDims const &vdims);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h
index 6e39315538..efad97279c 100644
--- a/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h
+++ b/lib/pcg/include/pcg/file_format/v1/parallel_tensor_shape.h
@@ -10,12 +10,13 @@ namespace FlexFlow {
 
 struct V1ParallelTensorShape {
   V1ParallelTensorDims dims;
-  V1DataType data_type;
+  req<V1DataType> data_type;
 };
 FF_VISITABLE_STRUCT(V1ParallelTensorShape, dims, data_type);
 CHECK_IS_JSONABLE(V1ParallelTensorShape);
 
 V1ParallelTensorShape to_v1(ParallelTensorShape const &t);
+ParallelTensorShape from_v1(V1ParallelTensorShape const &vt);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/param_sync.h b/lib/pcg/include/pcg/file_format/v1/param_sync.h
index d97a9d21b4..e18cc15397 100644
--- a/lib/pcg/include/pcg/file_format/v1/param_sync.h
+++ b/lib/pcg/include/pcg/file_format/v1/param_sync.h
@@ -12,7 +12,8 @@ NLOHMANN_JSON_SERIALIZE_ENUM(V1ParamSync,
                              {{V1ParamSync::PARAM_SERVER, "PARAM_SERVER"},
                               {V1ParamSync::NCCL, "NCCL"}});
 
-V1ParamSync to_v1(ParamSync const &);
+V1ParamSync to_v1(ParamSync const &p);
+ParamSync from_v1(V1ParamSync const &vp);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor.h b/lib/pcg/include/pcg/file_format/v1/tensor.h
index bc8903c78c..f0311cd718 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor.h
@@ -22,6 +22,7 @@ FF_VISITABLE_STRUCT(
 CHECK_IS_JSONABLE(V1Tensor);
 
 V1Tensor to_v1(Tensor const &);
+Tensor from_v1(V1Tensor const &);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
index 4bc6895ea7..edab0faaab 100644
--- a/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
+++ b/lib/pcg/include/pcg/file_format/v1/tensor_shape.h
@@ -7,15 +7,19 @@
 
 namespace FlexFlow {
 
+using V1TensorDims = std::vector<size_t>;
+V1TensorDims from_v1(std::vector<size_t> const &dims);
+
 struct V1TensorShape {
 public:
-  req<std::vector<size_t>> dims;
+  std::vector<size_t> dims;
   req<V1DataType> data_type;
 };
 FF_VISITABLE_STRUCT(V1TensorShape, dims, data_type);
 CHECK_IS_JSONABLE(V1TensorShape);
 
 V1TensorShape to_v1(TensorShape const &t);
+TensorShape from_v1(V1TensorShape const &vt);
 
 } // namespace FlexFlow
 
diff --git a/lib/pcg/include/pcg/file_format/v1/v1.h b/lib/pcg/include/pcg/file_format/v1/v1.h
index 780b008970..7673fe0611 100644
--- a/lib/pcg/include/pcg/file_format/v1/v1.h
+++ b/lib/pcg/include/pcg/file_format/v1/v1.h
@@ -12,7 +12,14 @@ T to_v1(T const &t) {
   return t;
 }
 
+template <typename T,
+          typename std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+T from_v1(T const &vt) {
+  return vt;
+}
+
 std::string to_v1(std::string const &s);
+std::string from_v1(std::string const &vs);
 
 template <typename V1T, typename T>
 optional<V1T> to_v1(optional<T> const &t) {
@@ -23,6 +30,15 @@ optional<V1T> to_v1(optional<T> const &t) {
   }
 }
 
+template <typename T, typename V1T>
+optional<T> from_v1(optional<V1T> const &vt) {
+  if (vt.has_value()) {
+    return from_v1(vt.value());
+  } else {
+    return nullopt;
+  }
+}
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/pcg/include/pcg/parallel_tensor.h b/lib/pcg/include/pcg/parallel_tensor.h
index fa3faae999..2dac62bf8f 100644
--- a/lib/pcg/include/pcg/parallel_tensor.h
+++ b/lib/pcg/include/pcg/parallel_tensor.h
@@ -46,16 +46,16 @@ struct ParallelTensor {
   ParallelTensorDims dims;
   DataType data_type;
   CreateGrad create_gradients;
-  req<optional<ParamSync>> sync_type;
   req<optional<Initializer>> initializer;
+  req<optional<ParamSync>> sync_type;
   req<optional<std::string>> name;
 };
 FF_VISITABLE_STRUCT(ParallelTensor,
                     dims,
                     data_type,
                     create_gradients,
-                    sync_type,
                     initializer,
+                    sync_type,
                     name);
 
 using ParallelParameter = ParallelTensor;
diff --git a/lib/pcg/src/computation_graph_builder.cc b/lib/pcg/src/computation_graph_builder.cc
index fae0829e60..cc1f47b68d 100644
--- a/lib/pcg/src/computation_graph_builder.cc
+++ b/lib/pcg/src/computation_graph_builder.cc
@@ -310,12 +310,15 @@ std::vector<Tensor>
   return this->add_layer(layer, {input}, {}, output_shapes);
 }
 
-TensorShape get_shape(Tensor const &) {
-  NOT_IMPLEMENTED();
+TensorShape get_shape(Tensor const &t) {
+  return t.get_shape();
 }
 
-std::vector<TensorShape> get_shape(std::vector<Tensor> const &) {
-  NOT_IMPLEMENTED();
+std::vector<TensorShape> get_shape(std::vector<Tensor> const &ts) {
+  std::vector<TensorShape> shps;
+  for (const Tensor& t : ts)
+    shps.emplace_back(t.get_shape());
+  return shps;
 }
 
 Tensor ComputationGraphBuilder::aggregate(
diff --git a/lib/pcg/src/file_format/v1/activation.cc b/lib/pcg/src/file_format/v1/activation.cc
index e6a7da9dcb..2b35f53d01 100644
--- a/lib/pcg/src/file_format/v1/activation.cc
+++ b/lib/pcg/src/file_format/v1/activation.cc
@@ -18,4 +18,19 @@ V1Activation to_v1(Activation const &a) {
   }
 }
 
+Activation from_v1(V1Activation const &va) {
+  switch (va) {
+    case V1Activation::RELU:
+      return Activation::RELU;
+    case V1Activation::SIGMOID:
+      return Activation::SIGMOID;
+    case V1Activation::TANH:
+      return Activation::TANH;
+    case V1Activation::GELU:
+      return Activation::GELU;
+    default:
+      NOT_REACHABLE();
+  }
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/create_grad.cc b/lib/pcg/src/file_format/v1/create_grad.cc
index 70adfecfcf..00dbf0ced8 100644
--- a/lib/pcg/src/file_format/v1/create_grad.cc
+++ b/lib/pcg/src/file_format/v1/create_grad.cc
@@ -14,4 +14,15 @@ V1CreateGrad to_v1(CreateGrad const &cg) {
   }
 }
 
+CreateGrad from_v1(V1CreateGrad const &vcg) {
+  switch (vcg) {
+    case V1CreateGrad::YES:
+      return CreateGrad::YES;
+    case V1CreateGrad::NO:
+      return CreateGrad::NO;
+    default:
+      NOT_REACHABLE();
+  }
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/datatype.cc b/lib/pcg/src/file_format/v1/datatype.cc
index d0d5ffe7c3..6b5c644f86 100644
--- a/lib/pcg/src/file_format/v1/datatype.cc
+++ b/lib/pcg/src/file_format/v1/datatype.cc
@@ -16,31 +16,74 @@ V1DataType to_v1(DataType const &dt) {
       return V1DataType::FLOAT;
     case DataType::DOUBLE:
       return V1DataType::DOUBLE;
-  default:
-    // Should never get here unless a new element was added to the DataType enum
-    // that was not handled here.
-    NOT_REACHABLE();
+    default:
+      // Should never get here unless a new element was added to the DataType
+      // enum that was not handled here.
+      NOT_REACHABLE();
+  }
+}
+
+DataType from_v1(V1DataType const &vdt) {
+  switch (vdt) {
+    case V1DataType::BOOL:
+      return DataType::BOOL;
+    case V1DataType::INT32:
+      return DataType::INT32;
+    case V1DataType::INT64:
+      return DataType::INT64;
+    case V1DataType::HALF:
+      return DataType::HALF;
+    case V1DataType::FLOAT:
+      return DataType::FLOAT;
+    case V1DataType::DOUBLE:
+      return DataType::DOUBLE;
+    default:
+      // Should never get here unless a new element was added to the DataType
+      // enum that was not handled here.
+      NOT_REACHABLE();
   }
 }
 
 V1DataTypeValue to_v1(DataTypeValue const &dv) {
   // There has to be a better way of doing this.
-  if (const auto* b = get_if<bool>(&dv))
+  if (auto const *b = get_if<bool>(&dv)) {
+    return *b;
+  } else if (auto const *i32 = get_if<int32_t>(&dv)) {
+    return *i32;
+  } else if (auto const *i64 = get_if<int64_t>(&dv)) {
+    return *i64;
+  } else if (auto const *flt = get_if<float>(&dv)) {
+    return *flt;
+  } else if (auto const *dbl = get_if<double>(&dv)) {
+    return *dbl;
+  } else if (auto const *hlf = get_if<half>(&dv)) {
+    return *hlf;
+  } else {
+    // Should never get here unless a new type was added into the DataTypeValue
+    // variant which was not handled here.
+    NOT_REACHABLE();
+  }
+}
+
+DataTypeValue from_v1(V1DataTypeValue const &vdv) {
+  // There has to be a better way of doing this.
+  if (auto const *b = get_if<bool>(&vdv)) {
     return *b;
-  else if (const auto* i32 = get_if<int32_t>(&dv))
+  } else if (auto const *i32 = get_if<int32_t>(&vdv)) {
     return *i32;
-  else if (const auto* i64 = get_if<int64_t>(&dv))
+  } else if (auto const *i64 = get_if<int64_t>(&vdv)) {
     return *i64;
-  else if (const auto* flt = get_if<float>(&dv))
+  } else if (auto const *flt = get_if<float>(&vdv)) {
     return *flt;
-  else if (const auto* dbl = get_if<double>(&dv))
+  } else if (auto const *dbl = get_if<double>(&vdv)) {
     return *dbl;
-  else if (const auto* hlf = get_if<half>(&dv))
+  } else if (auto const *hlf = get_if<half>(&vdv)) {
     return *hlf;
-  else
+  } else {
     // Should never get here unless a new type was added into the DataTypeValue
     // variant which was not handled here.
     NOT_REACHABLE();
+  }
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ff_dim.cc b/lib/pcg/src/file_format/v1/ff_dim.cc
index 2cea18f62a..c0627d7fbb 100644
--- a/lib/pcg/src/file_format/v1/ff_dim.cc
+++ b/lib/pcg/src/file_format/v1/ff_dim.cc
@@ -6,4 +6,8 @@ int to_v1(ff_dim_t const &t) {
   return t.value();
 }
 
+ff_dim_t from_v1(int const &vt) {
+  return ff_dim_t(vt);
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/graphs.cc b/lib/pcg/src/file_format/v1/graphs.cc
index ffc473c2da..13ea1124c3 100644
--- a/lib/pcg/src/file_format/v1/graphs.cc
+++ b/lib/pcg/src/file_format/v1/graphs.cc
@@ -7,10 +7,18 @@ V1Operator to_v1(Operator const &op) {
   return {to_v1(op.attrs), op.name};
 }
 
+Operator from_v1(V1Operator const &vop) {
+  return {from_v1(vop.attrs), vop.name};
+}
+
 V1Layer to_v1(Layer const &l) {
   return {to_v1(l.attrs), l.name};
 }
 
+Layer from_v1(V1Layer const &vl) {
+  return {from_v1(vl.attrs), vl.name};
+}
+
 V1MultiDiGraph to_v1(MultiDiGraphView const &g) {
   return to_v1(g,
                enumerate(get_nodes(g)).reversed(),
@@ -63,8 +71,16 @@ V1ComputationGraph to_v1(ComputationGraph const &g) {
   return to_v1<Layer, Tensor>(g.value());
 }
 
+ComputationGraph from_v1(V1ComputationGraph const &vg) {
+  NOT_IMPLEMENTED();
+}
+
 V1ParallelComputationGraph to_v1(ParallelComputationGraph const &g) {
   return to_v1<Operator, ParallelTensor>(g.value());
 }
 
+ParallelComputationGraph from_v1(V1ParallelComputationGraph const &vg) {
+  NOT_IMPLEMENTED();
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/initializer.cc b/lib/pcg/src/file_format/v1/initializer.cc
index cf26123409..c06f689ccd 100644
--- a/lib/pcg/src/file_format/v1/initializer.cc
+++ b/lib/pcg/src/file_format/v1/initializer.cc
@@ -6,38 +6,78 @@ V1GlorotInitializer to_v1(GlorotUniform const &i) {
   return {i.seed};
 }
 
+GlorotUniform from_v1(V1GlorotInitializer const &vi) {
+  return {vi.seed};
+}
+
 V1ZeroInitializer to_v1(ZeroInitializer const &i) {
   return {
       // No fields in ZeroInitializer.
   };
 }
 
+ZeroInitializer from_v1(V1ZeroInitializer const &vi) {
+  return {
+      // No fields in V1ZeroInitializer
+  };
+}
+
 V1UniformInitializer to_v1(UniformInitializer const &i) {
   return {i.seed, i.min_val, i.max_val};
 }
 
+UniformInitializer from_v1(V1UniformInitializer const &vi) {
+  return {vi.seed, vi.min_val, vi.max_val};
+}
+
 V1NormInitializer to_v1(NormInitializer const &i) {
   return {i.seed, i.mean, i.stddev};
 }
 
+NormInitializer from_v1(V1NormInitializer const &vi) {
+  return {vi.seed, vi.mean, vi.stddev};
+}
+
 V1ConstantInitializer to_v1(ConstantInitializer const &i) {
   return {to_v1(i.value)};
 }
 
+ConstantInitializer from_v1(V1ConstantInitializer const &vi) {
+  return {from_v1(vi.value)};
+}
+
 V1Initializer to_v1(Initializer const &i) {
   // There is surely a better way of doing this ...
-  if (const auto* glorot = get_if<GlorotUniform>(&i))
+  if (auto const *glorot = get_if<GlorotUniform>(&i)) {
     return to_v1(*glorot);
-  else if (const auto* zero = get_if<ZeroInitializer>(&i))
+  } else if (auto const *zero = get_if<ZeroInitializer>(&i)) {
     return to_v1(*zero);
-  else if (const auto* uniform = get_if<UniformInitializer>(&i))
+  } else if (auto const *uniform = get_if<UniformInitializer>(&i)) {
     return to_v1(*uniform);
-  else if (const auto* norm = get_if<NormInitializer>(&i))
+  } else if (auto const *norm = get_if<NormInitializer>(&i)) {
     return to_v1(*norm);
-  else if (const auto* constant = get_if<ConstantInitializer>(&i))
+  } else if (auto const *constant = get_if<ConstantInitializer>(&i)) {
     return to_v1(*constant);
-  else
+  } else {
+    NOT_REACHABLE();
+  }
+}
+
+Initializer from_v1(V1Initializer const &vi) {
+  // There is surely a better way of doing this ...
+  if (auto const *glorot = get_if<V1GlorotInitializer>(&vi)) {
+    return from_v1(*glorot);
+  } else if (auto const *zero = get_if<V1ZeroInitializer>(&vi)) {
+    return from_v1(*zero);
+  } else if (auto const *uniform = get_if<V1UniformInitializer>(&vi)) {
+    return from_v1(*uniform);
+  } else if (auto const *norm = get_if<V1NormInitializer>(&vi)) {
+    return from_v1(*norm);
+  } else if (auto const *constant = get_if<V1ConstantInitializer>(&vi)) {
+    return from_v1(*constant);
+  } else {
     NOT_REACHABLE();
+  }
 }
 
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/op.cc b/lib/pcg/src/file_format/v1/op.cc
index 4ef528a4c3..6f9fa1b591 100644
--- a/lib/pcg/src/file_format/v1/op.cc
+++ b/lib/pcg/src/file_format/v1/op.cc
@@ -182,4 +182,184 @@ V1Op to_v1(Op const &op) {
   }
 }
 
+Op from_v1(V1Op const &vop) {
+  // There should be a better way of doing this.
+  switch (vop) {
+    case V1Op::NOOP:
+      return Op::NOOP;
+    case V1Op::INPUT:
+      return Op::INPUT;
+    case V1Op::WEIGHT:
+      return Op::WEIGHT;
+    case V1Op::CONV2D:
+      return Op::CONV2D;
+    case V1Op::DROPOUT:
+      return Op::DROPOUT;
+    case V1Op::LINEAR:
+      return Op::LINEAR;
+    case V1Op::BATCHMATMUL:
+      return Op::BATCHMATMUL;
+    case V1Op::POOL2D:
+      return Op::POOL2D;
+    case V1Op::SCALAR_MULTIPLY:
+      return Op::SCALAR_MULTIPLY;
+    case V1Op::SCALAR_ADD:
+      return Op::SCALAR_ADD;
+    case V1Op::SCALAR_FLOOR_DIV:
+      return Op::SCALAR_FLOOR_DIV;
+    case V1Op::SCALAR_TRUE_DIV:
+      return Op::SCALAR_TRUE_DIV;
+    case V1Op::SCALAR_SUB:
+      return Op::SCALAR_SUB;
+    case V1Op::RELU:
+      return Op::RELU;
+    case V1Op::IDENTITY:
+      return Op::IDENTITY;
+    case V1Op::SIGMOID:
+      return Op::SIGMOID;
+    case V1Op::TANH:
+      return Op::TANH;
+    case V1Op::ELU:
+      return Op::ELU;
+    case V1Op::FLAT:
+      return Op::FLAT;
+    case V1Op::SOFTMAX:
+      return Op::SOFTMAX;
+    case V1Op::BATCHNORM:
+      return Op::BATCHNORM;
+    case V1Op::CONCAT:
+      return Op::CONCAT;
+    case V1Op::SPLIT:
+      return Op::SPLIT;
+    case V1Op::EMBEDDING:
+      return Op::EMBEDDING;
+    case V1Op::GROUP_BY:
+      return Op::GROUP_BY;
+    case V1Op::CACHE:
+      return Op::CACHE;
+    case V1Op::AGGREGATE:
+      return Op::AGGREGATE;
+    case V1Op::AGG_SPEC:
+      return Op::AGG_SPEC;
+    case V1Op::RESHAPE:
+      return Op::RESHAPE;
+    case V1Op::REVERSE:
+      return Op::REVERSE;
+    case V1Op::TRANSPOSE:
+      return Op::TRANSPOSE;
+    case V1Op::EW_ADD:
+      return Op::EW_ADD;
+    case V1Op::EW_MUL:
+      return Op::EW_MUL;
+    case V1Op::MATMUL:
+      return Op::MATMUL;
+    case V1Op::MUL:
+      return Op::MUL;
+    case V1Op::ENLARGE:
+      return Op::ENLARGE;
+    case V1Op::SQUEEZE:
+      return Op::SQUEEZE;
+    case V1Op::UNSQUEEZE:
+      return Op::UNSQUEEZE;
+    case V1Op::EW_SUB:
+      return Op::EW_SUB;
+    case V1Op::EW_DIV:
+      return Op::EW_DIV;
+    case V1Op::EW_EQUAL:
+      return Op::EW_EQUAL;
+    case V1Op::EW_GREATER:
+      return Op::EW_GREATER;
+    case V1Op::EW_LESS:
+      return Op::EW_LESS;
+    case V1Op::EW_MAX:
+      return Op::EW_MAX;
+    case V1Op::EW_MIN:
+      return Op::EW_MIN;
+    case V1Op::REDUCE_ARGMAX:
+      return Op::REDUCE_ARGMAX;
+    case V1Op::REDUCE_ARGMIN:
+      return Op::REDUCE_ARGMIN;
+    case V1Op::REDUCE_MAX:
+      return Op::REDUCE_MAX;
+    case V1Op::REDUCE_MEAN:
+      return Op::REDUCE_MEAN;
+    case V1Op::REDUCE_MIN:
+      return Op::REDUCE_MIN;
+    case V1Op::REDUCE_PROD:
+      return Op::REDUCE_PROD;
+    case V1Op::REDUCE_SUM:
+      return Op::REDUCE_SUM;
+    case V1Op::PAD:
+      return Op::PAD;
+    case V1Op::SHAPE:
+      return Op::SHAPE;
+    case V1Op::SIZE:
+      return Op::SIZE;
+    case V1Op::TOPK:
+      return Op::TOPK;
+    case V1Op::WHERE:
+      return Op::WHERE;
+    case V1Op::CEIL:
+      return Op::CEIL;
+    case V1Op::CAST:
+      return Op::CAST;
+    case V1Op::EXP:
+      return Op::EXP;
+    case V1Op::ROUND:
+      return Op::ROUND;
+    case V1Op::LOG:
+      return Op::LOG;
+    case V1Op::LOGICAL_NOT:
+      return Op::LOGICAL_NOT;
+    case V1Op::SQRT:
+      return Op::SQRT;
+    case V1Op::SIN:
+      return Op::SIN;
+    case V1Op::COS:
+      return Op::COS;
+    case V1Op::LEAKYRELU:
+      return Op::LEAKYRELU;
+    case V1Op::SLICE:
+      return Op::SLICE;
+    case V1Op::RESIZE:
+      return Op::RESIZE;
+    case V1Op::PRELU:
+      return Op::PRELU;
+    case V1Op::GELU:
+      return Op::GELU;
+    case V1Op::MULTIHEAD_ATTENTION:
+      return Op::MULTIHEAD_ATTENTION;
+    case V1Op::FUSED:
+      return Op::FUSED;
+    case V1Op::RSQRT:
+      return Op::RSQRT;
+    case V1Op::POW:
+      return Op::POW;
+    case V1Op::MEAN:
+      return Op::MEAN;
+    case V1Op::LAYERNORM:
+      return Op::LAYERNORM;
+    case V1Op::GATHER:
+      return Op::GATHER;
+    case V1Op::BROADCAST:
+      return Op::BROADCAST;
+    case V1Op::REPARTITION:
+      return Op::REPARTITION;
+    case V1Op::COMBINE:
+      return Op::COMBINE;
+    case V1Op::REPLICATE:
+      return Op::REPLICATE;
+    case V1Op::REDUCTION:
+      return Op::REDUCTION;
+    case V1Op::BATCH:
+      return Op::BATCH;
+    case V1Op::PIPELINE:
+      return Op::PIPELINE;
+    case V1Op::FUSED_PARALLEL:
+      return Op::FUSED_PARALLEL;
+    default:
+      NOT_REACHABLE();
+  }
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/operator_attrs.cc b/lib/pcg/src/file_format/v1/operator_attrs.cc
index 683c8116b1..fc4b455b62 100644
--- a/lib/pcg/src/file_format/v1/operator_attrs.cc
+++ b/lib/pcg/src/file_format/v1/operator_attrs.cc
@@ -67,6 +67,70 @@ V1CompGraphOperatorAttrs to_v1(CompGraphOperatorAttrs const &attrs) {
   }
 }
 
+CompGraphOperatorAttrs from_v1(V1CompGraphOperatorAttrs const &va) {
+  if (auto const *aggr = get_if<V1AggregateAttrs>(&va)) {
+    return from_v1(*aggr);
+  } else if (auto const *aggrSpec = get_if<V1AggregateSpecAttrs>(&va)) {
+    return from_v1(*aggrSpec);
+  } else if (auto const *batchMm = get_if<V1BatchMatmulAttrs>(&va)) {
+    return from_v1(*batchMm);
+  } else if (auto const *batchNorm = get_if<V1BatchNormAttrs>(&va)) {
+    return from_v1(*batchNorm);
+  } else if (auto const *cast = get_if<V1CastAttrs>(&va)) {
+    return from_v1(*cast);
+  } else if (auto const *concat = get_if<V1ConcatAttrs>(&va)) {
+    return from_v1(*concat);
+  } else if (auto const *conv2d = get_if<V1Conv2DAttrs>(&va)) {
+    return from_v1(*conv2d);
+  } else if (auto const *dropout = get_if<V1DropoutAttrs>(&va)) {
+    return from_v1(*dropout);
+  } else if (auto const *elemBin = get_if<V1ElementBinaryAttrs>(&va)) {
+    return from_v1(*elemBin);
+  } else if (auto const *elemUnSc = get_if<V1ElementScalarUnaryAttrs>(&va)) {
+    return from_v1(*elemUnSc);
+  } else if (auto const *elemUn = get_if<V1ElementUnaryAttrs>(&va)) {
+    return from_v1(*elemUn);
+  } else if (auto const *emb = get_if<V1EmbeddingAttrs>(&va)) {
+    return from_v1(*emb);
+  } else if (auto const *flat = get_if<V1FlatAttrs>(&va)) {
+    return from_v1(*flat);
+  } else if (auto const *gather = get_if<V1GatherAttrs>(&va)) {
+    return from_v1(*gather);
+  } else if (auto const *group = get_if<V1Group_byAttrs>(&va)) {
+    return from_v1(*group);
+  } else if (auto const *inp = get_if<V1InputAttrs>(&va)) {
+    return from_v1(*inp);
+  } else if (auto const *layerNorm = get_if<V1LayerNormAttrs>(&va)) {
+    return from_v1(*layerNorm);
+  } else if (auto const *lin = get_if<V1LinearAttrs>(&va)) {
+    return from_v1(*lin);
+  } else if (auto const *att = get_if<V1MultiHeadAttentionAttrs>(&va)) {
+    return from_v1(*att);
+  } else if (auto const *noop = get_if<V1NoopAttrs>(&va)) {
+    return from_v1(*noop);
+  } else if (auto const *pool2d = get_if<V1Pool2DAttrs>(&va)) {
+    return from_v1(*pool2d);
+  } else if (auto const *reduce = get_if<V1ReduceAttrs>(&va)) {
+    return from_v1(*reduce);
+  } else if (auto const *reverse = get_if<V1ReverseAttrs>(&va)) {
+    return from_v1(*reverse);
+  } else if (auto const *reshape = get_if<V1ReshapeAttrs>(&va)) {
+    return from_v1(*reshape);
+  } else if (auto const *split = get_if<V1SplitAttrs>(&va)) {
+    return from_v1(*split);
+  } else if (auto const *soft = get_if<V1SoftmaxAttrs>(&va)) {
+    return from_v1(*soft);
+  } else if (auto const *topk = get_if<V1TopKAttrs>(&va)) {
+    return from_v1(*topk);
+  } else if (auto const *trans = get_if<V1TransposeAttrs>(&va)) {
+    return from_v1(*trans);
+  } else if (auto const *bcast = get_if<V1BroadcastAttrs>(&va)) {
+    return from_v1(*bcast);
+  } else {
+    NOT_REACHABLE();
+  }
+}
+
 V1PCGOperatorAttrs to_v1(PCGOperatorAttrs const &attrs) {
   if (auto const *aggr = get_if<AggregateAttrs>(&attrs)) {
     return to_v1(*aggr);
@@ -137,4 +201,74 @@ V1PCGOperatorAttrs to_v1(PCGOperatorAttrs const &attrs) {
   }
 }
 
+PCGOperatorAttrs from_v1(V1PCGOperatorAttrs const &va) {
+  if (auto const *aggr = get_if<V1AggregateAttrs>(&va)) {
+    return from_v1(*aggr);
+  } else if (auto const *aggrSpec = get_if<V1AggregateSpecAttrs>(&va)) {
+    return from_v1(*aggrSpec);
+  } else if (auto const *batchMm = get_if<V1BatchMatmulAttrs>(&va)) {
+    return from_v1(*batchMm);
+  } else if (auto const *batchNorm = get_if<V1BatchNormAttrs>(&va)) {
+    return from_v1(*batchNorm);
+  } else if (auto const *cast = get_if<V1CastAttrs>(&va)) {
+    return from_v1(*cast);
+  } else if (auto const *concat = get_if<V1ConcatAttrs>(&va)) {
+    return from_v1(*concat);
+  } else if (auto const *conv2d = get_if<V1Conv2DAttrs>(&va)) {
+    return from_v1(*conv2d);
+  } else if (auto const *dropout = get_if<V1DropoutAttrs>(&va)) {
+    return from_v1(*dropout);
+  } else if (auto const *elemBin = get_if<V1ElementBinaryAttrs>(&va)) {
+    return from_v1(*elemBin);
+  } else if (auto const *elemUnSc = get_if<V1ElementScalarUnaryAttrs>(&va)) {
+    return from_v1(*elemUnSc);
+  } else if (auto const *elemUn = get_if<V1ElementUnaryAttrs>(&va)) {
+    return from_v1(*elemUn);
+  } else if (auto const *emb = get_if<V1EmbeddingAttrs>(&va)) {
+    return from_v1(*emb);
+  } else if (auto const *flat = get_if<V1FlatAttrs>(&va)) {
+    return from_v1(*flat);
+  } else if (auto const *gather = get_if<V1GatherAttrs>(&va)) {
+    return from_v1(*gather);
+  } else if (auto const *group = get_if<V1Group_byAttrs>(&va)) {
+    return from_v1(*group);
+  } else if (auto const *inp = get_if<V1InputAttrs>(&va)) {
+    return from_v1(*inp);
+  } else if (auto const *layerNorm = get_if<V1LayerNormAttrs>(&va)) {
+    return from_v1(*layerNorm);
+  } else if (auto const *lin = get_if<V1LinearAttrs>(&va)) {
+    return from_v1(*lin);
+  } else if (auto const *att = get_if<V1MultiHeadAttentionAttrs>(&va)) {
+    return from_v1(*att);
+  } else if (auto const *noop = get_if<V1NoopAttrs>(&va)) {
+    return from_v1(*noop);
+  } else if (auto const *pool2d = get_if<V1Pool2DAttrs>(&va)) {
+    return from_v1(*pool2d);
+  } else if (auto const *reduce = get_if<V1ReduceAttrs>(&va)) {
+    return from_v1(*reduce);
+  } else if (auto const *reverse = get_if<V1ReverseAttrs>(&va)) {
+    return from_v1(*reverse);
+  } else if (auto const *reshape = get_if<V1ReshapeAttrs>(&va)) {
+    return from_v1(*reshape);
+  } else if (auto const *split = get_if<V1SplitAttrs>(&va)) {
+    return from_v1(*split);
+  } else if (auto const *soft = get_if<V1SoftmaxAttrs>(&va)) {
+    return from_v1(*soft);
+  } else if (auto const *topk = get_if<V1TopKAttrs>(&va)) {
+    return from_v1(*topk);
+  } else if (auto const *trans = get_if<V1TransposeAttrs>(&va)) {
+    return from_v1(*trans);
+  } else if (auto const *combine = get_if<V1CombineAttrs>(&va)) {
+    return from_v1(*combine);
+  } else if (auto const *red = get_if<V1ReductionAttrs>(&va)) {
+    return from_v1(*red);
+  } else if (auto const *repart = get_if<V1RepartitionAttrs>(&va)) {
+    return from_v1(*repart);
+  } else if (auto const *repl = get_if<V1ReplicateAttrs>(&va)) {
+    return from_v1(*repl);
+  } else {
+    NOT_REACHABLE();
+  }
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/aggregate.cc b/lib/pcg/src/file_format/v1/ops/aggregate.cc
index 0a6818e676..47b5dfec6c 100644
--- a/lib/pcg/src/file_format/v1/ops/aggregate.cc
+++ b/lib/pcg/src/file_format/v1/ops/aggregate.cc
@@ -6,4 +6,8 @@ V1AggregateAttrs to_v1(AggregateAttrs const &a) {
   return {a.n, a.lambda_bal};
 }
 
+AggregateAttrs from_v1(V1AggregateAttrs const &va) {
+  return {va.n, va.lambda_bal};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc b/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
index 29f17109d5..a032124d50 100644
--- a/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
+++ b/lib/pcg/src/file_format/v1/ops/aggregate_spec.cc
@@ -6,4 +6,8 @@ V1AggregateSpecAttrs to_v1(AggregateSpecAttrs const &a) {
   return {a.n, a.lambda_bal};
 }
 
+AggregateSpecAttrs from_v1(V1AggregateSpecAttrs const &va) {
+  return {va.n, va.lambda_bal};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/attention.cc b/lib/pcg/src/file_format/v1/ops/attention.cc
index 553106330d..8850aa5d00 100644
--- a/lib/pcg/src/file_format/v1/ops/attention.cc
+++ b/lib/pcg/src/file_format/v1/ops/attention.cc
@@ -13,4 +13,15 @@ V1MultiHeadAttentionAttrs to_v1(MultiHeadAttentionAttrs const &a) {
           a.add_zero_attn};
 }
 
+MultiHeadAttentionAttrs from_v1(V1MultiHeadAttentionAttrs const &va) {
+  return {va.embed_dim,
+          va.num_heads,
+          va.kdim,
+          va.vdim,
+          va.dropout,
+          va.bias,
+          va.add_bias_kv,
+          va.add_zero_attn};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/batch_matmul.cc b/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
index 48324a4672..86a49caf3f 100644
--- a/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
+++ b/lib/pcg/src/file_format/v1/ops/batch_matmul.cc
@@ -7,4 +7,8 @@ V1BatchMatmulAttrs to_v1(BatchMatmulAttrs const &a) {
   return {a.a_seq_length_dim, a.b_seq_length_dim};
 }
 
+BatchMatmulAttrs from_v1(V1BatchMatmulAttrs const &va) {
+  return {va.a_seq_length_dim, va.b_seq_length_dim};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/batch_norm.cc b/lib/pcg/src/file_format/v1/ops/batch_norm.cc
index f06cbffa89..d0deaf95a6 100644
--- a/lib/pcg/src/file_format/v1/ops/batch_norm.cc
+++ b/lib/pcg/src/file_format/v1/ops/batch_norm.cc
@@ -6,4 +6,8 @@ V1BatchNormAttrs to_v1(BatchNormAttrs const &a) {
   return {a.relu};
 }
 
+BatchNormAttrs from_v1(V1BatchNormAttrs const &va) {
+  return {va.relu};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/broadcast.cc b/lib/pcg/src/file_format/v1/ops/broadcast.cc
index 3457be953f..899d8de9cb 100644
--- a/lib/pcg/src/file_format/v1/ops/broadcast.cc
+++ b/lib/pcg/src/file_format/v1/ops/broadcast.cc
@@ -7,4 +7,11 @@ V1BroadcastAttrs to_v1(BroadcastAttrs const &a) {
   return {std::vector<int>(a.target_dims.begin(), a.target_dims.end())};
 }
 
+BroadcastAttrs from_v1(V1BroadcastAttrs const &va) {
+  stack_vector<int, MAX_TENSOR_DIM> dims;
+  for (const int& dim : va.target_dims)
+    dims.emplace_back(dim);
+  return BroadcastAttrs{dims};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/cast.cc b/lib/pcg/src/file_format/v1/ops/cast.cc
index 5a156698e5..c522d75171 100644
--- a/lib/pcg/src/file_format/v1/ops/cast.cc
+++ b/lib/pcg/src/file_format/v1/ops/cast.cc
@@ -7,4 +7,8 @@ V1CastAttrs to_v1(CastAttrs const &a) {
   return {to_v1(a.dtype)};
 }
 
+CastAttrs from_v1(V1CastAttrs const &va) {
+  return {from_v1(va.dtype)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/combine.cc b/lib/pcg/src/file_format/v1/ops/combine.cc
index a80ecd869d..62ce546edd 100644
--- a/lib/pcg/src/file_format/v1/ops/combine.cc
+++ b/lib/pcg/src/file_format/v1/ops/combine.cc
@@ -7,4 +7,8 @@ V1CombineAttrs to_v1(CombineAttrs const &a) {
   return {to_v1(a.combine_dim), a.combine_degree};
 }
 
+CombineAttrs from_v1(V1CombineAttrs const &va) {
+  return {from_v1(va.combine_dim), va.combine_degree};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/concat.cc b/lib/pcg/src/file_format/v1/ops/concat.cc
index 65621b5d27..553f2fd11a 100644
--- a/lib/pcg/src/file_format/v1/ops/concat.cc
+++ b/lib/pcg/src/file_format/v1/ops/concat.cc
@@ -8,4 +8,8 @@ V1ConcatAttrs to_v1(ConcatAttrs const &a) {
   return {to_v1(a.axis)};
 }
 
+ConcatAttrs from_v1(V1ConcatAttrs const &va) {
+  return {ff_dim_t(va.axis)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/conv_2d.cc b/lib/pcg/src/file_format/v1/ops/conv_2d.cc
index 8993dc0da4..270742b700 100644
--- a/lib/pcg/src/file_format/v1/ops/conv_2d.cc
+++ b/lib/pcg/src/file_format/v1/ops/conv_2d.cc
@@ -16,4 +16,17 @@ V1Conv2DAttrs to_v1(Conv2DAttrs const &a) {
           a.use_bias};
 }
 
+Conv2DAttrs from_v1(V1Conv2DAttrs const &va) {
+  return {va.out_channels,
+          va.kernel_h,
+          va.kernel_w,
+          va.stride_h,
+          va.stride_w,
+          va.padding_h,
+          va.padding_w,
+          va.groups,
+          from_v1<Activation>(va.activation),
+          va.use_bias};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/dropout.cc b/lib/pcg/src/file_format/v1/ops/dropout.cc
index 2b6d482cc9..2c92916530 100644
--- a/lib/pcg/src/file_format/v1/ops/dropout.cc
+++ b/lib/pcg/src/file_format/v1/ops/dropout.cc
@@ -6,4 +6,8 @@ V1DropoutAttrs to_v1(DropoutAttrs const &a) {
   return {a.rate, a.seed};
 }
 
+DropoutAttrs from_v1(V1DropoutAttrs const &va) {
+  return {va.rate, va.seed};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/element_binary.cc b/lib/pcg/src/file_format/v1/ops/element_binary.cc
index a763d9e35a..be2eb1a26d 100644
--- a/lib/pcg/src/file_format/v1/ops/element_binary.cc
+++ b/lib/pcg/src/file_format/v1/ops/element_binary.cc
@@ -9,4 +9,11 @@ V1ElementBinaryAttrs to_v1(ElementBinaryAttrs const &a) {
           a.should_broadcast_rhs};
 }
 
+ElementBinaryAttrs from_v1(V1ElementBinaryAttrs const &va) {
+  return {from_v1(va.type),
+          from_v1(va.compute_type),
+          va.should_broadcast_lhs,
+          va.should_broadcast_rhs};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/element_unary.cc b/lib/pcg/src/file_format/v1/ops/element_unary.cc
index f4f69fbd7d..4aecc47c95 100644
--- a/lib/pcg/src/file_format/v1/ops/element_unary.cc
+++ b/lib/pcg/src/file_format/v1/ops/element_unary.cc
@@ -6,8 +6,16 @@ V1ElementScalarUnaryAttrs to_v1(ElementScalarUnaryAttrs const &a) {
   return {to_v1(a.op), a.scalar};
 }
 
+ElementScalarUnaryAttrs from_v1(V1ElementScalarUnaryAttrs const &va) {
+  return {from_v1(va.op), va.scalar};
+}
+
 V1ElementUnaryAttrs to_v1(ElementUnaryAttrs const &a) {
   return {to_v1(a.op)};
 }
 
+ElementUnaryAttrs from_v1(V1ElementUnaryAttrs const &va) {
+  return {from_v1(va.op)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/embedding.cc b/lib/pcg/src/file_format/v1/ops/embedding.cc
index 91b093c928..6fb54883c6 100644
--- a/lib/pcg/src/file_format/v1/ops/embedding.cc
+++ b/lib/pcg/src/file_format/v1/ops/embedding.cc
@@ -15,8 +15,25 @@ V1AggregateOp to_v1(AggregateOp const &op) {
   }
 }
 
+AggregateOp from_v1(V1AggregateOp const &vop) {
+  // There should be a better way of doing this.
+  switch (vop) {
+    case V1AggregateOp::SUM:
+      return AggregateOp::SUM;
+    case V1AggregateOp::AVG:
+      return AggregateOp::AVG;
+    default:
+      NOT_REACHABLE();
+  }
+}
+
 V1EmbeddingAttrs to_v1(EmbeddingAttrs const &a) {
   return {a.num_entries, a.out_channels, to_v1(a.aggr), to_v1(a.data_type)};
 }
 
+EmbeddingAttrs from_v1(V1EmbeddingAttrs const &va) {
+  return {
+      va.num_entries, va.out_channels, from_v1(va.aggr), from_v1(va.data_type)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/flat.cc b/lib/pcg/src/file_format/v1/ops/flat.cc
index 7166cccde3..be0c056b1c 100644
--- a/lib/pcg/src/file_format/v1/ops/flat.cc
+++ b/lib/pcg/src/file_format/v1/ops/flat.cc
@@ -9,4 +9,10 @@ V1FlatAttrs to_v1(FlatAttrs const &a) {
   };
 }
 
+FlatAttrs from_v1(V1FlatAttrs const &va) {
+  return {
+    // No fields in FlatAttrs
+  };
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/gather.cc b/lib/pcg/src/file_format/v1/ops/gather.cc
index 2a93920955..c6ce769f5e 100644
--- a/lib/pcg/src/file_format/v1/ops/gather.cc
+++ b/lib/pcg/src/file_format/v1/ops/gather.cc
@@ -8,4 +8,8 @@ V1GatherAttrs to_v1(GatherAttrs const &a) {
   return {to_v1(a.dim)};
 }
 
+GatherAttrs from_v1(V1GatherAttrs const &va) {
+  return {ff_dim_t(va.dim)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/groupby.cc b/lib/pcg/src/file_format/v1/ops/groupby.cc
index 652e7e63b2..11325e7a55 100644
--- a/lib/pcg/src/file_format/v1/ops/groupby.cc
+++ b/lib/pcg/src/file_format/v1/ops/groupby.cc
@@ -6,4 +6,8 @@ V1Group_byAttrs to_v1(Group_byAttrs const &a) {
   return {a.n, a.alpha};
 }
 
+Group_byAttrs from_v1(V1Group_byAttrs const &va) {
+  return {va.n, va.alpha};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/input.cc b/lib/pcg/src/file_format/v1/ops/input.cc
index 8ef3462fc6..aad7b98add 100644
--- a/lib/pcg/src/file_format/v1/ops/input.cc
+++ b/lib/pcg/src/file_format/v1/ops/input.cc
@@ -9,4 +9,10 @@ V1InputAttrs to_v1(InputAttrs const &a) {
   };
 }
 
+InputAttrs from_v1(V1InputAttrs const &va) {
+  return {
+      // No fields in InputAttrs
+  };
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/layer_norm.cc b/lib/pcg/src/file_format/v1/ops/layer_norm.cc
index 97713c2d4a..4fd52ed1c6 100644
--- a/lib/pcg/src/file_format/v1/ops/layer_norm.cc
+++ b/lib/pcg/src/file_format/v1/ops/layer_norm.cc
@@ -10,4 +10,12 @@ V1LayerNormAttrs to_v1(LayerNormAttrs const &a) {
           a.eps};
 }
 
+LayerNormAttrs from_v1(V1LayerNormAttrs const &va) {
+
+  return {
+      stack_vector<ff_dim_t, MAX_TENSOR_DIM>(va.axes.begin(), va.axes.end()),
+      va.elementwise_affine,
+      va.eps};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/linear.cc b/lib/pcg/src/file_format/v1/ops/linear.cc
index f0ee521029..53549a3919 100644
--- a/lib/pcg/src/file_format/v1/ops/linear.cc
+++ b/lib/pcg/src/file_format/v1/ops/linear.cc
@@ -7,18 +7,38 @@ V1L1RegularizerAttrs to_v1(L1RegularizerAttrs const &a) {
   return {a.lambda};
 }
 
+L1RegularizerAttrs from_v1(V1L1RegularizerAttrs const &va) {
+  return {va.lambda};
+}
+
 V1L2RegularizerAttrs to_v1(L2RegularizerAttrs const &a) {
   return {a.lambda};
 }
 
+L2RegularizerAttrs from_v1(V1L2RegularizerAttrs const &va) {
+  return {va.lambda};
+}
+
 V1RegularizerAttrs to_v1(RegularizerAttrs const &a) {
   // There should be a better way of doing this.
-  if (const auto* l1 = get_if<L1RegularizerAttrs>(&a))
+  if (auto const *l1 = get_if<L1RegularizerAttrs>(&a)) {
     return to_v1(*l1);
-  else if (const auto* l2 = get_if<L2RegularizerAttrs>(&a))
+  } else if (auto const *l2 = get_if<L2RegularizerAttrs>(&a)) {
     return to_v1(*l2);
-  else
+  } else {
+    NOT_REACHABLE();
+  }
+}
+
+RegularizerAttrs from_v1(V1RegularizerAttrs const &a) {
+  // There should be a better way of doing this.
+  if (auto const *l1 = get_if<V1L1RegularizerAttrs>(&a)) {
+    return from_v1(*l1);
+  } else if (auto const *l2 = get_if<V1L2RegularizerAttrs>(&a)) {
+    return from_v1(*l2);
+  } else {
     NOT_REACHABLE();
+  }
 }
 
 V1LinearAttrs to_v1(LinearAttrs const &a) {
@@ -29,4 +49,12 @@ V1LinearAttrs to_v1(LinearAttrs const &a) {
           to_v1<V1RegularizerAttrs>(a.regularizer)};
 }
 
+LinearAttrs from_v1(V1LinearAttrs const &va) {
+  return {va.out_channels,
+          va.use_bias,
+          from_v1(va.data_type),
+          from_v1(va.activation),
+          from_v1<RegularizerAttrs>(va.regularizer)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/noop.cc b/lib/pcg/src/file_format/v1/ops/noop.cc
index 6b48860c20..cbda4195ad 100644
--- a/lib/pcg/src/file_format/v1/ops/noop.cc
+++ b/lib/pcg/src/file_format/v1/ops/noop.cc
@@ -9,4 +9,10 @@ V1NoopAttrs to_v1(NoopAttrs const &a) {
   };
 }
 
+NoopAttrs from_v1(V1NoopAttrs const &va) {
+  return {
+      // No fields in NoopAttrs.
+  };
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/pool_2d.cc b/lib/pcg/src/file_format/v1/ops/pool_2d.cc
index 1d37aede8d..1127d76c5e 100644
--- a/lib/pcg/src/file_format/v1/ops/pool_2d.cc
+++ b/lib/pcg/src/file_format/v1/ops/pool_2d.cc
@@ -15,6 +15,18 @@ V1PoolOp to_v1(PoolOp const &op) {
   }
 }
 
+PoolOp from_v1(V1PoolOp const &vop) {
+  // There should be a better way of doing this.
+  switch (vop) {
+    case V1PoolOp::MAX:
+      return PoolOp::MAX;
+    case V1PoolOp::AVG:
+      return PoolOp::AVG;
+    default:
+      NOT_REACHABLE();
+  }
+}
+
 V1Pool2DAttrs to_v1(Pool2DAttrs const &a) {
   return {a.kernel_h,
           a.kernel_w,
@@ -26,4 +38,15 @@ V1Pool2DAttrs to_v1(Pool2DAttrs const &a) {
           to_v1(a.activation)};
 }
 
+Pool2DAttrs from_v1(V1Pool2DAttrs const &va) {
+  return {va.kernel_h,
+          va.kernel_w,
+          va.stride_h,
+          va.stride_w,
+          va.padding_h,
+          va.padding_w,
+          from_v1(va.pool_type),
+          from_v1(va.activation)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reduce.cc b/lib/pcg/src/file_format/v1/ops/reduce.cc
index cd6eac6e6a..0e4188a588 100644
--- a/lib/pcg/src/file_format/v1/ops/reduce.cc
+++ b/lib/pcg/src/file_format/v1/ops/reduce.cc
@@ -9,4 +9,12 @@ V1ReduceAttrs to_v1(ReduceAttrs const &a) {
           a.keepdims};
 }
 
+ReduceAttrs from_v1(V1ReduceAttrs const &va) {
+  stack_vector<ff_dim_t, MAX_TENSOR_DIM> axes;
+  for (int const &d : va.axes) {
+    axes.push_back(ff_dim_t(d));
+  }
+  return {axes, from_v1(va.op_type), va.keepdims};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reduction.cc b/lib/pcg/src/file_format/v1/ops/reduction.cc
index 2f086b1817..606ba14ba7 100644
--- a/lib/pcg/src/file_format/v1/ops/reduction.cc
+++ b/lib/pcg/src/file_format/v1/ops/reduction.cc
@@ -7,4 +7,8 @@ V1ReductionAttrs to_v1(ReductionAttrs const &a) {
   return {to_v1(a.reduction_dim), a.reduction_degree};
 }
 
+ReductionAttrs from_v1(V1ReductionAttrs const &va) {
+  return {ff_dim_t(va.reduction_dim), va.reduction_degree};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/repartition.cc b/lib/pcg/src/file_format/v1/ops/repartition.cc
index 629aa89045..55c4fc175a 100644
--- a/lib/pcg/src/file_format/v1/ops/repartition.cc
+++ b/lib/pcg/src/file_format/v1/ops/repartition.cc
@@ -7,4 +7,8 @@ V1RepartitionAttrs to_v1(RepartitionAttrs const &a) {
   return {to_v1(a.repartition_dim), a.repartition_degree};
 }
 
+RepartitionAttrs from_v1(V1RepartitionAttrs const &va) {
+  return {from_v1(va.repartition_dim), va.repartition_degree};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/replicate.cc b/lib/pcg/src/file_format/v1/ops/replicate.cc
index a1a369e417..520f0710d7 100644
--- a/lib/pcg/src/file_format/v1/ops/replicate.cc
+++ b/lib/pcg/src/file_format/v1/ops/replicate.cc
@@ -7,4 +7,8 @@ V1ReplicateAttrs to_v1(ReplicateAttrs const &a) {
   return {to_v1(a.replicate_dim), a.replicate_degree};
 }
 
+ReplicateAttrs from_v1(V1ReplicateAttrs const &va) {
+  return {ff_dim_t(va.replicate_dim), va.replicate_degree};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reshape.cc b/lib/pcg/src/file_format/v1/ops/reshape.cc
index 1beb95fd22..e9832b1353 100644
--- a/lib/pcg/src/file_format/v1/ops/reshape.cc
+++ b/lib/pcg/src/file_format/v1/ops/reshape.cc
@@ -7,4 +7,8 @@ V1ReshapeAttrs to_v1(ReshapeAttrs const &a) {
   return {to_v1(a.shape)};
 }
 
+ReshapeAttrs from_v1(V1ReshapeAttrs const &va) {
+  return {from_v1(va.shape)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/reverse.cc b/lib/pcg/src/file_format/v1/ops/reverse.cc
index 1ee500c881..13c5e2cd43 100644
--- a/lib/pcg/src/file_format/v1/ops/reverse.cc
+++ b/lib/pcg/src/file_format/v1/ops/reverse.cc
@@ -7,4 +7,8 @@ V1ReverseAttrs to_v1(ReverseAttrs const &a) {
   return {to_v1(a.axis)};
 }
 
+ReverseAttrs from_v1(V1ReverseAttrs const &va) {
+  return {from_v1(va.axis)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/softmax.cc b/lib/pcg/src/file_format/v1/ops/softmax.cc
index 8cae6408aa..61e817512a 100644
--- a/lib/pcg/src/file_format/v1/ops/softmax.cc
+++ b/lib/pcg/src/file_format/v1/ops/softmax.cc
@@ -8,4 +8,8 @@ V1SoftmaxAttrs to_v1(SoftmaxAttrs const &a) {
   return {to_v1(a.dim)};
 }
 
+SoftmaxAttrs from_v1(V1SoftmaxAttrs const &va) {
+  return {ff_dim_t(va.dim)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/split.cc b/lib/pcg/src/file_format/v1/ops/split.cc
index ffbc767475..478e175140 100644
--- a/lib/pcg/src/file_format/v1/ops/split.cc
+++ b/lib/pcg/src/file_format/v1/ops/split.cc
@@ -8,4 +8,12 @@ V1SplitAttrs to_v1(SplitAttrs const &a) {
   return {std::vector<int>(a.splits.begin(), a.splits.end()), to_v1(a.axis)};
 }
 
+SplitAttrs from_v1(V1SplitAttrs const &va) {
+  stack_vector<int, MAX_NUM_OUTPUTS> splits;
+  for (int const &i : va.splits) {
+    splits.push_back(i);
+  }
+  return {splits, ff_dim_t(va.axis)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/topk.cc b/lib/pcg/src/file_format/v1/ops/topk.cc
index 2735f0ac20..1a8ab444d6 100644
--- a/lib/pcg/src/file_format/v1/ops/topk.cc
+++ b/lib/pcg/src/file_format/v1/ops/topk.cc
@@ -6,4 +6,8 @@ V1TopKAttrs to_v1(TopKAttrs const &a) {
   return {a.k, a.sorted};
 }
 
+TopKAttrs from_v1(V1TopKAttrs const &va) {
+  return {va.k, va.sorted};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/ops/transpose.cc b/lib/pcg/src/file_format/v1/ops/transpose.cc
index 9900a0f3e7..6fe12331c7 100644
--- a/lib/pcg/src/file_format/v1/ops/transpose.cc
+++ b/lib/pcg/src/file_format/v1/ops/transpose.cc
@@ -8,4 +8,12 @@ V1TransposeAttrs to_v1(TransposeAttrs const &a) {
   return {std::vector<int>(a.perm.begin(), a.perm.end())};
 }
 
+TransposeAttrs from_v1(V1TransposeAttrs const &va) {
+  stack_vector<ff_dim_t, MAX_TENSOR_DIM> perm;
+  for (int const &i : va.perm) {
+    perm.push_back(ff_dim_t(i));
+  }
+  return {perm};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/parallel_tensor.cc b/lib/pcg/src/file_format/v1/parallel_tensor.cc
index e04d89d512..d9ada5880e 100644
--- a/lib/pcg/src/file_format/v1/parallel_tensor.cc
+++ b/lib/pcg/src/file_format/v1/parallel_tensor.cc
@@ -7,6 +7,10 @@ V1ParallelDim to_v1(ParallelDim const &dim) {
   return {dim.size, dim.degree, dim.is_replica_dim};
 }
 
+ParallelDim from_v1(V1ParallelDim const &vdim) {
+  return {vdim.size, vdim.degree, vdim.is_replica_dim};
+}
+
 V1ParallelTensorShape to_v1(ParallelTensorShape const &shp) {
   std::vector<V1ParallelDim> pdims;
   for (ParallelDim const &pdim : shp.dims) {
@@ -15,6 +19,10 @@ V1ParallelTensorShape to_v1(ParallelTensorShape const &shp) {
   return {pdims, to_v1(shp.data_type)};
 }
 
+ParallelTensorShape from_v1(V1ParallelTensorShape const &vshp) {
+  return ParallelTensorShape(from_v1(vshp.dims), from_v1(vshp.data_type));
+}
+
 V1ParallelTensor to_v1(ParallelTensor const &t) {
   return {to_v1(t.get_shape()),
           to_v1(t.create_gradients),
@@ -23,4 +31,14 @@ V1ParallelTensor to_v1(ParallelTensor const &t) {
           t.name};
 }
 
+ParallelTensor from_v1(V1ParallelTensor const &vt) {
+  ParallelTensorShape shape = from_v1(vt.shape);
+  return {shape.dims,
+          shape.data_type,
+          from_v1(vt.create_gradients),
+          from_v1<Initializer>(vt.initializer),
+          from_v1<ParamSync>(vt.sync_type),
+          vt.name};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/parallel_tensor_dims.cc b/lib/pcg/src/file_format/v1/parallel_tensor_dims.cc
new file mode 100644
index 0000000000..de8698e379
--- /dev/null
+++ b/lib/pcg/src/file_format/v1/parallel_tensor_dims.cc
@@ -0,0 +1,21 @@
+#include "pcg/file_format/v1/parallel_tensor_dims.h"
+
+namespace FlexFlow {
+
+V1ParallelTensorDims to_v1(ParallelTensorDims const &dims) {
+  std::vector<V1ParallelDim> data;
+  for (ParallelDim const &pdim : dims.data) {
+    data.emplace_back(to_v1(pdim));
+  }
+  return {data};
+}
+
+ParallelTensorDims from_v1(V1ParallelTensorDims const &vdims) {
+  std::vector<ParallelDim> dims;
+  for (V1ParallelDim const &pdim : vdims.data) {
+    dims.emplace_back(from_v1(pdim));
+  }
+  return ParallelTensorDims(dims);
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/param_sync.cc b/lib/pcg/src/file_format/v1/param_sync.cc
index f9f75171cd..26741c9b7a 100644
--- a/lib/pcg/src/file_format/v1/param_sync.cc
+++ b/lib/pcg/src/file_format/v1/param_sync.cc
@@ -13,4 +13,15 @@ V1ParamSync to_v1(ParamSync const &p) {
   };
 }
 
+ParamSync from_v1(V1ParamSync const &vp) {
+  switch (vp) {
+    case V1ParamSync::PARAM_SERVER:
+      return ParamSync::PS;
+    case V1ParamSync::NCCL:
+      return ParamSync::NCCL;
+    default:
+      NOT_REACHABLE();
+  };
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/tensor.cc b/lib/pcg/src/file_format/v1/tensor.cc
index 4d891a5a78..ff4c3d84c8 100644
--- a/lib/pcg/src/file_format/v1/tensor.cc
+++ b/lib/pcg/src/file_format/v1/tensor.cc
@@ -11,4 +11,14 @@ V1Tensor to_v1(Tensor const &t) {
           t.name};
 }
 
+Tensor from_v1(V1Tensor const &vt) {
+  TensorShape shape = from_v1(vt.shape);
+  return {shape.dims,
+          shape.data_type,
+          from_v1(vt.create_gradients),
+          from_v1<Initializer>(vt.initializer),
+          from_v1<ParamSync>(vt.sync_type),
+          vt.name};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/tensor_shape.cc b/lib/pcg/src/file_format/v1/tensor_shape.cc
index 6c75ffd446..ec1419d65e 100644
--- a/lib/pcg/src/file_format/v1/tensor_shape.cc
+++ b/lib/pcg/src/file_format/v1/tensor_shape.cc
@@ -7,4 +7,9 @@ V1TensorShape to_v1(TensorShape const &shape) {
           to_v1(shape.data_type)};
 }
 
+TensorShape from_v1(V1TensorShape const &vshp) {
+  return {TensorDims(vshp.dims.begin(), vshp.dims.end()),
+          from_v1(vshp.data_type)};
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/src/file_format/v1/v1.cc b/lib/pcg/src/file_format/v1/v1.cc
index 6c748a45e9..3f32837609 100644
--- a/lib/pcg/src/file_format/v1/v1.cc
+++ b/lib/pcg/src/file_format/v1/v1.cc
@@ -6,4 +6,8 @@ std::string to_v1(std::string const &s) {
   return s;
 }
 
+std::string from_v1(std::string const &vs) {
+  return vs;
+}
+
 } // namespace FlexFlow
diff --git a/lib/pcg/test/test_tensor.cc b/lib/pcg/test/test_tensor.cc
index 95365e0762..7fed302958 100644
--- a/lib/pcg/test/test_tensor.cc
+++ b/lib/pcg/test/test_tensor.cc
@@ -2,6 +2,7 @@
 #include "pcg/file_format/v1/tensor.h"
 #include "pcg/tensor.h"
 #include "utils/containers.h"
+#include "utils/json.h"
 #include "utils/required.h"
 
 #include <optional>
@@ -15,5 +16,10 @@ TEST_CASE("Tensor") {
            nullopt,
            nullopt,
            std::string("tensor")};
-  to_v1(t);
+  json j = to_v1(t);
+
+  // FIXME: There is currently a bug in the serialization of tl::optional to
+  // json which puts it in an infinite loop. When that is fixed, this will
+  // actually work.
+  NOT_REACHABLE();
 }
diff --git a/lib/utils/test/src/test_json.cc b/lib/utils/test/src/test_json.cc
new file mode 100644
index 0000000000..499bb11674
--- /dev/null
+++ b/lib/utils/test/src/test_json.cc
@@ -0,0 +1,21 @@
+#include "test/utils/doctest.h"
+#include "utils/json.h"
+
+static std::string str(json const &j) {
+  std::stringstream ss;
+  ss << j;
+  return ss.str();
+}
+
+TEST_CASE("optional primitive") {
+  SUBCASE("int") {
+    CHECK(str(json(optional<int>())) == "null");
+
+    CHECK(str(json(optional<int>(11))) == "11");
+
+    // FIXME: There is a bug somewhere in the automatic JSON handling of an
+    // optional<T> with a value in it that causes the code to go into an
+    // infinite loop. This should be fixed ASAP.
+    NOT_REACHABLE();
+  }
+}

From 6f7460e289e62a2f9fb2aa1517870abef1611a88 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Wed, 18 Oct 2023 12:01:56 -0600
Subject: [PATCH 12/15] WIP: Add some tests for json (de)serialization. Add
 implementations for some incomplete code.

There is currently a bug in deserializing FlexFlow::req<T> that prevents the
code from building.
---
 lib/utils/include/utils/json.h  | 147 +++++++++++++++++++++++++++----
 lib/utils/test/src/test_json.cc | 149 ++++++++++++++++++++++++++++++--
 2 files changed, 272 insertions(+), 24 deletions(-)

diff --git a/lib/utils/include/utils/json.h b/lib/utils/include/utils/json.h
index a753c52daa..b5207d0d6d 100644
--- a/lib/utils/include/utils/json.h
+++ b/lib/utils/include/utils/json.h
@@ -10,6 +10,100 @@
 
 namespace FlexFlow {
 
+template <typename T, typename = void>
+struct json_type_name {
+  static constexpr char const *name = "anonymous";
+};
+
+template <>
+struct json_type_name<bool> {
+  static constexpr char const *name = "bool";
+};
+
+template <>
+struct json_type_name<char> {
+  static constexpr char const *name = "char";
+};
+
+template <>
+struct json_type_name<signed char> {
+  static constexpr char const *name = "signed char";
+};
+
+template <>
+struct json_type_name<short> {
+  static constexpr char const *name = "short";
+};
+
+template <>
+struct json_type_name<int> {
+  static constexpr char const *name = "int";
+};
+
+template <>
+struct json_type_name<long> {
+  static constexpr char const *name = "long";
+};
+
+template <>
+struct json_type_name<long long> {
+  static constexpr char const *name = "long long";
+};
+
+template <>
+struct json_type_name<unsigned char> {
+  static constexpr char const *name = "unsigned char";
+};
+
+template <>
+struct json_type_name<unsigned short> {
+  static constexpr char const *name = "unsigned short";
+};
+
+template <>
+struct json_type_name<unsigned int> {
+  static constexpr char const *name = "unsigned int";
+};
+
+template <>
+struct json_type_name<unsigned long> {
+  static constexpr char const *name = "unsigned long";
+};
+
+template <>
+struct json_type_name<unsigned long long> {
+  static constexpr char const *name = "unsigned long long";
+};
+
+template <>
+struct json_type_name<float> {
+  static constexpr char const *name = "float";
+};
+
+template <>
+struct json_type_name<double> {
+  static constexpr char const *name = "double";
+};
+
+template <>
+struct json_type_name<long double> {
+  static constexpr char const *name = "long double";
+};
+
+template <typename T>
+struct json_type_name<
+    T,
+    std::enable_if_t<std::is_class_v<T> && is_visitable<T>::value>> {
+  static constexpr char const *name = visit_struct::get_name<T>();
+};
+
+template <typename T>
+struct json_type_name<
+    T,
+    std::enable_if_t<std::is_class_v<T> && !is_visitable<T>::value>> {
+  static constexpr char const *name = "unnamed struct";
+};
+
 template <typename T, typename Enable = void>
 struct is_json_serializable : std::false_type {};
 
@@ -143,39 +237,58 @@ struct VariantToJsonFunctor {
   void operator()(T const &t) {
     static_assert(is_jsonable<T>::value, "");
 
-    j["type"] = get_name(t);
+    // The type field is not used for deserialization. It is there primarily
+    // as a debugging aid if needed.
+    j["type"] = json_type_name<T>::name;
     j["value"] = t;
   }
 };
 
 template <typename... Args>
 void variant_to_json(json &j, variant<Args...> const &v) {
-  visit(::FlexFlow::VariantToJsonFunctor{j}, v.value);
+  // The index indicates the type of the variant that is serialized. The
+  // actual serialization of the type will be handled by the functor. The
+  // variant itself is lost in the visitor, so this needs to be done first. The
+  // type field is not used in deserialization - only the index is.
+  j["index"] = v.index();
+  visit(::FlexFlow::VariantToJsonFunctor{j}, v);
 }
 
-template <typename Variant>
-struct VariantFromJsonFunctor {
-  VariantFromJsonFunctor(json const &j) : j(j) {}
+template <typename Variant, size_t Idx>
+optional<Variant> variant_from_json_impl(json const &j) {
+  using Type = typename variant_alternative<Idx, Variant>::type;
 
-  json const &j;
-
-  template <int Idx>
-  optional<Variant> operator()(std::integral_constant<int, Idx> const &) const {
-    using Type = typename variant_alternative<Idx, Variant>::type;
+  if (j.at("index").get<size_t>() == Idx) {
+    return j.at("value").get<Type>();
+  }
+  return nullopt;
+}
 
-    if (visit_struct::get_name<Type>()) {
-      return j.at("value").get<Type>();
+template <typename Variant, size_t... Is>
+optional<Variant> variant_from_json_impl(json const &j,
+                                         std::index_sequence<Is...>) {
+  // If there were no errors when parsing, all but one element of the array
+  // will be nullopt. This is because each call to variant_from_json_impl will
+  // have a unique index and exactly one of them will match the index in the
+  // json object.
+  std::array<optional<Variant>, sizeof...(Is)> results{
+      variant_from_json_impl<Variant, Is>(j)...};
+  for (optional<Variant> &maybe : results) {
+    if (maybe) {
+      return maybe.value();
     }
   }
-};
+  return nullopt;
+}
 
 template <typename... Args>
 variant<Args...> variant_from_json(json const &j) {
-  ::FlexFlow::VariantFromJsonFunctor<::FlexFlow::variant<Args...>> func(j);
-  auto result = seq_map(func, seq_enumerate_args_t<Args...>{});
+  using Variant = ::FlexFlow::variant<Args...>;
+  optional<Variant> result = variant_from_json_impl<Variant>(
+      j, std::make_index_sequence<sizeof...(Args)>());
   if (!result.has_value()) {
     throw ::FlexFlow::mk_runtime_error("Invalid type {} found in json",
-                                       j.at("type").get<std::string>());
+                                       j.at("index").get<size_t>());
   }
   return result.value();
 }
@@ -223,7 +336,7 @@ struct adl_serializer<
     typename std::enable_if<::FlexFlow::is_jsonable<T>::value>::type> {
   static void to_json(json &j, ::FlexFlow::optional<T> const &t) {
     if (t.has_value()) {
-      to_json(j, t.value());
+      j = t.value();
     } else {
       j = nullptr;
     }
diff --git a/lib/utils/test/src/test_json.cc b/lib/utils/test/src/test_json.cc
index 499bb11674..dbd04005fa 100644
--- a/lib/utils/test/src/test_json.cc
+++ b/lib/utils/test/src/test_json.cc
@@ -1,21 +1,156 @@
 #include "test/utils/doctest.h"
 #include "utils/json.h"
 
+namespace FlexFlow {
+
+struct Struct0 {
+  // No fields. It is unlikely that this will ever happen in FlexFlow, but who
+  // knows?
+};
+FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(Struct0);
+FF_VISIT_FMTABLE(Struct0);
+
+struct Struct1 {
+  char c;
+};
+FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(Struct1, c);
+FF_VISIT_FMTABLE(Struct1);
+
+struct Struct2 {
+  std::string str;
+  int i;
+};
+FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(Struct2, str, i);
+FF_VISIT_FMTABLE(Struct2);
+
+struct Struct3 {
+  unsigned long long ll;
+  bool b;
+  short s;
+};
+FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(Struct3, ll, b, s);
+FF_VISIT_FMTABLE(Struct3);
+
+struct NotVisitable {
+  float f;
+  int i;
+};
+
+} // namespace FlexFlow
+
 static std::string str(json const &j) {
   std::stringstream ss;
   ss << j;
   return ss.str();
 }
 
-TEST_CASE("optional primitive") {
+template <typename T>
+static void serde(T const &v, std::string const &expected) {
+  json j = v;
+  CHECK(str(j) == expected);
+  CHECK(j.get<T>() == v);
+}
+
+// This is used to check that the serialization of the struct produces the
+// correct fields. It seems as if the fields are not processed in any specific
+// order, so we need to check that everything is present and that the
+// punctuation is in order. Each element of the list argument will be the
+// serialization of one field.
+template <typename T>
+static void serde(T const& v, std::initializer_list<const char*> list) {
+  json j = v;
+  std::string ser = str(j);
+
+  CHECK(ser.front() == '{');
+  for (const char* f : list)
+    CHECK(ser.find(f) != std::string::npos);
+  CHECK(ser.back() == '}');
+
+  // The remaining characters should be commas. But checking for them would be
+  // a bit more involved since it would need us to look at anything that was not
+  // part of the field itself. Instead, just check that the length is what we
+  // expect it to be. We start at two for the two braces. There should be
+  // list.size() - 1 commas.
+  size_t len = 2;
+  for (const char* f : list)
+    len += strlen(f);
+  CHECK(ser.size() == len + list.size() - 1);
+}
+
+TEST_CASE("json_type_name") {
+  SUBCASE("builtin") {
+    // We don't check for the fixed-width types because they are just typedefs
+    // for some builtin type. Those mappings are platform dependent, so it
+    // doesn't make a great deal of sense to check them.
+    CHECK(json_type_name<bool>::name == "bool");
+
+    CHECK(json_type_name<char>::name == "char");
+    CHECK(json_type_name<signed char>::name == "signed char");
+    CHECK(json_type_name<unsigned char>::name == "unsigned char");
+
+    CHECK(json_type_name<short>::name == "short");
+    CHECK(json_type_name<int>::name == "int");
+    CHECK(json_type_name<long>::name == "long");
+    CHECK(json_type_name<long long>::name == "long long");
+    CHECK(json_type_name<unsigned char>::name == "unsigned char");
+    CHECK(json_type_name<unsigned short>::name == "unsigned short");
+    CHECK(json_type_name<unsigned int>::name == "unsigned int");
+    CHECK(json_type_name<unsigned long>::name == "unsigned long");
+    CHECK(json_type_name<unsigned long long>::name == "unsigned long long");
+    CHECK(json_type_name<float>::name == "float");
+    CHECK(json_type_name<double>::name == "double");
+    CHECK(json_type_name<long double>::name == "long double");
+  }
+
+  SUBCASE("struct") {
+    CHECK(json_type_name<FlexFlow::Struct0>::name == "::FlexFlow::Struct0");
+    CHECK(json_type_name<FlexFlow::Struct1>::name == "::FlexFlow::Struct1");
+    CHECK(json_type_name<FlexFlow::Struct2>::name == "::FlexFlow::Struct2");
+    CHECK(json_type_name<FlexFlow::NotVisitable>::name == "unnamed struct");
+  }
+}
+
+TEST_CASE("struct") {
+  serde(Struct0{}, "null");
+  serde(Struct1{'A'}, "{\"c\":65}");
+  serde(Struct2{"string", 42}, {"\"i\":42","\"str\":\"string\""});
+  serde(Struct3{99, false, 12}, {"\"s\":12","\"b\":false","\"ll\":99"});
+}
+
+TEST_CASE("req") {
+  SUBCASE("char") {
+    req<char> r('c');
+    json j = json(r);
+    CHECK(str(j) == "99");
+
+    // FIXME: There is currently a bug of some sort that causes this to not
+    // compile.
+    CHECK(j.get<req<char>>() == r);
+  }
+}
+
+TEST_CASE("optional") {
   SUBCASE("int") {
-    CHECK(str(json(optional<int>())) == "null");
+    serde<optional<int>>(nullopt, "null");
+    serde<optional<int>>(11, "11");
+  }
 
-    CHECK(str(json(optional<int>(11))) == "11");
+  SUBCASE("string") {
+    serde<optional<std::string>>(nullopt, "null");
+    serde<optional<std::string>>("string", "\"string\"");
+  }
+}
+
+TEST_CASE("variant") {
+  SUBCASE("single primitive") {
+    serde(variant<int>(11), "{\"index\":0,\"type\":\"int\",\"value\":11}");
+  }
 
-    // FIXME: There is a bug somewhere in the automatic JSON handling of an
-    // optional<T> with a value in it that causes the code to go into an
-    // infinite loop. This should be fixed ASAP.
-    NOT_REACHABLE();
+  SUBCASE("multiple primitives") {
+    using Type = variant<int, char, bool>;
+    serde<Type>(11, "{\"index\":0,\"type\":\"int\",\"value\":11}");
+    serde<Type>('f', "{\"index\":1,\"type\":\"char\",\"value\":102}");
+    serde<Type>(true, "{\"index\":2,\"type\":\"bool\",\"value\":true}");
+    serde<Type>(false, "{\"index\":2,\"type\":\"bool\",\"value\":false}");
   }
 }

From 7b222c4eecbf040c26cc3b54c72588fda3276a95 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Mon, 6 Nov 2023 15:34:11 -0700
Subject: [PATCH 13/15] Add some tests for serialization.

---
 lib/pcg/test/test_operator_attrs.cc | 227 ++++++++++++++++++++++++++++
 lib/pcg/test/test_tensor.cc         |   5 -
 lib/utils/test/src/test_json.cc     |   2 +-
 3 files changed, 228 insertions(+), 6 deletions(-)
 create mode 100644 lib/pcg/test/test_operator_attrs.cc

diff --git a/lib/pcg/test/test_operator_attrs.cc b/lib/pcg/test/test_operator_attrs.cc
new file mode 100644
index 0000000000..5e19cbeac3
--- /dev/null
+++ b/lib/pcg/test/test_operator_attrs.cc
@@ -0,0 +1,227 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/operator_attrs.h"
+#include "utils/containers.h"
+#include "utils/json.h"
+#include "utils/required.h"
+
+using namespace FlexFlow;
+
+using Field = std::pair<std::string, std::string>;
+static void check_fields(json const &j, std::vector<Field> const &fields) {
+  std::stringstream ss;
+  ss << j;
+  std::string strj = ss.str();
+
+  for (auto const &[key, val] : fields) {
+    std::stringstream fs;
+    fs << "\"" << key << "\":" << val;
+    std::string field = fs.str();
+
+    CHECK(strj.find(field) != std::string::npos);
+  }
+}
+
+// FIXME: Check deserialization as well. This is currently not implemented
+// because of a bug that prevents req from being properly deserialized.
+//
+// The comments below may apply to multiple test cases.
+//
+// The checks for the attributes compare the number of fields to ensure that if
+// a field is added/removed, the check fails since it may be necessary to update
+// the test in that case.
+//
+// Floating point numbers may be serialized with additional digits. Just check
+// that the digits that were provided in the initialization are present. Is it
+// even guaranteed that those digits will appear in the serialized result?
+
+TEST_CASE("AggregateAttrs") {
+  AggregateAttrs a = {42, 3.14};
+  V1AggregateAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<AggregateAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1AggregateAttrs>() == 2);
+
+  json j = v1;
+  check_fields(j, {{"lambda_bal", "3.14"}, {"n", "42"}});
+}
+
+TEST_CASE("AggregateSpec") {
+  AggregateSpecAttrs a = {42, 3.14};
+  V1AggregateSpecAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<AggregateSpecAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1AggregateSpecAttrs>() == 2);
+
+  json j = v1;
+  check_fields(j, {{"lambda_bal", "3.14"}, {"n", "42"}});
+}
+
+TEST_CASE("MultiHeadAttentionAttrs") {
+  MultiHeadAttentionAttrs a = {1, 2, 3, 4, 5.67, false, true, false};
+  V1MultiHeadAttentionAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<MultiHeadAttentionAttrs>() == 8);
+  CHECK(visit_struct::field_count<V1MultiHeadAttentionAttrs>() == 8);
+
+  json j = v1;
+  check_fields(j,
+               {{"embed_dim", "1"},
+                {"num_heads", "2"},
+                {"kdim", "3"},
+                {"vdim", "4"},
+                {"dropout", "5.67"},
+                {"bias", "false"},
+                {"add_bias_kv", "true"},
+                {"add_zero_attn", "false"}});
+}
+
+TEST_CASE("BatchMatmulAttrs") {
+  BatchMatmulAttrs a = {12, 34};
+  V1BatchMatmulAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<BatchMatmulAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1BatchMatmulAttrs>() == 2);
+
+  json j = v1;
+  check_fields(j, {{"a_seq_length_dim", "12"}, {"b_seq_length_dim", "34"}});
+}
+
+TEST_CASE("BatchNormAttrs") {
+  BatchNormAttrs a = {true};
+  V1BatchNormAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<BatchNormAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1BatchNormAttrs>() == 1);
+
+  json j = v1;
+  check_fields(j, {{"relu", "true"}});
+}
+
+TEST_CASE("BroadcastAttrs") {
+  BroadcastAttrs a = {stack_vector<int, MAX_TENSOR_DIM>()};
+  a.target_dims.push_back(1);
+  a.target_dims.push_back(2);
+  a.target_dims.push_back(3);
+  a.target_dims.push_back(4);
+  V1BroadcastAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<BroadcastAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1BroadcastAttrs>() == 1);
+
+  json j = v1;
+  check_fields(j, {{"target_dims", "[1,2,3,4]"}});
+}
+
+TEST_CASE("CastAttrs") {
+  CastAttrs a = {DataType::HALF};
+  V1CastAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<CastAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1CastAttrs>() == 1);
+
+  json j = v1;
+  check_fields(j, {{"dtype", "\"HALF\""}});
+}
+
+TEST_CASE("CombineAttrs") {
+  CombineAttrs a = {ff_dim_t(1), 2};
+  V1CombineAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<CombineAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1CombineAttrs>() == 2);
+
+  json j = v1;
+  check_fields(j, {{"combine_dim", "1"}, {"combine_degree", "2"}});
+}
+
+TEST_CASE("ConcatAttrs") {
+  ConcatAttrs a = {ff_dim_t(43)};
+  V1ConcatAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<ConcatAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1ConcatAttrs>() == 1);
+
+  json j = v1;
+  check_fields(j, {{"axis", "43"}});
+}
+
+TEST_CASE("Conv2DAttrs") {
+  Conv2DAttrs a = {1, 2, 3, 4, 5, 6, 7, 8, Activation::SIGMOID, false};
+  V1Conv2DAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<Conv2DAttrs>() == 10);
+  CHECK(visit_struct::field_count<V1Conv2DAttrs>() == 10);
+
+  json j = v1;
+  check_fields(j, {{"out_channels", "1"},
+                   {"kernel_h", "2"},
+                   {"kernel_w", "3"},
+                   {"stride_h", "4"},
+                   {"stride_w", "5"},
+                   {"padding_h", "6"},
+                   {"padding_w", "7"},
+                   {"groups", "8"},
+                   {"activation", "\"SIGMOID\""},
+                   {"use_bias", "false"}});
+}
+
+TEST_CASE("DropoutAttrs") {
+  DropoutAttrs a = {3.14, 9823749238472398ULL};
+  V1DropoutAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<DropoutAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1DropoutAttrs>() == 2);
+
+  json j = v1;
+  check_fields(j, {{"rate", "3.14"},
+                   {"seed", "9823749238472398"}});
+}
+
+TEST_CASE("ElementBinaryAttrs") {
+  ElementBinaryAttrs a = {Op::SQUEEZE, DataType::FLOAT, false, true};
+  V1ElementBinaryAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<ElementBinaryAttrs>() == 4);
+  CHECK(visit_struct::field_count<V1ElementBinaryAttrs>() == 4);
+
+  json j = v1;
+  check_fields(j, {{"should_broadcast_lhs", "false"},
+                   {"should_broadcast_rhs", "true"}});
+}
+
+TEST_CASE("ElementUnaryAttrs") {
+  ElementUnaryAttrs a = {Op::LOGICAL_NOT};
+  V1ElementUnaryAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<ElementUnaryAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1ElementUnaryAttrs>() == 1);
+
+  json j = v1;
+  check_fields(j, {{"op", "\"LOGICAL_NOT\""}});
+}
+
+TEST_CASE("ElementUnaryScalarAttrs") {
+  ElementScalarUnaryAttrs a = {Op::SCALAR_FLOOR_DIV, 2.71828};
+  V1ElementScalarUnaryAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<ElementScalarUnaryAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1ElementScalarUnaryAttrs>() == 2);
+
+  json j = v1;
+  check_fields(j, {{"op", "\"SCALAR_FLOOR_DIV\""},
+                   {"scalar", "2.71828"}});
+}
+
+TEST_CASE("EmbeddingAttrs") {
+  EmbeddingAttrs a = {1, 2, AggregateOp::SUM, DataType::DOUBLE};
+  V1EmbeddingAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<EmbeddingAttrs>() == 4);
+  CHECK(visit_struct::field_count<V1EmbeddingAttrs>() == 4);
+
+  json j = v1;
+  check_fields(j, {{"num_entries", "1"},
+                   {"out_channels", "2"},
+                   {"aggr", "\"SUM\""},
+                   {"data_type", "\"DOUBLE\""}});
+}
diff --git a/lib/pcg/test/test_tensor.cc b/lib/pcg/test/test_tensor.cc
index 7fed302958..488ec81360 100644
--- a/lib/pcg/test/test_tensor.cc
+++ b/lib/pcg/test/test_tensor.cc
@@ -17,9 +17,4 @@ TEST_CASE("Tensor") {
            nullopt,
            std::string("tensor")};
   json j = to_v1(t);
-
-  // FIXME: There is currently a bug in the serialization of tl::optional to
-  // json which puts it in an infinite loop. When that is fixed, this will
-  // actually work.
-  NOT_REACHABLE();
 }
diff --git a/lib/utils/test/src/test_json.cc b/lib/utils/test/src/test_json.cc
index dbd04005fa..7f3debda2a 100644
--- a/lib/utils/test/src/test_json.cc
+++ b/lib/utils/test/src/test_json.cc
@@ -125,7 +125,7 @@ TEST_CASE("req") {
 
     // FIXME: There is currently a bug of some sort that causes this to not
     // compile.
-    CHECK(j.get<req<char>>() == r);
+    // CHECK(j.get<req<char>>() == r);
   }
 }
 

From d780b8287abb3811fce2d042c53ddfdebc4407b5 Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Thu, 16 Nov 2023 16:19:46 -0700
Subject: [PATCH 14/15] More tests.

---
 lib/pcg/test/test_activation.cc     |  23 ++
 lib/pcg/test/test_create_grad.cc    |  15 ++
 lib/pcg/test/test_datatype.cc       |  37 +++
 lib/pcg/test/test_ff_dim_t.cc       |   9 +
 lib/pcg/test/test_initializer.cc    |  84 +++++++
 lib/pcg/test/test_operator_attrs.cc | 338 +++++++++++++++++++++++++---
 lib/pcg/test/test_param_sync.cc     |  15 ++
 lib/pcg/test/utils.cc               |  28 +++
 lib/pcg/test/utils.h                |  15 ++
 9 files changed, 529 insertions(+), 35 deletions(-)
 create mode 100644 lib/pcg/test/test_activation.cc
 create mode 100644 lib/pcg/test/test_create_grad.cc
 create mode 100644 lib/pcg/test/test_datatype.cc
 create mode 100644 lib/pcg/test/test_ff_dim_t.cc
 create mode 100644 lib/pcg/test/test_initializer.cc
 create mode 100644 lib/pcg/test/test_param_sync.cc
 create mode 100644 lib/pcg/test/utils.cc
 create mode 100644 lib/pcg/test/utils.h

diff --git a/lib/pcg/test/test_activation.cc b/lib/pcg/test/test_activation.cc
new file mode 100644
index 0000000000..0e9210f7dd
--- /dev/null
+++ b/lib/pcg/test/test_activation.cc
@@ -0,0 +1,23 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/activation.h"
+#include "utils.h"
+
+using namespace FlexFlow;
+
+TEST_CASE("Activation") {
+  V1Activation v10 = to_v1(Activation::RELU);
+  CHECK(from_v1(v10) == Activation::RELU);
+  CHECK(str(json(v10)) == "\"RELU\"");
+
+  V1Activation v11 = to_v1(Activation::SIGMOID);
+  CHECK(from_v1(v11) == Activation::SIGMOID);
+  CHECK(str(json(v11)) == "\"SIGMOID\"");
+
+  V1Activation v12 = to_v1(Activation::TANH);
+  CHECK(from_v1(v12) == Activation::TANH);
+  CHECK(str(json(v12)) == "\"TANH\"");
+
+  V1Activation v13 = to_v1(Activation::GELU);
+  CHECK(from_v1(v13) == Activation::GELU);
+  CHECK(str(json(v13)) == "\"GELU\"");
+}
diff --git a/lib/pcg/test/test_create_grad.cc b/lib/pcg/test/test_create_grad.cc
new file mode 100644
index 0000000000..ffffafd3e7
--- /dev/null
+++ b/lib/pcg/test/test_create_grad.cc
@@ -0,0 +1,15 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/create_grad.h"
+#include "utils.h"
+
+using namespace FlexFlow;
+
+TEST_CASE("CreateGrad") {
+  V1CreateGrad v10 = to_v1(CreateGrad::YES);
+  CHECK(from_v1(v10) == CreateGrad::YES);
+  CHECK(str(json(v10)) == "\"YES\"");
+
+  V1CreateGrad v11 = to_v1(CreateGrad::NO);
+  CHECK(from_v1(v11) == CreateGrad::NO);
+  CHECK(str(json(v11)) == "\"NO\"");
+}
diff --git a/lib/pcg/test/test_datatype.cc b/lib/pcg/test/test_datatype.cc
new file mode 100644
index 0000000000..b39483ce5b
--- /dev/null
+++ b/lib/pcg/test/test_datatype.cc
@@ -0,0 +1,37 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/datatype.h"
+#include "utils.h"
+
+using namespace FlexFlow;
+
+#define TEST_MEMBER(m, exp)                                                    \
+  do {                                                                         \
+    V1DataType v10 = to_v1(m);                                                 \
+    CHECK(from_v1(v10) == m);                                                  \
+    CHECK(str(json(v10)) == "\"" exp "\"");                                    \
+  } while (0)
+
+TEST_CASE("DataType") {
+  TEST_MEMBER(DataType::BOOL, "BOOL");
+  TEST_MEMBER(DataType::INT32, "INT32");
+  TEST_MEMBER(DataType::INT64, "INT64");
+  TEST_MEMBER(DataType::HALF, "HALF");
+  TEST_MEMBER(DataType::FLOAT, "FLOAT");
+  TEST_MEMBER(DataType::DOUBLE, "DOUBLE");
+}
+
+TEST_CASE("DataTypeValue") {
+  DataTypeValue b = true;
+  DataTypeValue i32 = (int32_t)32;
+  DataTypeValue i64 = (int64_t)64L;
+  DataTypeValue f16 = half(3.14);
+  DataTypeValue f32 = (float)2.71828;
+  DataTypeValue f64 = (double)1.414235;
+
+  CHECK(from_v1(to_v1(b)) == b);
+  CHECK(from_v1(to_v1(i32)) == i32);
+  CHECK(from_v1(to_v1(i64)) == i64);
+  CHECK(from_v1(to_v1(f16)) == f16);
+  CHECK(from_v1(to_v1(f32)) == f32);
+  CHECK(from_v1(to_v1(f64)) == f64);
+}
diff --git a/lib/pcg/test/test_ff_dim_t.cc b/lib/pcg/test/test_ff_dim_t.cc
new file mode 100644
index 0000000000..8c10173621
--- /dev/null
+++ b/lib/pcg/test/test_ff_dim_t.cc
@@ -0,0 +1,9 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/ff_dim.h"
+#include "utils.h"
+
+using namespace FlexFlow;
+
+TEST_CASE("ff_dim_t") {
+  CHECK(from_v1(to_v1(ff_dim_t(11))) == 11);
+}
diff --git a/lib/pcg/test/test_initializer.cc b/lib/pcg/test/test_initializer.cc
new file mode 100644
index 0000000000..ed94c8946e
--- /dev/null
+++ b/lib/pcg/test/test_initializer.cc
@@ -0,0 +1,84 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/initializer.h"
+#include "utils.h"
+#include "utils/containers.h"
+#include "utils/required.h"
+
+using namespace FlexFlow;
+
+TEST_CASE("GlorotInitializer") {
+  GlorotUniform i = {11};
+  V1GlorotInitializer v1 = to_v1(i);
+
+  // CHECK(from_v1(v1) == i);
+
+  json j = v1;
+  check_fields(j, {{"seed", "11"}});
+}
+
+TEST_CASE("ZeroInitializer") {
+  ZeroInitializer i;
+  V1ZeroInitializer v1 = to_v1(i);
+
+  // CHECK(from_v1(v1) == i);
+
+  json j = v1;
+  check_fields(j, {});
+}
+
+TEST_CASE("UniformInitializer") {
+  UniformInitializer i = {77, 9.1, 4.3};
+  V1UniformInitializer v1 = to_v1(i);
+
+  // CHECK(from_v1(v1) == i);
+
+  json j = v1;
+  check_fields(j, {{"seed", "77"}, {"min_val", "9.1"}, {"max_val", "4.3"}});
+}
+
+TEST_CASE("NormInitializer") {
+  NormInitializer i = {77, 9.1, 4.3};
+  V1NormInitializer v1 = to_v1(i);
+
+  // CHECK(from_v1(v1) == i);
+
+  json j = v1;
+  check_fields(j, {{"seed", "77"}, {"mean", "9.1"}, {"stddev", "4.3"}});
+}
+
+TEST_CASE("ConstantInitializer") {
+  ConstantInitializer i = {32};
+  V1ConstantInitializer v1 = to_v1(i);
+
+  // CHECK(from_v1(v1) == i);
+
+  json j = v1;
+  // The value field is a variant. Don't try to check for anything in the
+  // serialization because that will have been tested elsewhere. Just check that
+  // the value of "value" is an object which is good enough.
+  check_fields(j, {{"value", "{"}});
+}
+
+TEST_CASE("Initializer") {
+  Initializer ig = GlorotUniform{11};
+  V1Initializer v1g = to_v1(ig);
+  // CHECK(from_v1(v1g) == ig);
+
+  Initializer iz = ZeroInitializer{};
+  V1Initializer v1z = to_v1(iz);
+  // CHECK(from_v1(v1z) == iz);
+
+  Initializer iu = UniformInitializer{77, 9.1, 4.3};
+  V1Initializer v1u = to_v1(iu);
+  // CHECK(from_v1(v1u) == iu);
+
+  Initializer in = NormInitializer{77, 9.1, 4.3};
+  V1Initializer v1n = to_v1(in);
+  // CHECK(from_v1(v1n) == in);
+
+  Initializer ic = ConstantInitializer{32};
+  V1Initializer v1c = to_v1(ic);
+  // CHECK(from_v1(v1c) == ic);
+
+  // No need to check the JSON because Initializer is just a variant.
+}
diff --git a/lib/pcg/test/test_operator_attrs.cc b/lib/pcg/test/test_operator_attrs.cc
index 5e19cbeac3..b1036b13f0 100644
--- a/lib/pcg/test/test_operator_attrs.cc
+++ b/lib/pcg/test/test_operator_attrs.cc
@@ -1,26 +1,12 @@
 #include "doctest.h"
 #include "pcg/file_format/v1/operator_attrs.h"
+#include "utils.h"
 #include "utils/containers.h"
 #include "utils/json.h"
 #include "utils/required.h"
 
 using namespace FlexFlow;
 
-using Field = std::pair<std::string, std::string>;
-static void check_fields(json const &j, std::vector<Field> const &fields) {
-  std::stringstream ss;
-  ss << j;
-  std::string strj = ss.str();
-
-  for (auto const &[key, val] : fields) {
-    std::stringstream fs;
-    fs << "\"" << key << "\":" << val;
-    std::string field = fs.str();
-
-    CHECK(strj.find(field) != std::string::npos);
-  }
-}
-
 // FIXME: Check deserialization as well. This is currently not implemented
 // because of a bug that prevents req from being properly deserialized.
 //
@@ -40,6 +26,7 @@ TEST_CASE("AggregateAttrs") {
 
   CHECK(visit_struct::field_count<AggregateAttrs>() == 2);
   CHECK(visit_struct::field_count<V1AggregateAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"lambda_bal", "3.14"}, {"n", "42"}});
@@ -51,6 +38,7 @@ TEST_CASE("AggregateSpec") {
 
   CHECK(visit_struct::field_count<AggregateSpecAttrs>() == 2);
   CHECK(visit_struct::field_count<V1AggregateSpecAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"lambda_bal", "3.14"}, {"n", "42"}});
@@ -62,6 +50,7 @@ TEST_CASE("MultiHeadAttentionAttrs") {
 
   CHECK(visit_struct::field_count<MultiHeadAttentionAttrs>() == 8);
   CHECK(visit_struct::field_count<V1MultiHeadAttentionAttrs>() == 8);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
@@ -81,6 +70,7 @@ TEST_CASE("BatchMatmulAttrs") {
 
   CHECK(visit_struct::field_count<BatchMatmulAttrs>() == 2);
   CHECK(visit_struct::field_count<V1BatchMatmulAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"a_seq_length_dim", "12"}, {"b_seq_length_dim", "34"}});
@@ -92,6 +82,7 @@ TEST_CASE("BatchNormAttrs") {
 
   CHECK(visit_struct::field_count<BatchNormAttrs>() == 1);
   CHECK(visit_struct::field_count<V1BatchNormAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"relu", "true"}});
@@ -107,6 +98,7 @@ TEST_CASE("BroadcastAttrs") {
 
   CHECK(visit_struct::field_count<BroadcastAttrs>() == 1);
   CHECK(visit_struct::field_count<V1BroadcastAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"target_dims", "[1,2,3,4]"}});
@@ -118,6 +110,7 @@ TEST_CASE("CastAttrs") {
 
   CHECK(visit_struct::field_count<CastAttrs>() == 1);
   CHECK(visit_struct::field_count<V1CastAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"dtype", "\"HALF\""}});
@@ -129,6 +122,7 @@ TEST_CASE("CombineAttrs") {
 
   CHECK(visit_struct::field_count<CombineAttrs>() == 2);
   CHECK(visit_struct::field_count<V1CombineAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"combine_dim", "1"}, {"combine_degree", "2"}});
@@ -140,6 +134,7 @@ TEST_CASE("ConcatAttrs") {
 
   CHECK(visit_struct::field_count<ConcatAttrs>() == 1);
   CHECK(visit_struct::field_count<V1ConcatAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"axis", "43"}});
@@ -151,18 +146,20 @@ TEST_CASE("Conv2DAttrs") {
 
   CHECK(visit_struct::field_count<Conv2DAttrs>() == 10);
   CHECK(visit_struct::field_count<V1Conv2DAttrs>() == 10);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
-  check_fields(j, {{"out_channels", "1"},
-                   {"kernel_h", "2"},
-                   {"kernel_w", "3"},
-                   {"stride_h", "4"},
-                   {"stride_w", "5"},
-                   {"padding_h", "6"},
-                   {"padding_w", "7"},
-                   {"groups", "8"},
-                   {"activation", "\"SIGMOID\""},
-                   {"use_bias", "false"}});
+  check_fields(j,
+               {{"out_channels", "1"},
+                {"kernel_h", "2"},
+                {"kernel_w", "3"},
+                {"stride_h", "4"},
+                {"stride_w", "5"},
+                {"padding_h", "6"},
+                {"padding_w", "7"},
+                {"groups", "8"},
+                {"activation", "\"SIGMOID\""},
+                {"use_bias", "false"}});
 }
 
 TEST_CASE("DropoutAttrs") {
@@ -171,10 +168,10 @@ TEST_CASE("DropoutAttrs") {
 
   CHECK(visit_struct::field_count<DropoutAttrs>() == 2);
   CHECK(visit_struct::field_count<V1DropoutAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
-  check_fields(j, {{"rate", "3.14"},
-                   {"seed", "9823749238472398"}});
+  check_fields(j, {{"rate", "3.14"}, {"seed", "9823749238472398"}});
 }
 
 TEST_CASE("ElementBinaryAttrs") {
@@ -183,10 +180,11 @@ TEST_CASE("ElementBinaryAttrs") {
 
   CHECK(visit_struct::field_count<ElementBinaryAttrs>() == 4);
   CHECK(visit_struct::field_count<V1ElementBinaryAttrs>() == 4);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
-  check_fields(j, {{"should_broadcast_lhs", "false"},
-                   {"should_broadcast_rhs", "true"}});
+  check_fields(
+      j, {{"should_broadcast_lhs", "false"}, {"should_broadcast_rhs", "true"}});
 }
 
 TEST_CASE("ElementUnaryAttrs") {
@@ -195,6 +193,7 @@ TEST_CASE("ElementUnaryAttrs") {
 
   CHECK(visit_struct::field_count<ElementUnaryAttrs>() == 1);
   CHECK(visit_struct::field_count<V1ElementUnaryAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"op", "\"LOGICAL_NOT\""}});
@@ -206,10 +205,20 @@ TEST_CASE("ElementUnaryScalarAttrs") {
 
   CHECK(visit_struct::field_count<ElementScalarUnaryAttrs>() == 2);
   CHECK(visit_struct::field_count<V1ElementScalarUnaryAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
-  check_fields(j, {{"op", "\"SCALAR_FLOOR_DIV\""},
-                   {"scalar", "2.71828"}});
+  check_fields(j, {{"op", "\"SCALAR_FLOOR_DIV\""}, {"scalar", "2.71828"}});
+}
+
+TEST_CASE("AggregateOp") {
+  V1AggregateOp v1Sum = to_v1(AggregateOp::SUM);
+  CHECK(from_v1(v1Sum) == AggregateOp::SUM);
+  CHECK(str(json(v1Sum)) == "\"SUM\"");
+
+  V1AggregateOp v1Avg = to_v1(AggregateOp::AVG);
+  CHECK(from_v1(v1Avg) == AggregateOp::AVG);
+  CHECK(str(json(v1Avg)) == "\"AVG\"");
 }
 
 TEST_CASE("EmbeddingAttrs") {
@@ -218,10 +227,269 @@ TEST_CASE("EmbeddingAttrs") {
 
   CHECK(visit_struct::field_count<EmbeddingAttrs>() == 4);
   CHECK(visit_struct::field_count<V1EmbeddingAttrs>() == 4);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j,
+               {{"num_entries", "1"},
+                {"out_channels", "2"},
+                {"aggr", "\"SUM\""},
+                {"data_type", "\"DOUBLE\""}});
+}
+
+TEST_CASE("FlatAttrs") {
+  FlatAttrs a;
+  V1FlatAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<FlatAttrs>() == 0);
+  CHECK(visit_struct::field_count<V1FlatAttrs>() == 0);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {});
+}
+
+TEST_CASE("GatherAttrs") {
+  GatherAttrs a = {ff_dim_t(42)};
+  V1GatherAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<GatherAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1GatherAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"dim", "42"}});
+}
+
+TEST_CASE("Group_byAttrs") {
+  Group_byAttrs a = {11, 3.14};
+  V1Group_byAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<Group_byAttrs>() == 2);
+  CHECK(visit_struct::field_count<V1Group_byAttrs>() == 2);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"n", "11"}, {"alpha", "3.14"}});
+}
+
+TEST_CASE("InputAttrs") {
+  InputAttrs a;
+  V1InputAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<InputAttrs>() == 0);
+  CHECK(visit_struct::field_count<V1InputAttrs>() == 0);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {});
+}
+
+TEST_CASE("LayerNormAttrs") {
+  LayerNormAttrs a = {stack_vector<ff_dim_t, MAX_TENSOR_DIM>(), false, 2.71828};
+  a.axes.push_back(ff_dim_t(19));
+  a.axes.push_back(ff_dim_t(29));
+  a.axes.push_back(ff_dim_t(39));
+  V1LayerNormAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<LayerNormAttrs>() == 3);
+  CHECK(visit_struct::field_count<V1LayerNormAttrs>() == 3);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j,
+               {{"axes", "[19,29,39]"},
+                {"elementwise_affine", "false"},
+                {"eps", "2.71828"}});
+}
+
+TEST_CASE("L1RegularizerAttrs") {
+  L1RegularizerAttrs a = {3.14159};
+  V1L1RegularizerAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<L1RegularizerAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1L1RegularizerAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"lambda", "3.14159"}});
+}
+
+TEST_CASE("L2RegularizerAttrs") {
+  L2RegularizerAttrs a = {3.14159};
+  V1L2RegularizerAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<L2RegularizerAttrs>() == 1);
+  CHECK(visit_struct::field_count<V1L2RegularizerAttrs>() == 1);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"lambda", "3.14159"}});
+}
+
+TEST_CASE("LinearAttrs") {
+  L1RegularizerAttrs r = {1234.567};
+  LinearAttrs a = {11, false, DataType::HALF, Activation::TANH, r};
+  V1LinearAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<LinearAttrs>() == 5);
+  CHECK(visit_struct::field_count<V1LinearAttrs>() == 5);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j,
+               {{"out_channels", "11"},
+                {"use_bias", "false"},
+                {"data_type", "\"HALF\""},
+                {"activation", "\"TANH\""},
+                {"regularizer",
+                 "{\"index\":0,\"type\":\"::FlexFlow::V1L1RegularizerAttrs\","
+                 "\"value\":{\"lambda\":1234.567"}});
+}
+
+TEST_CASE("NoopAttrs") {
+  NoopAttrs a;
+  V1NoopAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<NoopAttrs>() == 0);
+  CHECK(visit_struct::field_count<V1NoopAttrs>() == 0);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {});
+}
+
+TEST_CASE("PoolOp") {
+  V1PoolOp v1Max = to_v1(PoolOp::MAX);
+  CHECK(from_v1(v1Max) == PoolOp::MAX);
+  CHECK(str(json(v1Max)) == "\"MAX\"");
+
+  V1PoolOp v1Avg = to_v1(PoolOp::AVG);
+  CHECK(from_v1(v1Avg) == PoolOp::AVG);
+  CHECK(str(json(v1Avg)) == "\"AVG\"");
+}
+
+TEST_CASE("Pool2DAttrs") {
+  Pool2DAttrs a = {1, 2, 3, 4, 5, 6, PoolOp::MAX, Activation::RELU};
+  V1Pool2DAttrs v1 = to_v1(a);
+
+  CHECK(visit_struct::field_count<Pool2DAttrs>() == 8);
+  CHECK(visit_struct::field_count<V1Pool2DAttrs>() == 8);
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j,
+               {{"kernel_h", "1"},
+                {"kernel_w", "2"},
+                {"stride_h", "3"},
+                {"stride_w", "4"},
+                {"padding_h", "5"},
+                {"padding_w", "6"},
+                {"pool_type", "\"MAX\""},
+                {"activation", "\"RELU\""}});
+}
+
+TEST_CASE("ReduceAttrs") {
+  ReduceAttrs a = {
+      stack_vector<ff_dim_t, MAX_TENSOR_DIM>(), Op::LEAKYRELU, true};
+  a.axes.push_back(ff_dim_t(19));
+  a.axes.push_back(ff_dim_t(29));
+  a.axes.push_back(ff_dim_t(39));
+  V1ReduceAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j,
+               {{"axes", "[19,29,39]"},
+                {"op_type", "\"LEAKYRELU\""},
+                {"keepdims", "true"}});
+}
+
+TEST_CASE("ReductionAttrs") {
+  ReductionAttrs a = {ff_dim_t(66), ff_dim_t(77)};
+  V1ReductionAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"reduction_dim", "66"}, {"reduction_degree", "77"}});
+}
+
+TEST_CASE("RepartitionAttrs") {
+  RepartitionAttrs a = {ff_dim_t(66), ff_dim_t(77)};
+  V1RepartitionAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"repartition_dim", "66"}, {"repartition_degree", "77"}});
+}
+
+TEST_CASE("ReplicateAttrs") {
+  ReplicateAttrs a = {ff_dim_t(66), ff_dim_t(77)};
+  V1ReplicateAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"replicate_dim", "66"}, {"replicate_degree", "77"}});
+}
+
+TEST_CASE("ReshapeAttrs") {
+  // TODO: IMPLEMENT THIS.
+}
+
+TEST_CASE("ReverseAttrs") {
+  ReverseAttrs a = {ff_dim_t(11)};
+  V1ReverseAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"axis", "11"}});
+}
+
+TEST_CASE("SoftmaxAttrs") {
+  SoftmaxAttrs a = {ff_dim_t(37)};
+  V1SoftmaxAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"dim", "37"}});
+}
+
+TEST_CASE("SplitAttrs") {
+  SplitAttrs a = {stack_vector<int, MAX_NUM_OUTPUTS>(), ff_dim_t(97)};
+  a.splits.push_back(53);
+  a.splits.push_back(67);
+  V1SplitAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"splits", "[53,67]"}, {"axis", "97"}});
+}
+
+TEST_CASE("TopKAttrs") {
+  TopKAttrs a = {17, true};
+  V1TopKAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
+
+  json j = v1;
+  check_fields(j, {{"k", "17"}, {"sorted", "true"}});
+}
+
+TEST_CASE("TransposeAttrs") {
+  TransposeAttrs a = {stack_vector<ff_dim_t, MAX_TENSOR_DIM>()};
+  a.perm.push_back(ff_dim_t(3));
+  a.perm.push_back(ff_dim_t(43));
+  V1TransposeAttrs v1 = to_v1(a);
+
+  // CHECK(from_v1(v1) == a);
 
   json j = v1;
-  check_fields(j, {{"num_entries", "1"},
-                   {"out_channels", "2"},
-                   {"aggr", "\"SUM\""},
-                   {"data_type", "\"DOUBLE\""}});
+  check_fields(j, {{"perm", "[3,43]"}});
 }
diff --git a/lib/pcg/test/test_param_sync.cc b/lib/pcg/test/test_param_sync.cc
new file mode 100644
index 0000000000..5115a28a2b
--- /dev/null
+++ b/lib/pcg/test/test_param_sync.cc
@@ -0,0 +1,15 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/param_sync.h"
+#include "utils.h"
+
+using namespace FlexFlow;
+
+TEST_CASE("ParamSync") {
+  V1ParamSync v10 = to_v1(ParamSync::PS);
+  CHECK(from_v1(v10) == ParamSync::PS);
+  CHECK(str(json(v10)) == "\"PARAM_SERVER\"");
+
+  V1ParamSync v11 = to_v1(ParamSync::NCCL);
+  CHECK(from_v1(v11) == ParamSync::NCCL);
+  CHECK(str(json(v11)) == "\"NCCL\"");
+}
diff --git a/lib/pcg/test/utils.cc b/lib/pcg/test/utils.cc
new file mode 100644
index 0000000000..fe6220a9c4
--- /dev/null
+++ b/lib/pcg/test/utils.cc
@@ -0,0 +1,28 @@
+#include "utils.h"
+#include "doctest.h"
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+std::string str(json const &j) {
+  std::stringstream ss;
+  ss << j;
+  return ss.str();
+}
+
+void check_fields(json const &j, std::vector<Field> const &fields) {
+  std::string strj = str(j);
+  if (fields.size()) {
+    for (auto const &[key, val] : fields) {
+      std::stringstream fs;
+      fs << "\"" << key << "\":" << val;
+      std::string field = fs.str();
+
+      CHECK(strj.find(field) != std::string::npos);
+    }
+  } else {
+    CHECK(strj == "null");
+  }
+}
+
+} // namespace FlexFlow
diff --git a/lib/pcg/test/utils.h b/lib/pcg/test/utils.h
new file mode 100644
index 0000000000..49494662b1
--- /dev/null
+++ b/lib/pcg/test/utils.h
@@ -0,0 +1,15 @@
+#ifndef _FLEXFLOW_PCG_TEST_UTILS_H
+#define _FLEXFLOW_PCG_TEST_UTILS_H
+
+#include "utils/json.h"
+
+namespace FlexFlow {
+
+std::string str(json const &j);
+
+using Field = std::pair<std::string, std::string>;
+void check_fields(json const &j, std::vector<Field> const &fields);
+
+} // namespace FlexFlow
+
+#endif // _FLEXFLOW_PCG_TEST_UTILS_H

From 992c78914a82fcf955f872596b97315114302c4f Mon Sep 17 00:00:00 2001
From: Tarun Prabhu <tarun@lanl.gov>
Date: Mon, 27 Nov 2023 10:50:59 -0700
Subject: [PATCH 15/15] Add more tests. Make operators fmtable since that is
 needed by the tests. Add an explicit call to join_strings in the FlexFlow
 namespace in the fmt.

---
 lib/op-attrs/include/op-attrs/datatype.h      |  26 +++
 lib/op-attrs/include/op-attrs/ops/aggregate.h |   4 +-
 .../include/op-attrs/ops/aggregate_spec.h     |   4 +-
 lib/op-attrs/include/op-attrs/ops/attention.h |   4 +-
 .../include/op-attrs/ops/batch_matmul.h       |   3 +-
 .../include/op-attrs/ops/batch_norm.h         |   5 +-
 lib/op-attrs/include/op-attrs/ops/broadcast.h |   3 +-
 lib/op-attrs/include/op-attrs/ops/cast.h      |   4 +-
 lib/op-attrs/include/op-attrs/ops/combine.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/concat.h    |   2 +
 lib/op-attrs/include/op-attrs/ops/conv_2d.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/dropout.h   |   2 +
 .../include/op-attrs/ops/element_binary.h     |   2 +
 .../include/op-attrs/ops/element_unary.h      |   4 +
 lib/op-attrs/include/op-attrs/ops/embedding.h |   2 +
 lib/op-attrs/include/op-attrs/ops/flat.h      |   2 +
 lib/op-attrs/include/op-attrs/ops/gather.h    |   2 +
 lib/op-attrs/include/op-attrs/ops/groupby.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/input.h     |   2 +
 .../include/op-attrs/ops/layer_norm.h         |   2 +
 lib/op-attrs/include/op-attrs/ops/linear.h    |   6 +
 .../include/op-attrs/ops/loss_functions.h     |   4 +
 lib/op-attrs/include/op-attrs/ops/noop.h      |   2 +
 lib/op-attrs/include/op-attrs/ops/pool_2d.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/reduce.h    |   2 +
 lib/op-attrs/include/op-attrs/ops/reduction.h |   2 +
 .../include/op-attrs/ops/repartition.h        |   2 +
 lib/op-attrs/include/op-attrs/ops/replicate.h |   2 +
 lib/op-attrs/include/op-attrs/ops/reshape.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/reverse.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/softmax.h   |   2 +
 lib/op-attrs/include/op-attrs/ops/split.h     |   2 +
 lib/op-attrs/include/op-attrs/ops/topk.h      |   2 +
 lib/op-attrs/include/op-attrs/ops/transpose.h |   2 +
 lib/op-attrs/include/op-attrs/parallel_dim.h  |   2 +
 .../include/op-attrs/parallel_tensor_dims.h   |  16 ++
 .../include/op-attrs/parallel_tensor_shape.h  |   2 +
 lib/op-attrs/include/op-attrs/tensor_shape.h  |  18 +++
 lib/pcg/include/pcg/initializer.h             |  37 +++++
 lib/pcg/include/pcg/parallel_tensor.h         |   2 +
 lib/pcg/include/pcg/tensor.h                  |   2 +
 lib/pcg/src/file_format/v1/parallel_tensor.cc |   2 +-
 lib/pcg/test/doctest.h                        |   2 +-
 lib/pcg/test/test_op.cc                       | 107 ++++++++++++
 lib/pcg/test/test_operator_attrs.cc           | 152 ++++++++----------
 lib/pcg/test/test_parallel_tensor.cc          | 102 ++++++++++++
 lib/pcg/test/test_tensor.cc                   |  50 +++++-
 lib/utils/include/utils/fmt.h                 |   4 +-
 48 files changed, 509 insertions(+), 102 deletions(-)
 create mode 100644 lib/pcg/test/test_op.cc
 create mode 100644 lib/pcg/test/test_parallel_tensor.cc

diff --git a/lib/op-attrs/include/op-attrs/datatype.h b/lib/op-attrs/include/op-attrs/datatype.h
index 2417f37fdb..53ad2ae679 100644
--- a/lib/op-attrs/include/op-attrs/datatype.h
+++ b/lib/op-attrs/include/op-attrs/datatype.h
@@ -94,6 +94,32 @@ struct formatter<::FlexFlow::DataType> : formatter<string_view> {
   }
 };
 
+template <>
+struct formatter<::FlexFlow::DataTypeValue> : formatter<string_view> {
+  template <typename FormatContext>
+  auto format(::FlexFlow::DataTypeValue v, FormatContext &ctx)
+      -> decltype(ctx.out()) {
+    using namespace FlexFlow;
+
+    string_view s = "unknown";
+    if (auto const *f32 = get_if<real_type<DataType::FLOAT>>(&v)) {
+      s = fmt::to_string(*f32);
+    } else if (auto const *f64 = get_if<real_type<DataType::DOUBLE>>(&v)) {
+      s = fmt::to_string(*f64);
+    } else if (auto const *i32 = get_if<real_type<DataType::INT32>>(&v)) {
+      s = fmt::to_string(*i32);
+    } else if (auto const *i64 = get_if<real_type<DataType::INT64>>(&v)) {
+      s = fmt::to_string(*i64);
+    } else if (auto const *h = get_if<real_type<DataType::HALF>>(&v)) {
+      s = fmt::to_string(*h);
+    } else if (auto const *b = get_if<real_type<DataType::BOOL>>(&v)) {
+      s = fmt::to_string(*b);
+    }
+    return formatter<string_view>::format(s, ctx);
+  }
+};
+
 } // namespace fmt
+// namespace fmt
 
 #endif
diff --git a/lib/op-attrs/include/op-attrs/ops/aggregate.h b/lib/op-attrs/include/op-attrs/ops/aggregate.h
index faf16472b1..224f65e19c 100644
--- a/lib/op-attrs/include/op-attrs/ops/aggregate.h
+++ b/lib/op-attrs/include/op-attrs/ops/aggregate.h
@@ -16,6 +16,9 @@ struct AggregateAttrs {
   req<float> lambda_bal;
 };
 FF_VISITABLE_STRUCT(AggregateAttrs, n, lambda_bal);
+FF_VISIT_FMTABLE(AggregateAttrs);
+CHECK_FMTABLE(AggregateAttrs);
+CHECK_VALID_OP_ATTR(AggregateAttrs);
 
 DataType get_datatype(AggregateAttrs const &);
 bool is_valid(AggregateAttrs const &,
@@ -32,7 +35,6 @@ ParallelTensorShape
                      ParallelTensorShape const &full_gate_gradients,
                      std::vector<ParallelTensorShape> const &exp_preds);
 
-CHECK_VALID_OP_ATTR(AggregateAttrs);
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/op-attrs/include/op-attrs/ops/aggregate_spec.h b/lib/op-attrs/include/op-attrs/ops/aggregate_spec.h
index 8373452dfa..76f472d922 100644
--- a/lib/op-attrs/include/op-attrs/ops/aggregate_spec.h
+++ b/lib/op-attrs/include/op-attrs/ops/aggregate_spec.h
@@ -12,6 +12,9 @@ struct AggregateSpecAttrs {
   req<float> lambda_bal;
 };
 FF_VISITABLE_STRUCT(AggregateSpecAttrs, n, lambda_bal);
+FF_VISIT_FMTABLE(AggregateSpecAttrs);
+CHECK_FMTABLE(AggregateSpecAttrs);
+CHECK_VALID_OP_ATTR(AggregateSpecAttrs);
 
 ParallelTensorShape
     get_output_shape(AggregateSpecAttrs const &,
@@ -21,7 +24,6 @@ ParallelTensorShape
                      ParallelTensorShape const &gate_gradients_full,
                      std::vector<ParallelTensorShape> const &exp_preds);
 
-CHECK_VALID_OP_ATTR(AggregateSpecAttrs);
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/op-attrs/include/op-attrs/ops/attention.h b/lib/op-attrs/include/op-attrs/ops/attention.h
index ec3e592607..e270cf86af 100644
--- a/lib/op-attrs/include/op-attrs/ops/attention.h
+++ b/lib/op-attrs/include/op-attrs/ops/attention.h
@@ -21,6 +21,9 @@ FF_VISITABLE_STRUCT(MultiHeadAttentionAttrs,
                     bias,
                     add_bias_kv,
                     add_zero_attn);
+FF_VISIT_FMTABLE(MultiHeadAttentionAttrs);
+CHECK_FMTABLE(MultiHeadAttentionAttrs);
+CHECK_VALID_OP_ATTR(MultiHeadAttentionAttrs);
 
 template <typename TensorType>
 struct MultiHeadAttentionInputs
@@ -70,7 +73,6 @@ ParallelTensorShape
 TensorShape get_output_shape(MultiHeadAttentionAttrs const &,
                              MultiHeadAttentionInputs<TensorShape> const &);
 
-CHECK_VALID_OP_ATTR(MultiHeadAttentionAttrs);
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/op-attrs/include/op-attrs/ops/batch_matmul.h b/lib/op-attrs/include/op-attrs/ops/batch_matmul.h
index c74824570c..ebd8d32c63 100644
--- a/lib/op-attrs/include/op-attrs/ops/batch_matmul.h
+++ b/lib/op-attrs/include/op-attrs/ops/batch_matmul.h
@@ -11,7 +11,8 @@ struct BatchMatmulAttrs {
   req<int> a_seq_length_dim, b_seq_length_dim;
 };
 FF_VISITABLE_STRUCT(BatchMatmulAttrs, a_seq_length_dim, b_seq_length_dim);
-
+FF_VISIT_FMTABLE(BatchMatmulAttrs);
+CHECK_FMTABLE(BatchMatmulAttrs);
 CHECK_VALID_OP_ATTR(BatchMatmulAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/batch_norm.h b/lib/op-attrs/include/op-attrs/ops/batch_norm.h
index 4ec823d4ae..200d679d97 100644
--- a/lib/op-attrs/include/op-attrs/ops/batch_norm.h
+++ b/lib/op-attrs/include/op-attrs/ops/batch_norm.h
@@ -11,11 +11,12 @@ struct BatchNormAttrs {
   req<bool> relu;
 };
 FF_VISITABLE_STRUCT(BatchNormAttrs, relu);
+FF_VISIT_FMTABLE(BatchNormAttrs);
+CHECK_FMTABLE(BatchNormAttrs);
+CHECK_VALID_OP_ATTR(BatchNormAttrs);
 
 ParallelTensorShape get_output_shape(BatchNormAttrs const &);
 
-CHECK_VALID_OP_ATTR(BatchNormAttrs);
-
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/op-attrs/include/op-attrs/ops/broadcast.h b/lib/op-attrs/include/op-attrs/ops/broadcast.h
index 433bf23241..c38fe667ac 100644
--- a/lib/op-attrs/include/op-attrs/ops/broadcast.h
+++ b/lib/op-attrs/include/op-attrs/ops/broadcast.h
@@ -11,7 +11,8 @@ struct BroadcastAttrs {
   req<stack_vector<int, MAX_TENSOR_DIM>> target_dims;
 };
 FF_VISITABLE_STRUCT(BroadcastAttrs, target_dims);
-
+FF_VISIT_FMTABLE(BroadcastAttrs);
+CHECK_FMTABLE(BroadcastAttrs);
 CHECK_VALID_OP_ATTR(BroadcastAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/cast.h b/lib/op-attrs/include/op-attrs/ops/cast.h
index 63563f8df8..2d02c920db 100644
--- a/lib/op-attrs/include/op-attrs/ops/cast.h
+++ b/lib/op-attrs/include/op-attrs/ops/cast.h
@@ -12,8 +12,10 @@ struct CastAttrs {
   req<DataType> dtype;
 };
 FF_VISITABLE_STRUCT(CastAttrs, dtype);
-
+FF_VISIT_FMTABLE(CastAttrs);
+CHECK_FMTABLE(CastAttrs);
 CHECK_VALID_OP_ATTR(CastAttrs);
+
 } // namespace FlexFlow
 
 #endif
diff --git a/lib/op-attrs/include/op-attrs/ops/combine.h b/lib/op-attrs/include/op-attrs/ops/combine.h
index deaba9e093..c94fbb0dfa 100644
--- a/lib/op-attrs/include/op-attrs/ops/combine.h
+++ b/lib/op-attrs/include/op-attrs/ops/combine.h
@@ -13,6 +13,8 @@ struct CombineAttrs {
   req<int> combine_degree;
 };
 FF_VISITABLE_STRUCT(CombineAttrs, combine_dim, combine_degree);
+FF_VISIT_FMTABLE(CombineAttrs);
+CHECK_FMTABLE(CombineAttrs);
 CHECK_VALID_OP_ATTR(CombineAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/concat.h b/lib/op-attrs/include/op-attrs/ops/concat.h
index b9bd14a231..fc55d3ea45 100644
--- a/lib/op-attrs/include/op-attrs/ops/concat.h
+++ b/lib/op-attrs/include/op-attrs/ops/concat.h
@@ -12,6 +12,8 @@ struct ConcatAttrs {
   ff_dim_t axis;
 };
 FF_VISITABLE_STRUCT(ConcatAttrs, axis);
+FF_VISIT_FMTABLE(ConcatAttrs);
+CHECK_FMTABLE(ConcatAttrs);
 CHECK_VALID_OP_ATTR(ConcatAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/conv_2d.h b/lib/op-attrs/include/op-attrs/ops/conv_2d.h
index 3034dc8c62..12437c94bc 100644
--- a/lib/op-attrs/include/op-attrs/ops/conv_2d.h
+++ b/lib/op-attrs/include/op-attrs/ops/conv_2d.h
@@ -27,6 +27,8 @@ FF_VISITABLE_STRUCT(Conv2DAttrs,
                     groups,
                     activation,
                     use_bias);
+FF_VISIT_FMTABLE(Conv2DAttrs);
+CHECK_FMTABLE(Conv2DAttrs);
 CHECK_VALID_OP_ATTR(Conv2DAttrs);
 
 TensorShape get_kernel_shape(Conv2DAttrs const &, TensorShape const &);
diff --git a/lib/op-attrs/include/op-attrs/ops/dropout.h b/lib/op-attrs/include/op-attrs/ops/dropout.h
index 8e0049f526..34d76b69ee 100644
--- a/lib/op-attrs/include/op-attrs/ops/dropout.h
+++ b/lib/op-attrs/include/op-attrs/ops/dropout.h
@@ -12,6 +12,8 @@ struct DropoutAttrs {
   req<unsigned long long> seed;
 };
 FF_VISITABLE_STRUCT(DropoutAttrs, rate, seed);
+FF_VISIT_FMTABLE(DropoutAttrs);
+CHECK_FMTABLE(DropoutAttrs);
 CHECK_VALID_OP_ATTR(DropoutAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/element_binary.h b/lib/op-attrs/include/op-attrs/ops/element_binary.h
index c4a096166d..a8a48529ed 100644
--- a/lib/op-attrs/include/op-attrs/ops/element_binary.h
+++ b/lib/op-attrs/include/op-attrs/ops/element_binary.h
@@ -20,6 +20,8 @@ FF_VISITABLE_STRUCT(ElementBinaryAttrs,
                     compute_type,
                     should_broadcast_lhs,
                     should_broadcast_rhs);
+FF_VISIT_FMTABLE(ElementBinaryAttrs);
+CHECK_FMTABLE(ElementBinaryAttrs);
 CHECK_VALID_OP_ATTR(ElementBinaryAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/element_unary.h b/lib/op-attrs/include/op-attrs/ops/element_unary.h
index 1b72e83cb5..cbca9b01b3 100644
--- a/lib/op-attrs/include/op-attrs/ops/element_unary.h
+++ b/lib/op-attrs/include/op-attrs/ops/element_unary.h
@@ -14,12 +14,16 @@ struct ElementScalarUnaryAttrs {
   req<float> scalar;
 };
 FF_VISITABLE_STRUCT(ElementScalarUnaryAttrs, op, scalar);
+FF_VISIT_FMTABLE(ElementScalarUnaryAttrs);
+CHECK_FMTABLE(ElementScalarUnaryAttrs);
 CHECK_VALID_OP_ATTR(ElementScalarUnaryAttrs);
 
 struct ElementUnaryAttrs {
   req<Op> op;
 };
 FF_VISITABLE_STRUCT(ElementUnaryAttrs, op);
+FF_VISIT_FMTABLE(ElementUnaryAttrs);
+CHECK_FMTABLE(ElementUnaryAttrs);
 CHECK_VALID_OP_ATTR(ElementUnaryAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/embedding.h b/lib/op-attrs/include/op-attrs/ops/embedding.h
index 8b00fa22ce..c3cb2f2368 100644
--- a/lib/op-attrs/include/op-attrs/ops/embedding.h
+++ b/lib/op-attrs/include/op-attrs/ops/embedding.h
@@ -21,6 +21,8 @@ struct EmbeddingAttrs {
   req<DataType> data_type;
 };
 FF_VISITABLE_STRUCT(EmbeddingAttrs, num_entries, out_channels, aggr, data_type);
+FF_VISIT_FMTABLE(EmbeddingAttrs);
+CHECK_FMTABLE(EmbeddingAttrs);
 CHECK_VALID_OP_ATTR(EmbeddingAttrs);
 
 TensorShape get_weights_shape(EmbeddingAttrs const &, TensorShape const &);
diff --git a/lib/op-attrs/include/op-attrs/ops/flat.h b/lib/op-attrs/include/op-attrs/ops/flat.h
index 706689199d..1f01395d85 100644
--- a/lib/op-attrs/include/op-attrs/ops/flat.h
+++ b/lib/op-attrs/include/op-attrs/ops/flat.h
@@ -9,6 +9,8 @@ namespace FlexFlow {
 
 struct FlatAttrs {};
 FF_VISITABLE_STRUCT(FlatAttrs);
+FF_VISIT_FMTABLE(FlatAttrs);
+CHECK_FMTABLE(FlatAttrs);
 CHECK_VALID_OP_ATTR(FlatAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/gather.h b/lib/op-attrs/include/op-attrs/ops/gather.h
index ca2406ef75..73e96ae3d8 100644
--- a/lib/op-attrs/include/op-attrs/ops/gather.h
+++ b/lib/op-attrs/include/op-attrs/ops/gather.h
@@ -12,6 +12,8 @@ struct GatherAttrs {
   ff_dim_t dim;
 };
 FF_VISITABLE_STRUCT(GatherAttrs, dim);
+FF_VISIT_FMTABLE(GatherAttrs);
+CHECK_FMTABLE(GatherAttrs);
 CHECK_VALID_OP_ATTR(GatherAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/groupby.h b/lib/op-attrs/include/op-attrs/ops/groupby.h
index 174c40242e..80eabb5529 100644
--- a/lib/op-attrs/include/op-attrs/ops/groupby.h
+++ b/lib/op-attrs/include/op-attrs/ops/groupby.h
@@ -12,6 +12,8 @@ struct Group_byAttrs {
   req<float> alpha;
 };
 FF_VISITABLE_STRUCT(Group_byAttrs, n, alpha);
+FF_VISIT_FMTABLE(Group_byAttrs);
+CHECK_FMTABLE(Group_byAttrs);
 CHECK_VALID_OP_ATTR(Group_byAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/input.h b/lib/op-attrs/include/op-attrs/ops/input.h
index 26c486c9ac..28522c7457 100644
--- a/lib/op-attrs/include/op-attrs/ops/input.h
+++ b/lib/op-attrs/include/op-attrs/ops/input.h
@@ -8,6 +8,8 @@ namespace FlexFlow {
 
 struct InputAttrs {};
 FF_VISITABLE_STRUCT(InputAttrs);
+FF_VISIT_FMTABLE(InputAttrs);
+CHECK_FMTABLE(InputAttrs);
 CHECK_VALID_OP_ATTR(InputAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/layer_norm.h b/lib/op-attrs/include/op-attrs/ops/layer_norm.h
index dab055b2c9..d78d0983b6 100644
--- a/lib/op-attrs/include/op-attrs/ops/layer_norm.h
+++ b/lib/op-attrs/include/op-attrs/ops/layer_norm.h
@@ -14,6 +14,8 @@ struct LayerNormAttrs {
   req<float> eps;
 };
 FF_VISITABLE_STRUCT(LayerNormAttrs, axes, elementwise_affine, eps);
+FF_VISIT_FMTABLE(LayerNormAttrs);
+CHECK_FMTABLE(LayerNormAttrs);
 CHECK_VALID_OP_ATTR(LayerNormAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/linear.h b/lib/op-attrs/include/op-attrs/ops/linear.h
index 3be8be2040..aa3144b8ff 100644
--- a/lib/op-attrs/include/op-attrs/ops/linear.h
+++ b/lib/op-attrs/include/op-attrs/ops/linear.h
@@ -13,12 +13,16 @@ struct L1RegularizerAttrs {
   req<float> lambda;
 };
 FF_VISITABLE_STRUCT(L1RegularizerAttrs, lambda);
+FF_VISIT_FMTABLE(L1RegularizerAttrs);
+CHECK_FMTABLE(L1RegularizerAttrs);
 CHECK_VALID_OP_ATTR(L1RegularizerAttrs);
 
 struct L2RegularizerAttrs {
   req<float> lambda;
 };
 FF_VISITABLE_STRUCT(L2RegularizerAttrs, lambda);
+FF_VISIT_FMTABLE(L2RegularizerAttrs);
+CHECK_FMTABLE(L2RegularizerAttrs);
 CHECK_VALID_OP_ATTR(L2RegularizerAttrs);
 
 using RegularizerAttrs = variant<L1RegularizerAttrs, L2RegularizerAttrs>;
@@ -32,6 +36,8 @@ struct LinearAttrs {
 };
 FF_VISITABLE_STRUCT(
     LinearAttrs, out_channels, use_bias, data_type, activation, regularizer);
+FF_VISIT_FMTABLE(LinearAttrs);
+CHECK_FMTABLE(LinearAttrs);
 CHECK_VALID_OP_ATTR(LinearAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/loss_functions.h b/lib/op-attrs/include/op-attrs/ops/loss_functions.h
index 7a3db05329..0b1a2c12e5 100644
--- a/lib/op-attrs/include/op-attrs/ops/loss_functions.h
+++ b/lib/op-attrs/include/op-attrs/ops/loss_functions.h
@@ -22,12 +22,16 @@ struct SparseCategoricalCrossEntropyLossAttrs {
   req<bool> replace_labels; // for aggregate_spec: More predictions than labels
 };
 FF_VISITABLE_STRUCT(SparseCategoricalCrossEntropyLossAttrs, replace_labels);
+FF_VISIT_FMTABLE(SparseCategoricalCrossEntropyLossAttrs);
+CHECK_FMTABLE(SparseCategoricalCrossEntropyLossAttrs);
 CHECK_VALID_OP_ATTR(SparseCategoricalCrossEntropyLossAttrs);
 
 struct OtherLossAttrs {
   req<LossFunction> loss_type;
 };
 FF_VISITABLE_STRUCT(OtherLossAttrs, loss_type);
+FF_VISIT_FMTABLE(OtherLossAttrs);
+CHECK_FMTABLE(OtherLossAttrs);
 CHECK_VALID_OP_ATTR(OtherLossAttrs);
 
 using LossAttrs =
diff --git a/lib/op-attrs/include/op-attrs/ops/noop.h b/lib/op-attrs/include/op-attrs/ops/noop.h
index 658e1b7d98..7b2eafa6f3 100644
--- a/lib/op-attrs/include/op-attrs/ops/noop.h
+++ b/lib/op-attrs/include/op-attrs/ops/noop.h
@@ -8,6 +8,8 @@ namespace FlexFlow {
 
 struct NoopAttrs {};
 FF_VISITABLE_STRUCT(NoopAttrs);
+FF_VISIT_FMTABLE(NoopAttrs);
+CHECK_FMTABLE(NoopAttrs);
 CHECK_VALID_OP_ATTR(NoopAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/pool_2d.h b/lib/op-attrs/include/op-attrs/ops/pool_2d.h
index efe29b3b2e..62a7ee491e 100644
--- a/lib/op-attrs/include/op-attrs/ops/pool_2d.h
+++ b/lib/op-attrs/include/op-attrs/ops/pool_2d.h
@@ -27,6 +27,8 @@ FF_VISITABLE_STRUCT(Pool2DAttrs,
                     padding_w,
                     pool_type,
                     activation);
+FF_VISIT_FMTABLE(Pool2DAttrs);
+CHECK_FMTABLE(Pool2DAttrs);
 CHECK_VALID_OP_ATTR(Pool2DAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/reduce.h b/lib/op-attrs/include/op-attrs/ops/reduce.h
index 193d3b0dc8..39b3b2e329 100644
--- a/lib/op-attrs/include/op-attrs/ops/reduce.h
+++ b/lib/op-attrs/include/op-attrs/ops/reduce.h
@@ -16,6 +16,8 @@ struct ReduceAttrs {
   req<bool> keepdims;
 };
 FF_VISITABLE_STRUCT(ReduceAttrs, axes, op_type, keepdims);
+FF_VISIT_FMTABLE(ReduceAttrs);
+CHECK_FMTABLE(ReduceAttrs);
 CHECK_VALID_OP_ATTR(ReduceAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/reduction.h b/lib/op-attrs/include/op-attrs/ops/reduction.h
index f848f879fc..58f81dbccc 100644
--- a/lib/op-attrs/include/op-attrs/ops/reduction.h
+++ b/lib/op-attrs/include/op-attrs/ops/reduction.h
@@ -13,6 +13,8 @@ struct ReductionAttrs {
   req<int> reduction_degree;
 };
 FF_VISITABLE_STRUCT(ReductionAttrs, reduction_dim, reduction_degree);
+FF_VISIT_FMTABLE(ReductionAttrs);
+CHECK_FMTABLE(ReductionAttrs);
 CHECK_VALID_OP_ATTR(ReductionAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/repartition.h b/lib/op-attrs/include/op-attrs/ops/repartition.h
index 83c4ae870b..078b0aa602 100644
--- a/lib/op-attrs/include/op-attrs/ops/repartition.h
+++ b/lib/op-attrs/include/op-attrs/ops/repartition.h
@@ -13,6 +13,8 @@ struct RepartitionAttrs {
   req<int> repartition_degree;
 };
 FF_VISITABLE_STRUCT(RepartitionAttrs, repartition_dim, repartition_degree);
+FF_VISIT_FMTABLE(RepartitionAttrs);
+CHECK_FMTABLE(RepartitionAttrs);
 CHECK_VALID_OP_ATTR(RepartitionAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/replicate.h b/lib/op-attrs/include/op-attrs/ops/replicate.h
index 92e64a4120..dfc3a44741 100644
--- a/lib/op-attrs/include/op-attrs/ops/replicate.h
+++ b/lib/op-attrs/include/op-attrs/ops/replicate.h
@@ -13,6 +13,8 @@ struct ReplicateAttrs {
   req<int> replicate_degree;
 };
 FF_VISITABLE_STRUCT(ReplicateAttrs, replicate_dim, replicate_degree);
+FF_VISIT_FMTABLE(ReplicateAttrs);
+CHECK_FMTABLE(ReplicateAttrs);
 CHECK_VALID_OP_ATTR(ReplicateAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/reshape.h b/lib/op-attrs/include/op-attrs/ops/reshape.h
index b118482a2b..b4cdb84a27 100644
--- a/lib/op-attrs/include/op-attrs/ops/reshape.h
+++ b/lib/op-attrs/include/op-attrs/ops/reshape.h
@@ -11,6 +11,8 @@ struct ReshapeAttrs {
   TensorShape shape;
 };
 FF_VISITABLE_STRUCT(ReshapeAttrs, shape);
+FF_VISIT_FMTABLE(ReshapeAttrs);
+CHECK_FMTABLE(ReshapeAttrs);
 CHECK_VALID_OP_ATTR(ReshapeAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/reverse.h b/lib/op-attrs/include/op-attrs/ops/reverse.h
index 6030285f14..35582ef9c5 100644
--- a/lib/op-attrs/include/op-attrs/ops/reverse.h
+++ b/lib/op-attrs/include/op-attrs/ops/reverse.h
@@ -11,6 +11,8 @@ struct ReverseAttrs {
   ff_dim_t axis;
 };
 FF_VISITABLE_STRUCT(ReverseAttrs, axis);
+FF_VISIT_FMTABLE(ReverseAttrs);
+CHECK_FMTABLE(ReverseAttrs);
 CHECK_VALID_OP_ATTR(ReverseAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/softmax.h b/lib/op-attrs/include/op-attrs/ops/softmax.h
index 9a776737f5..9bf53254f6 100644
--- a/lib/op-attrs/include/op-attrs/ops/softmax.h
+++ b/lib/op-attrs/include/op-attrs/ops/softmax.h
@@ -12,6 +12,8 @@ struct SoftmaxAttrs {
   ff_dim_t dim;
 };
 FF_VISITABLE_STRUCT(SoftmaxAttrs, dim);
+FF_VISIT_FMTABLE(SoftmaxAttrs);
+CHECK_FMTABLE(SoftmaxAttrs);
 CHECK_VALID_OP_ATTR(SoftmaxAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/split.h b/lib/op-attrs/include/op-attrs/ops/split.h
index fa66bc46f5..232a996380 100644
--- a/lib/op-attrs/include/op-attrs/ops/split.h
+++ b/lib/op-attrs/include/op-attrs/ops/split.h
@@ -13,6 +13,8 @@ struct SplitAttrs {
   ff_dim_t axis;
 };
 FF_VISITABLE_STRUCT(SplitAttrs, splits, axis);
+FF_VISIT_FMTABLE(SplitAttrs);
+CHECK_FMTABLE(SplitAttrs);
 CHECK_VALID_OP_ATTR(SplitAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/topk.h b/lib/op-attrs/include/op-attrs/ops/topk.h
index 413855913c..963c6189a6 100644
--- a/lib/op-attrs/include/op-attrs/ops/topk.h
+++ b/lib/op-attrs/include/op-attrs/ops/topk.h
@@ -12,6 +12,8 @@ struct TopKAttrs {
   req<bool> sorted;
 };
 FF_VISITABLE_STRUCT(TopKAttrs, k, sorted);
+FF_VISIT_FMTABLE(TopKAttrs);
+CHECK_FMTABLE(TopKAttrs);
 CHECK_VALID_OP_ATTR(TopKAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/ops/transpose.h b/lib/op-attrs/include/op-attrs/ops/transpose.h
index 87db435979..8b87fca08a 100644
--- a/lib/op-attrs/include/op-attrs/ops/transpose.h
+++ b/lib/op-attrs/include/op-attrs/ops/transpose.h
@@ -12,6 +12,8 @@ struct TransposeAttrs {
   req<stack_vector<ff_dim_t, MAX_TENSOR_DIM>> perm;
 };
 FF_VISITABLE_STRUCT(TransposeAttrs, perm);
+FF_VISIT_FMTABLE(TransposeAttrs);
+CHECK_FMTABLE(TransposeAttrs);
 CHECK_VALID_OP_ATTR(TransposeAttrs);
 
 } // namespace FlexFlow
diff --git a/lib/op-attrs/include/op-attrs/parallel_dim.h b/lib/op-attrs/include/op-attrs/parallel_dim.h
index b9df2d9037..ae05f39d61 100644
--- a/lib/op-attrs/include/op-attrs/parallel_dim.h
+++ b/lib/op-attrs/include/op-attrs/parallel_dim.h
@@ -12,6 +12,8 @@ struct ParallelDim {
   req<bool> is_replica_dim;
 };
 FF_VISITABLE_STRUCT(ParallelDim, size, degree, is_replica_dim);
+FF_VISIT_FMTABLE(ParallelDim);
+CHECK_FMTABLE(ParallelDim);
 
 bool is_valid(ParallelDim const &);
 bool is_replica_dim(ParallelDim const &);
diff --git a/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h b/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
index a32b1ecb33..4053804a97 100644
--- a/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
+++ b/lib/op-attrs/include/op-attrs/parallel_tensor_dims.h
@@ -53,4 +53,20 @@ TensorDims get_tensor_dims_unsafe(ParallelTensorDims const &);
 
 } // namespace FlexFlow
 
+namespace fmt {
+
+template <>
+struct formatter<::FlexFlow::ParallelTensorDims> : formatter<string_view> {
+  template <typename FormatContext>
+  auto format(::FlexFlow::ParallelTensorDims dims, FormatContext &ctx) const
+      -> decltype(ctx.out()) {
+    using namespace FlexFlow;
+
+    std::vector<ParallelDim> v(dims.data.begin(), dims.data.end());
+    return formatter<string_view>::format(fmt::to_string(v), ctx);
+  }
+};
+
+} // namespace fmt
+
 #endif
diff --git a/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h b/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
index a9c52baaca..5e78350ebe 100644
--- a/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
+++ b/lib/op-attrs/include/op-attrs/parallel_tensor_shape.h
@@ -35,6 +35,8 @@ struct ParallelTensorShape {
   req<DataType> data_type;
 };
 FF_VISITABLE_STRUCT_NONSTANDARD_CONSTRUCTION(ParallelTensorShape, dims, data_type);
+FF_VISIT_FMTABLE(ParallelTensorShape);
+CHECK_FMTABLE(ParallelTensorShape);
 
 TensorShape get_piece_shape(ParallelTensorShape const &);
 int get_num_replica_dims(ParallelTensorShape const &);
diff --git a/lib/op-attrs/include/op-attrs/tensor_shape.h b/lib/op-attrs/include/op-attrs/tensor_shape.h
index 2c0cd562d2..c8a5638ef6 100644
--- a/lib/op-attrs/include/op-attrs/tensor_shape.h
+++ b/lib/op-attrs/include/op-attrs/tensor_shape.h
@@ -21,7 +21,25 @@ struct TensorShape {
 };
 
 FF_VISITABLE_STRUCT(TensorShape, dims, data_type);
+FF_VISIT_FMTABLE(TensorShape);
+CHECK_FMTABLE(TensorShape);
 
 } // namespace FlexFlow
 
+namespace fmt {
+
+template <>
+struct formatter<::FlexFlow::TensorDims> : formatter<string_view> {
+  template <typename FormatContext>
+  auto format(::FlexFlow::TensorDims dims, FormatContext &ctx) const
+      -> decltype(ctx.out()) {
+    using namespace FlexFlow;
+
+    std::vector<size_t> v(dims.begin(), dims.end());
+    return formatter<string_view>::format(fmt::to_string(v), ctx);
+  }
+};
+
+} // namespace fmt
+
 #endif
diff --git a/lib/pcg/include/pcg/initializer.h b/lib/pcg/include/pcg/initializer.h
index 58e4fcc242..55a9e1e8c5 100644
--- a/lib/pcg/include/pcg/initializer.h
+++ b/lib/pcg/include/pcg/initializer.h
@@ -13,11 +13,15 @@ struct GlorotUniform {
   /* DataType data_type; */
 };
 FF_VISITABLE_STRUCT(GlorotUniform, seed);
+FF_VISIT_FMTABLE(GlorotUniform);
+CHECK_FMTABLE(GlorotUniform);
 
 struct ZeroInitializer {
   ZeroInitializer() = default;
 };
 FF_VISITABLE_STRUCT(ZeroInitializer);
+FF_VISIT_FMTABLE(ZeroInitializer);
+CHECK_FMTABLE(ZeroInitializer);
 
 struct UniformInitializer {
   req<int> seed;
@@ -25,6 +29,8 @@ struct UniformInitializer {
   req<float> max_val;
 };
 FF_VISITABLE_STRUCT(UniformInitializer, seed, min_val, max_val);
+FF_VISIT_FMTABLE(UniformInitializer);
+CHECK_FMTABLE(UniformInitializer);
 
 struct NormInitializer {
   req<int> seed;
@@ -32,11 +38,15 @@ struct NormInitializer {
   req<float> stddev;
 };
 FF_VISITABLE_STRUCT(NormInitializer, seed, mean, stddev);
+FF_VISIT_FMTABLE(NormInitializer);
+CHECK_FMTABLE(NormInitializer);
 
 struct ConstantInitializer {
   req<DataTypeValue> value;
 };
 FF_VISITABLE_STRUCT(ConstantInitializer, value);
+FF_VISIT_FMTABLE(ConstantInitializer);
+CHECK_FMTABLE(ConstantInitializer);
 
 using Initializer = variant<GlorotUniform,
                             ZeroInitializer,
@@ -47,4 +57,31 @@ CHECK_WELL_BEHAVED_VALUE_TYPE(Initializer);
 
 } // namespace FlexFlow
 
+namespace fmt {
+
+template <>
+struct formatter<::FlexFlow::Initializer> : formatter<string_view> {
+  template <typename FormatContext>
+  auto format(::FlexFlow::Initializer initializer, FormatContext &ctx) const
+      -> decltype(ctx.out()) {
+    using namespace FlexFlow;
+
+    string_view s = "unknown";
+    if (auto const *g = get_if<GlorotUniform>(&initializer)) {
+      s = fmt::to_string(*g);
+    } else if (auto const *z = get_if<ZeroInitializer>(&initializer)) {
+      s = fmt::to_string(*z);
+    } else if (auto const *u = get_if<UniformInitializer>(&initializer)) {
+      s = fmt::to_string(*u);
+    } else if (auto const *n = get_if<NormInitializer>(&initializer)) {
+      s = fmt::to_string(*n);
+    } else if (auto const *c = get_if<ConstantInitializer>(&initializer)) {
+      s = fmt::to_string(*c);
+    }
+    return formatter<string_view>::format(s, ctx);
+  }
+};
+
+} // namespace fmt
+
 #endif
diff --git a/lib/pcg/include/pcg/parallel_tensor.h b/lib/pcg/include/pcg/parallel_tensor.h
index 2dac62bf8f..55656c6a8e 100644
--- a/lib/pcg/include/pcg/parallel_tensor.h
+++ b/lib/pcg/include/pcg/parallel_tensor.h
@@ -57,6 +57,8 @@ FF_VISITABLE_STRUCT(ParallelTensor,
                     initializer,
                     sync_type,
                     name);
+FF_VISIT_FMTABLE(ParallelTensor);
+CHECK_FMTABLE(ParallelTensor);
 
 using ParallelParameter = ParallelTensor;
 
diff --git a/lib/pcg/include/pcg/tensor.h b/lib/pcg/include/pcg/tensor.h
index b5032e4097..3e2b970a89 100644
--- a/lib/pcg/include/pcg/tensor.h
+++ b/lib/pcg/include/pcg/tensor.h
@@ -25,6 +25,8 @@ struct Tensor {
 };
 FF_VISITABLE_STRUCT(
     Tensor, dims, data_type, create_gradients, initializer, sync_type, name);
+FF_VISIT_FMTABLE(Tensor);
+CHECK_FMTABLE(Tensor);
 
 using Parameter = Tensor;
 
diff --git a/lib/pcg/src/file_format/v1/parallel_tensor.cc b/lib/pcg/src/file_format/v1/parallel_tensor.cc
index d9ada5880e..61aa52a80f 100644
--- a/lib/pcg/src/file_format/v1/parallel_tensor.cc
+++ b/lib/pcg/src/file_format/v1/parallel_tensor.cc
@@ -13,7 +13,7 @@ ParallelDim from_v1(V1ParallelDim const &vdim) {
 
 V1ParallelTensorShape to_v1(ParallelTensorShape const &shp) {
   std::vector<V1ParallelDim> pdims;
-  for (ParallelDim const &pdim : shp.dims) {
+  for (ParallelDim const &pdim : shp.dims.data) {
     pdims.emplace_back(to_v1(pdim));
   }
   return {pdims, to_v1(shp.data_type)};
diff --git a/lib/pcg/test/doctest.h b/lib/pcg/test/doctest.h
index 891cc81d32..1712a05a5f 100644
--- a/lib/pcg/test/doctest.h
+++ b/lib/pcg/test/doctest.h
@@ -18,7 +18,7 @@ std::string
   if (first == last) {
     return open + "(empty)" + close;
   } else {
-    return open + join_strings(first, last, delimiter, f) + close;
+    return open + FlexFlow::join_strings(first, last, delimiter, f) + close;
   }
 }
 
diff --git a/lib/pcg/test/test_op.cc b/lib/pcg/test/test_op.cc
new file mode 100644
index 0000000000..ddaa975936
--- /dev/null
+++ b/lib/pcg/test/test_op.cc
@@ -0,0 +1,107 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/op.h"
+#include "utils.h"
+#include "utils/json.h"
+
+using namespace FlexFlow;
+
+#define TEST(m)                                                                \
+  do {                                                                         \
+    V1Op v1 = to_v1(Op::m);                                                    \
+                                                                               \
+    CHECK(from_v1(v1) == Op::m);                                               \
+                                                                               \
+    json j = v1;                                                               \
+    CHECK(str(j) == "\"" #m "\"");                                             \
+    /* TODO: Check deserialization.*/                                          \
+  } while (0)
+
+TEST_CASE("V1Op") {
+  TEST(NOOP);
+  TEST(INPUT);
+  TEST(WEIGHT);
+  TEST(CONV2D);
+  TEST(DROPOUT);
+  TEST(LINEAR);
+  TEST(BATCHMATMUL);
+  TEST(POOL2D);
+  TEST(SCALAR_MULTIPLY);
+  TEST(SCALAR_ADD);
+  TEST(SCALAR_FLOOR_DIV);
+  TEST(SCALAR_TRUE_DIV);
+  TEST(SCALAR_SUB);
+  TEST(RELU);
+  TEST(IDENTITY);
+  TEST(SIGMOID);
+  TEST(TANH);
+  TEST(ELU);
+  TEST(FLAT);
+  TEST(SOFTMAX);
+  TEST(BATCHNORM);
+  TEST(CONCAT);
+  TEST(SPLIT);
+  TEST(EMBEDDING);
+  TEST(GROUP_BY);
+  TEST(CACHE);
+  TEST(AGGREGATE);
+  TEST(AGG_SPEC);
+  // TEST(OP_ELEMENTWISE)
+  TEST(RESHAPE);
+  TEST(REVERSE);
+  TEST(TRANSPOSE);
+  TEST(EW_ADD);
+  TEST(EW_MUL);
+  TEST(MATMUL);
+  TEST(MUL);
+  TEST(ENLARGE);
+  TEST(SQUEEZE);
+  TEST(UNSQUEEZE);
+  TEST(EW_SUB);
+  TEST(EW_DIV);
+  TEST(EW_EQUAL);
+  TEST(EW_GREATER);
+  TEST(EW_LESS);
+  TEST(EW_MAX);
+  TEST(EW_MIN);
+  TEST(REDUCE_ARGMAX);
+  TEST(REDUCE_ARGMIN);
+  TEST(REDUCE_MAX);
+  TEST(REDUCE_MEAN);
+  TEST(REDUCE_MIN);
+  TEST(REDUCE_PROD);
+  TEST(REDUCE_SUM);
+  TEST(PAD);
+  TEST(SHAPE);
+  TEST(SIZE);
+  TEST(TOPK);
+  TEST(WHERE);
+  TEST(CEIL);
+  TEST(CAST);
+  TEST(EXP);
+  TEST(ROUND);
+  TEST(LOG);
+  TEST(LOGICAL_NOT);
+  TEST(SQRT);
+  TEST(SIN);
+  TEST(COS);
+  TEST(LEAKYRELU);
+  TEST(SLICE);
+  TEST(RESIZE);
+  TEST(PRELU);
+  TEST(GELU);
+  TEST(MULTIHEAD_ATTENTION);
+  TEST(FUSED);
+  TEST(RSQRT);
+  TEST(POW);
+  TEST(MEAN);
+  TEST(LAYERNORM);
+  TEST(GATHER);
+  TEST(BROADCAST);
+  TEST(REPARTITION);
+  TEST(COMBINE);
+  TEST(REPLICATE);
+  TEST(REDUCTION);
+  TEST(BATCH);
+  TEST(PIPELINE);
+  TEST(FUSED_PARALLEL);
+}
diff --git a/lib/pcg/test/test_operator_attrs.cc b/lib/pcg/test/test_operator_attrs.cc
index b1036b13f0..8bfe7ec66c 100644
--- a/lib/pcg/test/test_operator_attrs.cc
+++ b/lib/pcg/test/test_operator_attrs.cc
@@ -24,33 +24,29 @@ TEST_CASE("AggregateAttrs") {
   AggregateAttrs a = {42, 3.14};
   V1AggregateAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<AggregateAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1AggregateAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"lambda_bal", "3.14"}, {"n", "42"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("AggregateSpec") {
   AggregateSpecAttrs a = {42, 3.14};
   V1AggregateSpecAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<AggregateSpecAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1AggregateSpecAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"lambda_bal", "3.14"}, {"n", "42"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("MultiHeadAttentionAttrs") {
   MultiHeadAttentionAttrs a = {1, 2, 3, 4, 5.67, false, true, false};
   V1MultiHeadAttentionAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<MultiHeadAttentionAttrs>() == 8);
-  CHECK(visit_struct::field_count<V1MultiHeadAttentionAttrs>() == 8);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
@@ -62,30 +58,29 @@ TEST_CASE("MultiHeadAttentionAttrs") {
                 {"bias", "false"},
                 {"add_bias_kv", "true"},
                 {"add_zero_attn", "false"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("BatchMatmulAttrs") {
   BatchMatmulAttrs a = {12, 34};
   V1BatchMatmulAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<BatchMatmulAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1BatchMatmulAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"a_seq_length_dim", "12"}, {"b_seq_length_dim", "34"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("BatchNormAttrs") {
   BatchNormAttrs a = {true};
   V1BatchNormAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<BatchNormAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1BatchNormAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"relu", "true"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("BroadcastAttrs") {
@@ -96,57 +91,51 @@ TEST_CASE("BroadcastAttrs") {
   a.target_dims.push_back(4);
   V1BroadcastAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<BroadcastAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1BroadcastAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"target_dims", "[1,2,3,4]"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("CastAttrs") {
   CastAttrs a = {DataType::HALF};
   V1CastAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<CastAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1CastAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+ CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"dtype", "\"HALF\""}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("CombineAttrs") {
   CombineAttrs a = {ff_dim_t(1), 2};
   V1CombineAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<CombineAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1CombineAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"combine_dim", "1"}, {"combine_degree", "2"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ConcatAttrs") {
   ConcatAttrs a = {ff_dim_t(43)};
   V1ConcatAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<ConcatAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1ConcatAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"axis", "43"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("Conv2DAttrs") {
   Conv2DAttrs a = {1, 2, 3, 4, 5, 6, 7, 8, Activation::SIGMOID, false};
   V1Conv2DAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<Conv2DAttrs>() == 10);
-  CHECK(visit_struct::field_count<V1Conv2DAttrs>() == 10);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
@@ -160,55 +149,52 @@ TEST_CASE("Conv2DAttrs") {
                 {"groups", "8"},
                 {"activation", "\"SIGMOID\""},
                 {"use_bias", "false"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("DropoutAttrs") {
   DropoutAttrs a = {3.14, 9823749238472398ULL};
   V1DropoutAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<DropoutAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1DropoutAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"rate", "3.14"}, {"seed", "9823749238472398"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ElementBinaryAttrs") {
   ElementBinaryAttrs a = {Op::SQUEEZE, DataType::FLOAT, false, true};
   V1ElementBinaryAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<ElementBinaryAttrs>() == 4);
-  CHECK(visit_struct::field_count<V1ElementBinaryAttrs>() == 4);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(
       j, {{"should_broadcast_lhs", "false"}, {"should_broadcast_rhs", "true"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ElementUnaryAttrs") {
   ElementUnaryAttrs a = {Op::LOGICAL_NOT};
   V1ElementUnaryAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<ElementUnaryAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1ElementUnaryAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"op", "\"LOGICAL_NOT\""}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ElementUnaryScalarAttrs") {
   ElementScalarUnaryAttrs a = {Op::SCALAR_FLOOR_DIV, 2.71828};
   V1ElementScalarUnaryAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<ElementScalarUnaryAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1ElementScalarUnaryAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"op", "\"SCALAR_FLOOR_DIV\""}, {"scalar", "2.71828"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("AggregateOp") {
@@ -225,9 +211,7 @@ TEST_CASE("EmbeddingAttrs") {
   EmbeddingAttrs a = {1, 2, AggregateOp::SUM, DataType::DOUBLE};
   V1EmbeddingAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<EmbeddingAttrs>() == 4);
-  CHECK(visit_struct::field_count<V1EmbeddingAttrs>() == 4);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
@@ -235,54 +219,51 @@ TEST_CASE("EmbeddingAttrs") {
                 {"out_channels", "2"},
                 {"aggr", "\"SUM\""},
                 {"data_type", "\"DOUBLE\""}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("FlatAttrs") {
   FlatAttrs a;
   V1FlatAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<FlatAttrs>() == 0);
-  CHECK(visit_struct::field_count<V1FlatAttrs>() == 0);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("GatherAttrs") {
   GatherAttrs a = {ff_dim_t(42)};
   V1GatherAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<GatherAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1GatherAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"dim", "42"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("Group_byAttrs") {
   Group_byAttrs a = {11, 3.14};
   V1Group_byAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<Group_byAttrs>() == 2);
-  CHECK(visit_struct::field_count<V1Group_byAttrs>() == 2);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"n", "11"}, {"alpha", "3.14"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("InputAttrs") {
   InputAttrs a;
   V1InputAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<InputAttrs>() == 0);
-  CHECK(visit_struct::field_count<V1InputAttrs>() == 0);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("LayerNormAttrs") {
@@ -292,39 +273,36 @@ TEST_CASE("LayerNormAttrs") {
   a.axes.push_back(ff_dim_t(39));
   V1LayerNormAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<LayerNormAttrs>() == 3);
-  CHECK(visit_struct::field_count<V1LayerNormAttrs>() == 3);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
                {{"axes", "[19,29,39]"},
                 {"elementwise_affine", "false"},
                 {"eps", "2.71828"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("L1RegularizerAttrs") {
   L1RegularizerAttrs a = {3.14159};
   V1L1RegularizerAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<L1RegularizerAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1L1RegularizerAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"lambda", "3.14159"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("L2RegularizerAttrs") {
   L2RegularizerAttrs a = {3.14159};
   V1L2RegularizerAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<L2RegularizerAttrs>() == 1);
-  CHECK(visit_struct::field_count<V1L2RegularizerAttrs>() == 1);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"lambda", "3.14159"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("LinearAttrs") {
@@ -332,9 +310,7 @@ TEST_CASE("LinearAttrs") {
   LinearAttrs a = {11, false, DataType::HALF, Activation::TANH, r};
   V1LinearAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<LinearAttrs>() == 5);
-  CHECK(visit_struct::field_count<V1LinearAttrs>() == 5);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
@@ -345,18 +321,18 @@ TEST_CASE("LinearAttrs") {
                 {"regularizer",
                  "{\"index\":0,\"type\":\"::FlexFlow::V1L1RegularizerAttrs\","
                  "\"value\":{\"lambda\":1234.567"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("NoopAttrs") {
   NoopAttrs a;
   V1NoopAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<NoopAttrs>() == 0);
-  CHECK(visit_struct::field_count<V1NoopAttrs>() == 0);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("PoolOp") {
@@ -373,9 +349,7 @@ TEST_CASE("Pool2DAttrs") {
   Pool2DAttrs a = {1, 2, 3, 4, 5, 6, PoolOp::MAX, Activation::RELU};
   V1Pool2DAttrs v1 = to_v1(a);
 
-  CHECK(visit_struct::field_count<Pool2DAttrs>() == 8);
-  CHECK(visit_struct::field_count<V1Pool2DAttrs>() == 8);
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
@@ -387,6 +361,7 @@ TEST_CASE("Pool2DAttrs") {
                 {"padding_w", "6"},
                 {"pool_type", "\"MAX\""},
                 {"activation", "\"RELU\""}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ReduceAttrs") {
@@ -397,43 +372,47 @@ TEST_CASE("ReduceAttrs") {
   a.axes.push_back(ff_dim_t(39));
   V1ReduceAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j,
                {{"axes", "[19,29,39]"},
                 {"op_type", "\"LEAKYRELU\""},
                 {"keepdims", "true"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ReductionAttrs") {
   ReductionAttrs a = {ff_dim_t(66), ff_dim_t(77)};
   V1ReductionAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"reduction_dim", "66"}, {"reduction_degree", "77"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("RepartitionAttrs") {
   RepartitionAttrs a = {ff_dim_t(66), ff_dim_t(77)};
   V1RepartitionAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"repartition_dim", "66"}, {"repartition_degree", "77"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ReplicateAttrs") {
   ReplicateAttrs a = {ff_dim_t(66), ff_dim_t(77)};
   V1ReplicateAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"replicate_dim", "66"}, {"replicate_degree", "77"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("ReshapeAttrs") {
@@ -444,20 +423,22 @@ TEST_CASE("ReverseAttrs") {
   ReverseAttrs a = {ff_dim_t(11)};
   V1ReverseAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"axis", "11"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("SoftmaxAttrs") {
   SoftmaxAttrs a = {ff_dim_t(37)};
   V1SoftmaxAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"dim", "37"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("SplitAttrs") {
@@ -466,20 +447,22 @@ TEST_CASE("SplitAttrs") {
   a.splits.push_back(67);
   V1SplitAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"splits", "[53,67]"}, {"axis", "97"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("TopKAttrs") {
   TopKAttrs a = {17, true};
   V1TopKAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"k", "17"}, {"sorted", "true"}});
+  // TODO: Check deserialization.
 }
 
 TEST_CASE("TransposeAttrs") {
@@ -488,8 +471,9 @@ TEST_CASE("TransposeAttrs") {
   a.perm.push_back(ff_dim_t(43));
   V1TransposeAttrs v1 = to_v1(a);
 
-  // CHECK(from_v1(v1) == a);
+  CHECK(from_v1(v1) == a);
 
   json j = v1;
   check_fields(j, {{"perm", "[3,43]"}});
+  // TODO: Check deserialization.
 }
diff --git a/lib/pcg/test/test_parallel_tensor.cc b/lib/pcg/test/test_parallel_tensor.cc
new file mode 100644
index 0000000000..a0123b8cee
--- /dev/null
+++ b/lib/pcg/test/test_parallel_tensor.cc
@@ -0,0 +1,102 @@
+#include "doctest.h"
+#include "pcg/file_format/v1/parallel_tensor.h"
+#include "pcg/parallel_tensor.h"
+#include "utils.h"
+#include "utils/json.h"
+#include "utils/required.h"
+
+using namespace FlexFlow;
+
+TEST_CASE("ParallelDim") {
+  ParallelDim d{4, 11, false};
+  V1ParallelDim v1 = to_v1(d);
+
+  CHECK(from_v1(v1) == d);
+
+  json j = v1;
+  check_fields(j, {{"size", "4"},
+                   {"degree", "11"},
+                   {"is_replica_dim", "false"}});
+  // TODO: Check deserialization.
+}
+
+TEST_CASE("ParallelTensorDims") {
+  ParallelTensorDims d(std::vector<ParallelDim>{{3, 11, false}, {4, 2, true}});
+  V1ParallelTensorDims v1 = to_v1(d);
+
+  CHECK(from_v1(v1) == d);
+
+  json j = v1;
+
+  // Currently, there isn't a great way to check the actual JSON since the
+  // elements of the array will also be objects whose fields may be in a
+  // different order. The test utilities are ok for checking that the fields of
+  // an object were serialized but they are currently not up to checking if
+  // an array of objects was serialized. So just check that it is an array of
+  // objects that was serialized.
+  std::string strj = str(j);
+  CHECK(strj.find("{\"data\":[{") == 0);
+  CHECK(strj.substr(strj.size() - 3, 3) == "}]}");
+
+  // TODO: Check deserialization.
+}
+
+TEST_CASE("ParallelTensorShape") {
+  ParallelTensorShape t{std::vector<ParallelDim>{{3, 11, false}, {4, 2, true}},
+                        DataType::FLOAT};
+  V1ParallelTensorShape v1 = to_v1(t);
+
+  CHECK(from_v1(v1) == t);
+
+  json j = v1;
+
+  // We can't check the serialization of the dims (see comment in the test case
+  // for ParallelTensorDims)
+  check_fields(j, {{"dims", "{\"data\":[{"}, {"data_type", "\"FLOAT\""}});
+
+  // TODO: Check deserialization.
+}
+
+TEST_CASE("ParallelTensor") {
+  ParallelTensor t{std::vector<ParallelDim>{{3, 11, false}, {4, 2, true}},
+                   DataType::FLOAT,
+                   CreateGrad::NO,
+                   GlorotUniform{932},
+                   ParamSync::PS,
+                   std::string("tensor")};
+  V1ParallelTensor v1 = to_v1(t);
+
+  CHECK(from_v1(v1) == t);
+
+  json j = v1;
+  // shape is itself an object. Since the order of the fields there may not be
+  // consistent, just check that the key exists. This is particularly relevant
+  // since there is no field named shape in the tensor object.
+  check_fields(j,
+               {{"shape", "{"},
+                {"create_gradients", "\"NO\""},
+                {"initializer", "{"},
+                {"sync_type", "\"PARAM_SERVER\""},
+                {"name", "\"tensor\""}});
+  // TODO: Check deserialization.
+
+  ParallelTensor t0{ParallelTensorDims(
+                        std::vector<ParallelDim>{{3, 11, false}, {4, 2, true}}),
+                    DataType::FLOAT,
+                    CreateGrad::YES,
+                    nullopt,
+                    nullopt,
+                    nullopt};
+  V1ParallelTensor v10 = to_v1(t0);
+
+  CHECK(from_v1(v10) == t0);
+
+  json j0 = v10;
+  check_fields(j0,
+               {{"shape", "{"},
+                {"create_gradients", "\"YES\""},
+                {"initializer", "null"},
+                {"sync_type", "null"},
+                {"name", "null"}});
+  // TODO: Check deserialization.
+}
diff --git a/lib/pcg/test/test_tensor.cc b/lib/pcg/test/test_tensor.cc
index 488ec81360..48c6dc083a 100644
--- a/lib/pcg/test/test_tensor.cc
+++ b/lib/pcg/test/test_tensor.cc
@@ -1,20 +1,58 @@
 #include "doctest.h"
 #include "pcg/file_format/v1/tensor.h"
 #include "pcg/tensor.h"
-#include "utils/containers.h"
+#include "utils.h"
 #include "utils/json.h"
 #include "utils/required.h"
 
-#include <optional>
-
 using namespace FlexFlow;
 
+TEST_CASE("TensorShape") {
+  TensorShape t{{3, 4, 5}, DataType::FLOAT};
+  V1TensorShape v1 = to_v1(t);
+
+  CHECK(from_v1(v1) == t);
+
+  json j = v1;
+  check_fields(j, {{"dims", "[3,4,5]"}, {"data_type", "\"FLOAT\""}});
+  // TODO: Check deserialization.
+}
+
 TEST_CASE("Tensor") {
   Tensor t{{3, 4, 5},
            DataType::FLOAT,
            CreateGrad::NO,
-           nullopt,
-           nullopt,
+           GlorotUniform{932},
+           ParamSync::PS,
            std::string("tensor")};
-  json j = to_v1(t);
+  V1Tensor v1 = to_v1(t);
+
+  CHECK(from_v1(v1) == t);
+
+  json j = v1;
+  // shape is itself an object. Since the order of the fields there may not be
+  // consistent, just check that the key exists. This is particularly relevant
+  // since there is no field named shape in the tensor object.
+  check_fields(j,
+               {{"shape", "{"},
+                {"create_gradients", "\"NO\""},
+                {"initializer", "{"},
+                {"sync_type", "\"PARAM_SERVER\""},
+                {"name", "\"tensor\""}});
+  // TODO: Check deserialization.
+
+  Tensor t0{
+      {3, 4, 5}, DataType::FLOAT, CreateGrad::YES, nullopt, nullopt, nullopt};
+  V1Tensor v10 = to_v1(t0);
+
+  CHECK(from_v1(v10) == t0);
+
+  json j0 = v10;
+  check_fields(j0,
+               {{"shape", "{"},
+                {"create_gradients", "\"YES\""},
+                {"initializer", "null"},
+                {"sync_type", "null"},
+                {"name", "null"}});
+  // TODO: Check deserialization.
 }
diff --git a/lib/utils/include/utils/fmt.h b/lib/utils/include/utils/fmt.h
index 218f72d8af..bd2ea83c1f 100644
--- a/lib/utils/include/utils/fmt.h
+++ b/lib/utils/include/utils/fmt.h
@@ -67,7 +67,7 @@ auto formatter<::std::unordered_set<T>>::format(
     -> decltype(ctx.out()) {
   CHECK_FMTABLE(T);
 
-  std::string result = join_strings(
+  std::string result = ::FlexFlow::join_strings(
       m.cbegin(), m.cend(), ", ", [](T const &t) { return fmt::to_string(t); });
   return formatter<std::string>::format(result, ctx);
 }
@@ -78,7 +78,7 @@ auto formatter<::std::vector<T>>::format(::std::vector<T> const &m,
                                          FormatContext &ctx)
     -> decltype(ctx.out()) {
   CHECK_FMTABLE(T);
-  std::string result = join_strings(
+  std::string result = ::FlexFlow::join_strings(
       m.cbegin(), m.cend(), ", ", [](T const &t) { return fmt::to_string(t); });
   return formatter<std::string>::format(result, ctx);
 }