nvfuser-cu121-torch25 0.2.25.dev20250201__cp312-cp312-manylinux_2_28_x86_64.whl

nvfuser/include/nvfuser/dispatch.h

@@ -0,0 +1,334 @@
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#pragma once
+
+#include <exceptions.h>
+#include <utils.h>
+#include <visibility.h>
+
+#include <complex>
+#include <unordered_map>
+
+// dispatch.h prevents the need from adding manual dispatch in every class that
+// wants to define how to process a series of nodes. dispatch.h provides 4
+// classes that can be inherited providing a means to override functions on a
+// per-node basis. There are currently 4 provided dispatch mechanisms:
+//
+// OptOutDispatch:
+//
+// provides the functions:
+// virtual void handle(ValType* irnode){}
+//
+// This provides a mechanisms to override this handle for particular node
+// types. For example if we only wanted to actually run a function on
+// BinaryOps, we could inherit OptOutDispatch and simply override: void
+// handle(BinaryOp*) { doSomething; } Then we could run through all our
+// Statement* and call OptOutDispatch::handle(statement). When a BinaryOp is
+// encountered our override function will be called. For every other node,
+// nothing will be done.
+//
+// OptInDispatch:
+//
+// This class is similar to OptOutDispatch, however if we encounter a node
+// that we haven't specified an override for in the derived class, an error
+// will be thrown. This is useful if we create a class that is expected to
+// handle any type of node it encounters.
+//
+// OptOutMutator:
+//
+// This class is similar to OptOutDispatch except the functions provided are of
+// type: virtual Statement* mutate(Statement*) this is useful for when we want
+// to have an IR node result from our overloaded functions.
+//
+// OptInMutator:
+//
+// This class is similar to OptInDispatch except the functions provided are of
+// type: virtual Statement* mutate(Statement*) this is useful for when we want
+// to have an IR node result from our overloaded functions.
+
+namespace nvfuser {
+class IrContainer;
+class Fusion;
+
+// Hierarchal dispatch functions for handle
+class Statement;
+class Expr;
+class Val;
+
+#define DISPATCH_FOR_ALL_VALS(f) \
+  f(IterDomain);                 \
+  f(TensorDomain);               \
+  f(TensorView);                 \
+  f(NamedScalar);
+#define DISPATCH_FOR_ALL_KIR_VALS(f) f(Predicate) f(TensorIndex)
+#define DISPATCH_FOR_ALL_HIR_VALS(f) f(Stream)
+
+#define DISPATCH_FOR_ALL_EXPRS(f) \
+  f(FullOp);                      \
+  f(IotaOp);                      \
+  f(EyeOp);                       \
+  f(UnaryOp);                     \
+  f(BinaryOp);                    \
+  f(TernaryOp);                   \
+  f(ArrayConstruct);              \
+  f(StructConstruct);             \
+  f(GetAttr);                     \
+  f(GetItem);                     \
+  f(ReverseArray);                \
+  f(GetMetaData);                 \
+  f(TensorConstruct);             \
+  f(SelectOp);                    \
+  f(IndexSelectOp);               \
+  f(TorchGatherOp);               \
+  f(ScatterOp);                   \
+  f(RNGOp);                       \
+  f(ReductionOp);                 \
+  f(GroupedReductionOp);          \
+  f(WelfordOp);                   \
+  f(GroupedWelfordOp);            \
+  f(LoadStoreOp);                 \
+  f(MmaOp);                       \
+  f(BroadcastOp);                 \
+  f(SqueezeOp);                   \
+  f(ExpandOp);                    \
+  f(RepeatOp);                    \
+  f(ViewAsScalar);                \
+  f(ViewOp);                      \
+  f(CatOp);                       \
+  f(PadOp);                       \
+  f(SliceOp);                     \
+  f(Split);                       \
+  f(Merge);                       \
+  f(Swizzle);                     \
+  f(Swizzle2D);                   \
+  f(Resize);                      \
+  f(MatmulOp);                    \
+  f(LinearOp);                    \
+  f(SdpaFwdOp);                   \
+  f(SdpaBwdOp);                   \
+  f(EmbeddingFwdOp);              \
+  f(Communication);               \
+  f(ForLoop);                     \
+  f(P2PCommunication);
+#define DISPATCH_FOR_ALL_KIR_EXPRS(f) \
+  f(Allocate);                        \
+  f(Asm);                             \
+  f(BlockSync);                       \
+  f(GridSync);                        \
+  f(FenceAsyncProxy);                 \
+  f(WgMmaFence);                      \
+  f(SetMaxNReg);                      \
+  f(Return);                          \
+  f(MBarrierInit);                    \
+  f(MBarrierInvalidate);              \
+  f(MBarrierArrive);                  \
+  f(MBarrierArriveExpectTx);          \
+  f(MBarrierWait);                    \
+  f(MBarrierWaitParity);              \
+  f(BlockSerializeWait);              \
+  f(BlockSerializeRelease);           \
+  f(AsyncWait);                       \
+  f(AsyncCommit);                     \
+  f(IfThenElse);                      \
+  f(GridReduction);                   \
+  f(GroupedGridReduction);            \
+  f(GridBroadcast);                   \
+  f(GridWelford);                     \
+  f(GroupedGridWelford);              \
+  f(VectorizedWelfordOp);             \
+  f(AllocateFusedReduction);          \
+  f(InitMagicZero);                   \
+  f(UpdateMagicZero);                 \
+  f(GetRNGSeedAndOffsetFromHost);     \
+  f(EncodeTensorMapTiled);
+#define DISPATCH_FOR_ALL_HIR_EXPRS(f) \
+  f(HostUnit);                        \
+  f(PostOnStream);                    \
+  f(LaunchKernel);                    \
+  f(SetCurrentStream);                \
+  f(GetCurrentStream);                \
+  f(Wait);                            \
+  f(Synchronize);                     \
+  f(StartCoalescing);                 \
+  f(EndCoalescing);
+
+// Forward declarations for all Val and Expr types
+
+#define M(e) class e;
+DISPATCH_FOR_ALL_VALS(M);
+DISPATCH_FOR_ALL_EXPRS(M);
+#undef M
+
+namespace kir {
+
+#define M(e) class e;
+DISPATCH_FOR_ALL_KIR_VALS(M)
+DISPATCH_FOR_ALL_KIR_EXPRS(M)
+#undef M
+
+} // namespace kir
+
+namespace hir {
+
+#define M(e) class e;
+DISPATCH_FOR_ALL_HIR_VALS(M)
+DISPATCH_FOR_ALL_HIR_EXPRS(M)
+#undef M
+
+} // namespace hir
+
+namespace assoc_comm {
+class FlattenedAssocCommOp;
+} // namespace assoc_comm
+
+// By default, all IR nodes are handled in this dispatch, and will call an empty
+// function on all nodes.
+class OptOutConstDispatch : public PolymorphicBase {
+ protected:
+  virtual void unhandled(const Statement*) {}
+
+ public:
+  // Hierarchal dispatch functions for handle
+  virtual void dispatch(const Statement*);
+  virtual void dispatch(const Expr*);
+  virtual void dispatch(const Val*);
+
+#define M(e) virtual void handle(const e* stmt);
+  M(Val);
+  DISPATCH_FOR_ALL_VALS(M)
+  DISPATCH_FOR_ALL_EXPRS(M)
+  M(assoc_comm::FlattenedAssocCommOp);
+#undef M
+#define M(e) virtual void handle(const kir::e* stmt);
+  DISPATCH_FOR_ALL_KIR_VALS(M)
+  DISPATCH_FOR_ALL_KIR_EXPRS(M)
+#undef M
+#define M(e) virtual void handle(const hir::e* stmt);
+  DISPATCH_FOR_ALL_HIR_VALS(M)
+  DISPATCH_FOR_ALL_HIR_EXPRS(M)
+#undef M
+};
+
+class NVF_API OptOutDispatch : public PolymorphicBase {
+ protected:
+  virtual void unhandled(Statement*);
+
+ public:
+  // Hierarchal dispatch functions for handle
+  virtual void dispatch(Statement*);
+  virtual void dispatch(Expr*);
+  virtual void dispatch(Val*);
+
+#define M(e) virtual void handle(e* stmt);
+  M(Val);
+  DISPATCH_FOR_ALL_VALS(M)
+  DISPATCH_FOR_ALL_EXPRS(M)
+  M(assoc_comm::FlattenedAssocCommOp);
+#undef M
+#define M(e) virtual void handle(kir::e* stmt);
+  DISPATCH_FOR_ALL_KIR_VALS(M)
+  DISPATCH_FOR_ALL_KIR_EXPRS(M)
+#undef M
+#define M(e) virtual void handle(hir::e* stmt);
+  DISPATCH_FOR_ALL_HIR_VALS(M)
+  DISPATCH_FOR_ALL_HIR_EXPRS(M)
+#undef M
+};
+
+class OptInConstDispatch : public OptOutConstDispatch {
+ public:
+  using OptOutConstDispatch::handle;
+
+ protected:
+  void unhandled(const Statement* stmt) final;
+};
+
+class OptInDispatch : public OptOutDispatch {
+ public:
+  using OptOutDispatch::handle;
+
+ protected:
+  void unhandled(Statement* stmt) final;
+};
+
+// Class to perform mutations on Fusion IR. Exprs can simply be redefined, but
+// when mutating values they have to be registered through registerMutation so
+// that exprs can detect there's been a muatation and know to modify all
+// instances of that Val. This means each Val should be mutated "consistently".
+// Otherwise behavior may be difficult to understand as it depends on which
+// order mutate is called in. This class expects user to topologically call the
+// statments of interest so inputs are called and mutated before exprs depending
+// on them.
+//
+// Warning: TensorViews need to be treated carefully. As we don't generally
+// register their mutation when their tensor domains only change. If a TV needs
+// to be swapped out, it needs to be registered as a "proper" mutation like
+// other vals, on top of TensorDomain being updated in the mutated TensorView.
+//
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+class NVF_API OptOutMutator : public PolymorphicBase {
+ public:
+  // Hierarchal dispatch functions for handle
+  virtual void dispatchMutate(Statement* s);
+  virtual void dispatchMutate(Val* v);
+
+  void registerMutation(Val* val, Val* mutation);
+
+  Val* maybeMutated(Val* val) const;
+
+  std::unordered_map<Val*, Val*> mutations_;
+
+  //****Functions below defined in mutator.cpp*****
+
+  // Vals
+  virtual void mutate(Val*);
+
+#define M(e) virtual void mutate(e* stmt);
+  DISPATCH_FOR_ALL_VALS(M)
+#undef M
+#define M(e) virtual void mutate(kir::e* stmt);
+  DISPATCH_FOR_ALL_KIR_VALS(M)
+#undef M
+
+  //! This method replaces e if any inputs or attributes are registered for
+  //! mutation.
+  virtual void mutate(Expr* e) {
+    mutateExpr(
+        e,
+        /*replace_outputs*/ false,
+        /*replace_inputs*/ true,
+        /*replace_attrs*/ true);
+  }
+
+  //! Unlike mutate(Expr*), this method replaces e only if any outputs are
+  //! registered for mutation. Inputs and attributes are unchanges. This method
+  //! is useful for tranferring the definition of e's current outputs to those
+  //! their respective registered mutations.
+  Expr* mutateExprOutputsOnly(Expr* e) {
+    return mutateExpr(
+        e,
+        /*replace_outputs*/ true,
+        /*replace_inputs*/ false,
+        /*replace_attrs*/ false);
+  }
+
+ protected:
+  virtual void removeExpr(IrContainer*, Expr*) const;
+  virtual void registerNewExpr(Expr*) {}
+
+ private:
+  //! Replaces Expr if any inputs, attrs, or outputs are registered for
+  //! mutation. See comment on mutateExprOutputsOnly for more information.
+  Expr* mutateExpr(
+      Expr*,
+      bool replace_outputs = false,
+      bool replace_inputs = true,
+      bool replace_attrs = true);
+};
+
+} // namespace nvfuser

nvfuser/include/nvfuser/driver_api.h

@@ -0,0 +1,49 @@
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#pragma once
+
+#include <cuda.h>
+
+// How to lazily load a driver API and invoke it? Just forget about lazy loading
+// and write code as if you are using the driver API directly. Magic will
+// happen. To understand how the magic works, please refer to the cpp file's doc
+// "How does the magic work?"
+
+namespace nvfuser {
+
+#define DECLARE_DRIVER_API_WRAPPER(funcName) \
+  extern decltype(::funcName)* funcName;
+
+// List of driver APIs that you want the magic to happen.
+#define ALL_DRIVER_API_WRAPPER_CUDA11(fn) \
+  fn(cuDeviceGetAttribute);               \
+  fn(cuDeviceGetName);                    \
+  fn(cuFuncGetAttribute);                 \
+  fn(cuFuncSetAttribute);                 \
+  fn(cuGetErrorName);                     \
+  fn(cuGetErrorString);                   \
+  fn(cuLaunchCooperativeKernel);          \
+  fn(cuLaunchKernel);                     \
+  fn(cuModuleGetFunction);                \
+  fn(cuModuleLoadDataEx);                 \
+  fn(cuModuleUnload);                     \
+  fn(cuOccupancyMaxActiveBlocksPerMultiprocessor)
+
+#if (CUDA_VERSION >= 12000)
+#define ALL_DRIVER_API_WRAPPER(fn)   \
+  ALL_DRIVER_API_WRAPPER_CUDA11(fn); \
+  fn(cuTensorMapEncodeTiled)
+#else
+#define ALL_DRIVER_API_WRAPPER ALL_DRIVER_API_WRAPPER_CUDA11
+#endif
+
+ALL_DRIVER_API_WRAPPER(DECLARE_DRIVER_API_WRAPPER);
+
+#undef DECLARE_DRIVER_API_WRAPPER
+
+} // namespace nvfuser

nvfuser/include/nvfuser/dynamic_transform.h

@@ -0,0 +1,316 @@
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#pragma once
+
+#include <exceptions.h>
+#include <visibility.h>
+
+#include <expr_evaluator.h>
+#include <ir/all_nodes.h>
+#include <ir/cloner.h>
+#include <ir/iostream.h>
+#include <iter_visitor.h>
+#include <logical_domain_map.h>
+#include <transform_view.h>
+#include <utils.h>
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace nvfuser {
+
+class Fusion;
+class DynamicTransformInitialInfoBuilder;
+
+//! Initial information derived only from the symbolic Fusion without input
+//! sizes
+class DynamicTransformInitialInfo {
+ public:
+  Fusion* fusion() const {
+    return fusion_;
+  }
+
+  //! Return whether any dynamic transforms exist in the Fusion, or whether
+  //! there are any tensors which could potentially be empty (size-0 extent)
+  //! given some user input. In either of these cases, concretization may change
+  //! the structure of the Fusion.
+  bool isDynamic() const {
+    return hasPossibleEmptyTensor() || !dynamic_reshaped_tvs_.empty() ||
+        !dynamic_resized_ids_.empty();
+  }
+
+  //! Return whether there are any tensors with unknown extent in some
+  //! dimension, so that they might be empty
+  bool hasPossibleEmptyTensor() const {
+    return !maybe_zero_extents_.empty();
+  }
+
+  //! Return a set of scalars that are inputs or extents of input TensorViews
+  //! and that appear in inputs to dynamic expressions. Any Vals not in this
+  //! list do not affect concretization.
+  const std::unordered_set<Val*>& getRootDynamicVals() const {
+    return root_dynamic_vals_;
+  }
+
+  //! Return a set of scalars that appear as extents in TensorViews in the
+  //! Fusion. If any of these evaluate to zero, there is at least one empty
+  //! TensorView present.
+  const std::vector<Val*>& getMaybeZeroExtents() const {
+    return maybe_zero_extents_;
+  }
+
+  //! Return a vector of outputs of ViewOp expressions that have dynamic output
+  //! shapes
+  const std::vector<TensorView*>& getDynamicReshapedTensorViews() const {
+    return dynamic_reshaped_tvs_;
+  }
+
+  //! Return a vector of outputs of Resize expressions that have symbolic output
+  //! IterTypes
+  const std::vector<IterDomain*>& getDynamicResizedIterDomains() const {
+    return dynamic_resized_ids_;
+  }
+
+  //! Return a vector of outputs of ExpandOp expressions that have Symbolic
+  //! output IterTypes
+  const std::vector<TensorView*>& getDynamicExpandedTensorViews() const {
+    return dynamic_expanded_tvs_;
+  }
+
+  //! Return a vector of outputs of factory expressions like full, iota,
+  //! normal, and uniform that have Symbolic output IterTypes
+  const std::vector<TensorView*>& getDynamicFactoryOutputs() const {
+    return dynamic_factory_tvs_;
+  }
+
+  std::string toString() const;
+
+  DynamicTransformInitialInfo clone(IrCloner& ir_cloner) const;
+
+  //! Return a set containing positions in inputs() holding any scalar input
+  //! that would affect the structure of the concretized Fusion.
+  const std::unordered_set<size_t>& scalarInputsAffectingConcretization()
+      const {
+    return scalar_inputs_affecting_concretization_;
+  }
+
+ protected:
+  //! Holds the set of scalar fusion inputs that affect concretization.
+  std::unordered_set<size_t> scalar_inputs_affecting_concretization_;
+
+ private:
+  DynamicTransformInitialInfo(Fusion* fusion) : fusion_(fusion) {}
+
+ private:
+  Fusion* fusion_ = nullptr;
+
+  // We hold vectors of the _outputs_ of dynamic ops. The reason we don't hold
+  // the ops themselves is that during concretization, the ops will actually be
+  // removed by ir_utils::replaceValInExprInputs. The outputs will not: their
+  // definitions will merely be altered. When the ops are replaced, if we had
+  // referred to them directly here, we would run into segfaults. Referring only
+  // to the outputs avoids this issue.
+  std::vector<TensorView*> dynamic_reshaped_tvs_;
+
+  std::vector<IterDomain*> dynamic_resized_ids_;
+
+  std::vector<TensorView*> dynamic_expanded_tvs_;
+
+  std::vector<TensorView*> dynamic_factory_tvs_;
+
+  // This is a minimal set of scalars to check for empty tensors. If any are
+  // zero, we should traverse to find empty tensors.
+  std::unordered_set<Val*> maybe_zero_extents_set_;
+  // The set above is populated then used to create this unique vector
+  std::vector<Val*> maybe_zero_extents_;
+
+  // Root Vals that determine concretization
+  std::unordered_set<Val*> root_dynamic_vals_;
+
+  friend class DynamicTransformInitialInfoBuilder;
+};
+
+//! A set of transformations for a symbolic fusion with concrete sizes
+//! of the fusion inputs
+class DynamicTransformConcretizationInfo {
+ public:
+  NVF_API DynamicTransformConcretizationInfo(
+      const DynamicTransformInitialInfo* initial_info,
+      ExpressionEvaluator* expr_eval,
+      ExactLogicalDomainMap* exact_map = nullptr);
+
+  //! Return a vector of integers each corresponding to the position in
+  //! initialInfo()->getMaybeZeroExtents() of an extent Val which is guaranteed
+  //! to be zero.
+  const std::vector<int64_t>& getEmptyExtents() const {
+    return empty_extents_;
+  }
+
+  //! Return a vector of pairs holding the index of each reshaped TensorView in
+  //! the vector returned by initialInfo()->getDynamicReshapedTensorViews(),
+  //! along with an AnalyzeViewResult describing how that reshape operation
+  //! should be decomposed into split, merge, squeeze, and broadcast transforms.
+  //!
+  //! In case there are any zeros in the size of the input and output we will
+  //! not perform a reshape but rather replace the output with full(). Then
+  //! instead of an AnalyzeViewResult we will hold a vector of symbolic sizes
+  //! indicating how to concretize the output IterDomains.
+  //!
+  //! The symbolic sizes are the actual sizes 0 or 1, or -1 if the size of a
+  //! given reshaped dimension is greater than 1.
+  using ViewConcretizationInfo =
+      std::variant<AnalyzeViewResult, std::vector<int64_t>>;
+  const std::vector<std::pair<int64_t, ViewConcretizationInfo>>&
+  getReshapeTransforms() const {
+    return reshape_transforms_;
+  }
+
+  //! Return a vector of pairs holding the index of each resized IterDomain in
+  //! the vector returned by initialInfo()->getDynamicResizedIterDomains(),
+  //! along with the IterType it should be concretized to.
+  const std::vector<std::pair<int64_t, IterType>>& getResizeIterTypes() const {
+    return resize_itertypes_;
+  }
+
+  //! Return a vector of pairs holding the index of each expanded TensorView in
+  //! the vector returned by initialInfo()->getDynamicExpandedTensorViews(),
+  //! along with a vector of bools describing whether each axis in the output
+  //! root domain is expanded.
+  const std::vector<std::pair<int64_t, std::vector<bool>>>& getExpandAxes()
+      const {
+    return expand_axes_;
+  }
+
+  //! Return a vector of vectors of pairs. Each vector of pairs corresponds to a
+  //! TensorView returned by by initialInfo()->getDynamicFactoryOutputs(). The
+  //! pairs contain an integer position of a Symbolic axis and the IterType that
+  //! axis will be converted to.
+  const std::vector<std::vector<std::pair<int64_t, IterType>>>&
+  getFactoryOutputIterTypes() const {
+    return factory_output_itertypes_;
+  }
+
+  //! Comparison operator for the purposes of determining cache hits. This does
+  //! not guarantee equality of all members. Instead, it returns equal if the
+  //! resulting concretizations would be structurally equivalent. Note that
+  //! pointers to Statements may differ between equivalent concretizations due
+  //! to cloning before concretization.
+  NVF_API bool operator==(
+      const DynamicTransformConcretizationInfo& other) const;
+
+  bool operator!=(const DynamicTransformConcretizationInfo& other) const {
+    return !(*this == other);
+  }
+
+  //! Given an ExpressionEvaluator which already has input scalars bound to it,
+  //! determine the decomposition of each dynamic reshape operation to use
+  //! during concretization.
+  void analyzeReshapes(ExpressionEvaluator* expr_eval);
+
+  //! Given an ExpressionEvaluator which already has input scalars bound to it,
+  //! determine the concrete IterType of each resized IterDomain.
+  void analyzeResizes(ExpressionEvaluator* expr_eval);
+
+  //! Given an ExpressionEvaluator which already has input scalars bound to it,
+  //! determine which axes of dynamic expand operations are expanded.
+  void analyzeExpands(ExpressionEvaluator* expr_eval);
+
+  //! Given an ExpressionEvaluator which already has input scalars bound to it,
+  //! determine the IterTypes of factory function outputs.
+  void analyzeFactoryOutputs(ExpressionEvaluator* expr_eval);
+
+  const DynamicTransformInitialInfo* initialInfo() const {
+    return initial_info_;
+  }
+
+  void setInitialInfo(const DynamicTransformInitialInfo* initial_info) {
+    initial_info_ = initial_info;
+  }
+
+  Fusion* fusion() const {
+    return initial_info_->fusion();
+  }
+
+  NVF_API std::string toString() const;
+
+  NVF_API size_t hash() const;
+
+ private:
+  DynamicTransformConcretizationInfo(
+      const DynamicTransformInitialInfo* initial_info)
+      : initial_info_(initial_info) {}
+
+ private:
+  const DynamicTransformInitialInfo* initial_info_ = nullptr;
+
+  //! Holds the index of the output TensorView in the vector returned by
+  //! initial_info_->getDynamicReshapedTensorViews(), and the corresponding
+  //! result of analyzeView (or list of IterTypes for output of full() in the
+  //! case of empty reshapes).
+  std::vector<std::pair<int64_t, ViewConcretizationInfo>> reshape_transforms_;
+
+  //! Holds a vector of indices into initial_info_.getMaybeZeroExtents() which
+  //! evaluate to 0
+  std::vector<int64_t> empty_extents_;
+
+  //! Holds the index of the resized IterDomain (output of the Resize op) in the
+  //! vector returned by initial_info_->getDynamicResizedIterDomains() along
+  //! with its concretized IterType
+  std::vector<std::pair<int64_t, IterType>> resize_itertypes_;
+
+  //! Holds the index of the expanded TensorView in the vector returned by
+  //! initial_info_->getDynamicExpandedTensorViews(), and a corresponding vector
+  //! of bools indicating whether each axis is in fact expanded.
+  std::vector<std::pair<int64_t, std::vector<bool>>> expand_axes_;
+
+  //! Holds the axis and IterType corresponding to each TensorView returned by
+  //! initial_info_->getDynamicFactoryOutputs().
+  std::vector<std::vector<std::pair<int64_t, IterType>>>
+      factory_output_itertypes_;
+
+  friend class DynamicTransformInfoBuilder;
+};
+
+class DynamicTransform {
+ public:
+  //! Get initial information before we have inputs. This analyzes the Fusion to
+  //! determine whether it has dynamic operations, and caches their position for
+  //! faster concretization once inputs are available.
+  NVF_API static DynamicTransformInitialInfo getInitialInfo(Fusion* fusion);
+
+  //! Concretizes a given fusion. Note that the concretization is
+  //! in-place and the given fusion is modified. Return a map from old, symbolic
+  //! values to new, concrete values.
+  NVF_API static std::unordered_map<Val*, Val*> concretizeFusion(
+      Fusion* fusion,
+      const DynamicTransformConcretizationInfo* info);
+
+  //! Calls the above after computing concretization info from inputs
+  static std::unordered_map<Val*, Val*> concretizeFusion(
+      Fusion* fusion,
+      const std::vector<c10::IValue>& aten_inputs);
+
+  //! Calls the above after computing concretization info from
+  //! KernelArgumentHolder
+  static std::unordered_map<Val*, Val*> concretizeFusion(
+      Fusion* fusion,
+      const KernelArgumentHolder& args);
+};
+
+} // namespace nvfuser
+
+namespace std {
+template <>
+struct hash<nvfuser::DynamicTransformConcretizationInfo> {
+  size_t operator()(
+      const nvfuser::DynamicTransformConcretizationInfo& info) const {
+    return info.hash();
+  }
+};
+} // namespace std