template <class Return, class... Args>
C10_ALWAYS_INLINE_UNLESS_MOBILE Return Dispatcher::call(
    const TypedOperatorHandle<Return(Args...)>& op,
    Args... args) const {
  auto dispatchKeySet =
      op.operatorDef_->op.dispatchKeyExtractor()
          .template getDispatchKeySetUnboxed<Args...>(args...);
  // ...
  const KernelFunction& kernel = op.operatorDef_->op.lookup(dispatchKeySet);
  // ...
  return kernel.template call<Return, Args...>(
      op, dispatchKeySet, std::forward<Args>(args)...);
}

class TORCH_API KernelFunction final {
  // ...
 private:
  BoxedKernel boxed_kernel_func_;
  void* unboxed_kernel_func_;
  void* sym_unboxed_kernel_func_;
  // ...
};

class TORCH_API BoxedKernel final {
  // ...
  using InternalBoxedKernelFunction =
      void(OperatorKernel*, const OperatorHandle&, DispatchKeySet, Stack*);
  // ...
  c10::intrusive_ptr<OperatorKernel> functor_;
  InternalBoxedKernelFunction* boxed_kernel_func_;
};

struct Shape {                       // 抽象类：有纯虚函数，不能直接实例化
  virtual ~Shape() = default;        // 虚析构（1.3 节解释为什么必须有）
  virtual double area() const = 0;   // 纯虚函数：= 0 表示没有默认实现
  virtual const char* name() const { return "Shape"; }
};
struct Circle final : Shape {        // final：Circle 不能再被继承
  double r;
  explicit Circle(double r) : r(r) {}
  double area() const override { return 3.14159 * r * r; }
  const char* name() const override { return "Circle"; }
};
struct Square : Shape {
  double s;
  explicit Square(double s) : s(s) {}
  double area() const override { return s * s; }
  // 没有覆盖 name()：继承基类版本
};

struct C10_API Allocator {
  virtual ~Allocator() = default;

  virtual DataPtr allocate(size_t n) = 0;
  // ...
  virtual DeleterFnPtr raw_deleter() const {
    return nullptr;
  }
  // ...
  virtual void copy_data(void* dest, const void* src, std::size_t count)
      const = 0;
  // ...
};

struct MetaAllocator final : public at::Allocator {
  MetaAllocator() = default;
  ~MetaAllocator() override = default;
  static void deleter(void* const pointer) {
    TORCH_INTERNAL_ASSERT(!pointer);
  }
  DataPtr allocate(const size_t nbytes [[maybe_unused]]) override {
    return {nullptr, nullptr, &deleter, at::Device(DeviceType::Meta)};
  }
  DeleterFnPtr raw_deleter() const override {
    return deleter;
  }
  void copy_data(void* dest, const void* src, std::size_t count) const final {}
};

std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(1.0));
shapes.push_back(std::make_unique<Square>(2.0));
for (const auto& s : shapes)        // 通过基类指针调用：运行期查 vtable
  std::printf("%s area=%.2f\n", s->name(), s->area());
std::printf("sizeof(NoVirtual)=%zu sizeof(Square)=%zu\n", sizeof(NoVirtual), sizeof(Square));

class C10_API intrusive_ptr_target {
  // ...
 protected:
  // protected destructor. We never want to destruct intrusive_ptr_target*
  // directly.
  virtual ~intrusive_ptr_target() {
    // ...
  }

struct TORCH_API OperatorKernel : public c10::intrusive_ptr_target {
  ~OperatorKernel() override = default;
};

  IntArrayRef sizes() const {
    if (C10_UNLIKELY(matches_policy(SizesStridesPolicy::CustomSizes))) {
      return sizes_custom();
    }
    return sizes_and_strides_.sizes_arrayref();
  }

  enum class SizesStridesPolicy : uint8_t {
    // Default behavior, e.g., dense tensor.
    //
    // Can override: nothing
    Default = 0,
    // Customizable strides behavior, e.g., sparse tensor,
    // mkldnn tensor.
    //
    // Can override: strides(), is_contiguous()
    CustomStrides = 1,
    // Customizable sizes behavior, e.g., nested tensor
    //
    // Can override: strides(), is_contiguous(), sizes(), dim(), numel()
    CustomSizes = 2
  };

 protected:
  inline bool matches_policy(SizesStridesPolicy policy) const {
    return sizes_strides_policy_ >= static_cast<uint8_t>(policy);
  }

  virtual IntArrayRef sizes_custom() const;
  virtual IntArrayRef strides_custom() const;
  virtual int64_t numel_custom() const;
  virtual int64_t storage_offset_custom() const;
  virtual int64_t dim_custom() const;
  virtual Device device_custom() const;
  virtual Layout layout_custom() const;

  virtual c10::SymIntArrayRef sym_sizes_custom() const;
  virtual c10::SymIntArrayRef sym_strides_custom() const;
  virtual c10::SymInt sym_numel_custom() const;
  virtual c10::SymInt sym_storage_offset_custom() const;

struct TORCH_API NestedTensorImpl : public c10::TensorImpl {
  // ...
  int64_t numel_custom() const override;
  c10::SymInt sym_numel_custom() const override;
  // ...
  IntArrayRef sizes_custom() const override;
  c10::SymIntArrayRef sym_sizes_custom() const override;
  IntArrayRef strides_custom() const override;
  c10::SymIntArrayRef sym_strides_custom() const override;

  virtual c10::intrusive_ptr<TensorImpl> shallow_copy_and_detach(
      const c10::VariableVersion& version_counter,
      bool allow_tensor_metadata_change) const;
  // ...
  virtual void shallow_copy_from(const c10::intrusive_ptr<TensorImpl>& impl) {
    copy_tensor_metadata(
        /*src_impl=*/impl.get(),
        /*dest_impl=*/this,
        /*version_counter=*/version_counter(),
        /*allow_tensor_metadata_change=*/allow_tensor_metadata_change());
  }

// WARNING: This class has to be written very carefully, because it may be
// possible for a Tensor to have a reference an interpreter corresponding to
// a shared library that has ALREADY BEEN UNLOADED.  This makes blindly calling
// virtual methods very dangerous, because the vtable may be garbage at that
// point (on a good day, you might get "pure virtual method called").
//
// The idea to solve this problem is we always leak PyInterpreters (so they
// always stay live even after dlclose), and make sure we can disarm their
// virtual methods by indirecting through a separate PyInterpreterVTable
// object.  This can be replaced with a no-op vtable from libc10.so, which
// is guaranteed to stick around until the bitter end.

struct C10_API PyInterpreterVTable {
  virtual ~PyInterpreterVTable() = default;

  // Report the name of this interpreter
  virtual std::string name() const = 0;

  // Run Py_INCREF on a PyObject.
  virtual void incref(PyObject* pyobj) const = 0;
  // Run Py_DECREF on a PyObject.  We DO NOT assume the GIL is held on call.
  virtual void decref(PyObject* pyobj) const = 0;
  // ...
  // Invoke the Python boxed fallback dispatch to go back into Python
  virtual void dispatch(const c10::OperatorHandle& op, torch::jit::Stack* stack)
      const = 0;
  // ...
  virtual c10::IntArrayRef sizes(const TensorImpl* self) const = 0;
  // ...
};

struct C10_API PyInterpreter {
  const PyInterpreterVTable* vtable_;

  PyInterpreter(const PyInterpreterVTable* vtable) : vtable_(vtable) {}

  const PyInterpreterVTable& operator*() const noexcept {
    return *vtable_;
  }
  const PyInterpreterVTable* operator->() const noexcept {
    return vtable_;
  }

  // Disarm this PyInterpreter, making all of its methods noops.
  // ...
  void disarm() noexcept;
};

using DeleterFnPtr = void (*)(void*);                 // 指向 "接受 void*、返回 void" 的函数的指针
using BoxedKernelFunction = void(const OperatorHandle&, Stack*);   // 注意：这是函数类型，不是指针
BoxedKernelFunction* fn = &my_boxed_kernel;           // 加 * 才是指针

  using InternalBoxedKernelFunction =
      void(OperatorKernel*, const OperatorHandle&, DispatchKeySet, Stack*);
  // This is the public API for how boxed kernels are defined
  using BoxedKernelFunction = void(const OperatorHandle&, Stack*);
  using BoxedKernelFunction_withDispatchKeys =
      void(const OperatorHandle&, DispatchKeySet, Stack*);

  /**
   * Create a KernelFunction from an unboxed function.
   * This is usually better than KernelFunction::makeFromUnboxedRuntimeFunction
   * because knowing the function pointer as a template argument (i.e. at
   * compile time) allows the compiler to inline the function into its
   * unboxing wrapper and yields better performance when calling the function.
   *
   * Example:
   *
   * > Tensor unboxed_func(Tensor a, Tensor b) {...}
   * > KernelFunction func =
   * KernelFunction::makeFromUnboxedFunction<decltype(unboxed_func),
   * &unboxed_func>();
   */
  template <class FuncPtr, bool AllowLegacyTypes = false>
  static KernelFunction makeFromUnboxedFunction(FuncPtr /*func_ptr*/);

template <class FuncType_, FuncType_* func_ptr_>
struct CompileTimeFunctionPointer final {
  static_assert(
      guts::is_function_type<FuncType_>::value,
      "TORCH_FN can only wrap function types.");
  using FuncType = FuncType_;

  static constexpr FuncType* func_ptr() {
    return func_ptr_;
  }
};
// ...
#define TORCH_FN_TYPE(func)                                           \
  ::c10::CompileTimeFunctionPointer<                                  \
      std::remove_pointer_t<std::remove_reference_t<decltype(func)>>, \
      func>
#define TORCH_FN(func) TORCH_FN_TYPE(func)()

  ops.impl("silu_and_mul", torch::kCPU, &silu_and_mul);

template <class Return, class... Args>
inline Return callUnboxedKernelFunction(
    void* unboxed_kernel_func,
    OperatorKernel* functor,
    DispatchKeySet dispatchKeySet,
    Args&&... args) {
  using ActualSignature = Return(OperatorKernel*, DispatchKeySet, Args...);
  ActualSignature* func =
      reinterpret_cast<ActualSignature*>(unboxed_kernel_func);
  return (*func)(functor, dispatchKeySet, std::forward<Args>(args)...);
}

class C10_API TaskThreadPoolBase {
 public:
  virtual void run(std::function<void()> func) = 0;
  // ...
};

class C10_API ThreadPool : public c10::TaskThreadPoolBase {
 protected:
  struct task_element_t {
    bool run_with_id;
    // ...
    const std::function<void()> no_id;
    // ...
    const std::function<void(std::size_t)> with_id;
    // ...
  };

  std::queue<task_element_t> tasks_;

// This context is inefficient because we have to do a dynamic
// allocation InefficientStdFunctionContext, on top of the dynamic
// allocation which is implied by std::function itself.
struct C10_API InefficientStdFunctionContext {
  void* ptr_{nullptr};
  std::function<void(void*)> deleter_;
  // ...
  ~InefficientStdFunctionContext() {
    if (deleter_) {
      deleter_(ptr_);
    }
  }
  static DataPtr makeDataPtr(
      void* ptr,
      std::function<void(void*)> deleter,
      Device device);
};

/// An efficient, type-erasing, non-owning reference to a callable. This is
/// intended for use as the type of a function parameter that is not used
/// after the function in question returns.
///
/// This class does not own the callable, so it is not in general safe to store
/// a function_ref.
template <typename Fn>
class function_ref;

template <typename Ret, typename... Params>
class function_ref<Ret(Params...)> {
  Ret (*callback)(intptr_t callable, Params... params) = nullptr;
  intptr_t callable{};

  template <typename Callable>
  static Ret callback_fn(intptr_t callable, Params... params) {
    return (*reinterpret_cast<Callable*>(callable))(
        std::forward<Params>(params)...);
  }

 public:
  // ...
  template <typename Callable>
  function_ref(
      Callable&& callable,
      // ... 两个 enable_if，略
      )
      : callback(callback_fn<std::remove_reference_t<Callable>>),
        callable(reinterpret_cast<intptr_t>(&callable)) {}

  Ret operator()(Params... params) const {
    return callback(callable, std::forward<Params>(params)...);
  }
  // ...
};

  using loop2d_t = c10::function_ref<
      void(char** data, const int64_t* strides, int64_t size0, int64_t size1)>;
  // ...
  void for_each(loop2d_t loop, int64_t grain_size = at::internal::GRAIN_SIZE);

template <typename func_t>
void cpu_kernel(TensorIteratorBase& iter, func_t&& op, int64_t grain_size = at::internal::GRAIN_SIZE, bool check_dynamic_casting = true) {
  using traits = function_traits<func_t>;
  // this could be extended to work with void return types
  TORCH_INTERNAL_ASSERT(iter.ninputs() == traits::arity);
  TORCH_INTERNAL_ASSERT(iter.noutputs() == 1);
  // ...
  iter.for_each([&](char** data, const int64_t* strides, int64_t n) {
    // basic loop can handle 1d slices with arbitrary strides, and 1d slices is all that
    // iter.for_each is ever sending to the loop lambda
      basic_loop(data, strides, 0, n, op);
  }, grain_size);
  iter.cast_outputs();
}

template <typename func_t>
inline void
execute_op(char* C10_RESTRICT data[], const int64_t* strides, int64_t i, int64_t n, func_t&& op) {
  using traits = function_traits<func_t>;
  for (; i < n; i++) {
    std::apply(op, dereference<traits>(
        &data[0],
        &strides[0],
        i));
  }
}

void add_clamp_kernel(
    TensorIterator& iter,
    const Scalar& alpha_scalar,
    const Scalar& min_val,
    const Scalar& max_val) {
  AT_DISPATCH_ALL_TYPES(iter.dtype(), "add_clamp_cpu", [&]() {
    auto alpha = alpha_scalar.to<scalar_t>();
    // ...
    cpu_kernel_vec(
        iter,
        [=](scalar_t a, scalar_t b) __ubsan_ignore_undefined__ -> scalar_t {
          return std::min(
              max_scalar,
              std::max(min_scalar, static_cast<scalar_t>(a + alpha * b)));
        },
        [=](Vectorized<scalar_t> a, Vectorized<scalar_t> b)
            __ubsan_ignore_undefined__ {
              // ...
            });
  });
}

template <typename Derived>
struct ModelBase {
  void run() {
    std::printf("prepare\n");
    static_cast<Derived*>(this)->run_impl();   // 编译期已知 Derived：直接调用，可内联
    std::printf("finish\n");
  }
};
struct MyModel : ModelBase<MyModel> {          // 把自己传给基类
  void run_impl() { std::printf("MyModel::run_impl\n"); }
};

// Defines the base class for AOTInductorModel, which is generated by the
// AOTInductor cpp codegen. Since we do not need dynamic dispatch, we rely
// on curiously recurring template pattern (CRTP) to save some runtime
// v-table overhead. The generated AOTInductorModel is specialized with
// methods such as run_impl.
template <typename Model>
class AOTInductorModelBase {
 public:
  // ...
  void run(
      AtenTensorHandle* input_handles,
      // ...
      DeviceStreamType stream,
      AOTIProxyExecutorHandle proxy_executor) {
    // ... 创建 / 等待 CUDA event
    auto* model = static_cast<Model*>(this);
    model->run_impl(input_handles, output_handles, stream, proxy_executor);
    // ... 记录 CUDA event
  }

class AOTInductorModel : public AOTInductorModelBase<AOTInductorModel> {
 public:
  // ...
  void run_impl(
      AtenTensorHandle* input_handles,
      // ...
      DeviceStreamType stream,
      AOTIProxyExecutorHandle proxy_executor);

/// The `clone()` method in the base `Module` class does not have knowledge of
/// the concrete runtime type of its subclasses. Therefore, `clone()` must
/// either be called from within the subclass, or from a base class that has
/// knowledge of the concrete type. `Cloneable` uses the CRTP to gain
/// knowledge of the subclass' static type and provide an implementation of the
/// `clone()` method. We do not want to use this pattern in the base class,
/// because then storing a module would always require templatizing it.
template <typename Derived>
class Cloneable : public Module {
 public:
  using Module::Module;

  /// `reset()` must perform initialization of all members with reference
  /// semantics, most importantly parameters, buffers and submodules.
  virtual void reset() = 0;

  /// Performs a recursive "deep copy" of the `Module`, ...
  std::shared_ptr<Module> clone(
      const std::optional<Device>& device = std::nullopt) const override {
    NoGradGuard no_grad;

    const auto& self = static_cast<const Derived&>(*this);
    auto copy = std::make_shared<Derived>(self);
    // ...
    copy->reset();
    // ...
    return copy;
  }

/**
 * KernelFunction is similar to std::function but stores a kernel function.
 * You can create a KernelFunction from a boxed or unboxed
 * function/functor/lambda and call it in a boxed or unboxed way. If the way it
 * was created doesn't match the way it was called, it will do boxing or
 * unboxing as necessary.
 */

  BoxedKernel boxed_kernel_func_;
  void* unboxed_kernel_func_;
  void* sym_unboxed_kernel_func_;

  c10::intrusive_ptr<OperatorKernel> functor_;
  InternalBoxedKernelFunction* boxed_kernel_func_;

template <bool AllowLegacyTypes, class KernelFunctor>
inline KernelFunction KernelFunction::makeFromUnboxedFunctor(
    std::unique_ptr<OperatorKernel> kernelFunctor) {
  // ...
  static_assert(
      std::is_base_of_v<OperatorKernel, KernelFunctor>,
      "Tried to call KernelFunction::makeFromUnboxedFunctor<KernelFunctor>, but the functor doesn't inherit from c10::OperatorKernel. Please have the functor inherit from it.");

  auto* unboxed_fn = &impl::wrap_kernel_functor_unboxed<KernelFunctor>::call;
  void* void_unboxed_fn = reinterpret_cast<void*>(unboxed_fn);
  bool is_symint = fn_has_symint<decltype(unboxed_fn)>::value;
  return KernelFunction(
      std::move(kernelFunctor),
      &impl::make_boxed_from_unboxed_functor<KernelFunctor, AllowLegacyTypes>::
          call,
      is_symint ? nullptr : void_unboxed_fn,
      is_symint ? void_unboxed_fn : nullptr);
}

template <class KernelFunctor, class ReturnType, class... ParameterTypes>
struct wrap_kernel_functor_unboxed_<
    KernelFunctor,
    ReturnType(ParameterTypes...)>
    final {
  // ...
  static ReturnType call(
      OperatorKernel* functor,
      DispatchKeySet /*unused*/,
      ParameterTypes... args) {
    KernelFunctor* functor_ = static_cast<KernelFunctor*>(functor);
    // ...
    return (*functor_)(std::forward<ParameterTypes>(args)...);
  }
};

template <class FuncPtr, class ReturnType, class... Parameters>
class WrapFunctionIntoFunctor_<
    FuncPtr,
    ReturnType,
    guts::typelist::typelist<Parameters...>>
    final : public c10::OperatorKernel {
 public:
  C10_ALWAYS_INLINE decltype(auto) operator()(Parameters... args) {
    return (*FuncPtr::func_ptr())(std::forward<Parameters>(args)...);
  }
};

template <class FuncType, class ReturnType, class... Parameters>
class WrapFunctionIntoRuntimeFunctor_<
    FuncType,
    ReturnType,
    guts::typelist::typelist<Parameters...>>
    final : public c10::OperatorKernel {
 public:
  template <class FuncType_>
  explicit WrapFunctionIntoRuntimeFunctor_(FuncType_&& kernel_func)
      : kernel_func_(std::forward<FuncType_>(kernel_func)) {}

  decltype(auto) operator()(Parameters... args) {
    return kernel_func_(std::forward<Parameters>(args)...);
  }

 private:
  FuncType kernel_func_;
};

template <class Return, class... Args>
C10_ALWAYS_INLINE Return KernelFunction::call(
    const OperatorHandle& opHandle,
    DispatchKeySet dispatchKeySet,
    Args... args) const {
  // note: Args above is intentionally not Args&&. We don't want perfect
  // forwarding, which would require Args to be deduced, but instead we
  // want callers to explicitly specify the Args.
  // ...
    if (C10_LIKELY(unboxed_kernel_func_ != nullptr)) {
      auto* functor = boxed_kernel_func_.getFunctor();
      return callUnboxedKernelFunction<Return, Args...>(
          unboxed_kernel_func_,
          functor,
          dispatchKeySet,
          std::forward<Args>(args)...);
    }
  // ...
  return impl::BoxedKernelWrapper<Return(Args...)>::call(
      boxed_kernel_func_,
      opHandle,
      dispatchKeySet,
      std::forward<Args>(args)...);
}

template <class KernelFunctor, bool AllowDeprecatedTypes>
struct make_boxed_from_unboxed_functor final {
  // ...
  static void call(
      OperatorKernel* functor,
      const OperatorHandle& /*unused*/,
      DispatchKeySet dispatchKeySet,
      Stack* stack) {
    using ReturnType =
        typename guts::infer_function_traits_t<KernelFunctor>::return_type;
    // ...
    using ArgTypes = typename c10::remove_DispatchKeySet_arg_from_func<
        KernelFunctor>::parameter_types;
    constexpr bool has_outputs = !std::is_same_v<void, ReturnType>;
    constexpr size_t num_inputs = guts::typelist::size<ArgTypes>::value;
    if constexpr (has_outputs) {
      // ...
      using ReturnType_ = decay_if_tuple_t<ReturnType>;
      ReturnType_ output = call_functor_with_args_from_stack<
          KernelFunctor,
          AllowDeprecatedTypes>(functor, dispatchKeySet, stack);
      torch::jit::drop(*stack, num_inputs);
      // ...
      push_outputs<ReturnType_, AllowDeprecatedTypes>::call(
          ::std::move(output), stack);
    } else {
      call_functor_with_args_from_stack<KernelFunctor, AllowDeprecatedTypes>(
          functor, dispatchKeySet, stack);
      torch::jit::drop(*stack, num_inputs);
    }
  }
};

  return wrap_kernel_functor_unboxed<Functor>::call(
      functor,
      dispatchKeySet,
      ivalue_to_arg<
          typename decay_if_not_tensor<ArgTypes>::type,
          AllowDeprecatedTypes>::
          call(torch::jit::peek(
              *stack, ivalue_arg_indices, sizeof...(ivalue_arg_indices)))...);

template <bool AllowDeprecatedTypes>
struct ivalue_to_arg<const at::Tensor&, AllowDeprecatedTypes> final {
  // We should not use the default implementation if they asked for
  // a `const at::Tensor&` because it moves from the IValue and they
  // didn't ask for that.
  static const at::Tensor& call(IValue& v) {
    // const Tensor& is valid, don't bother asserting
    return v.toTensor();
  }
};

template <class Result, class... Args>
struct BoxedKernelWrapper<
    Result(Args...),
    std::enable_if_t<
        can_box_all<Args...>::value && can_unbox<Result>::value &&
            !is_tuple_of_mutable_tensor_refs<Result>::value,
        void>> {
  static Result call(
      const BoxedKernel& boxed_kernel_func,
      const OperatorHandle& opHandle,
      DispatchKeySet dispatchKeySet,
      Args... args) {
    torch::jit::Stack stack = boxArgs<Args...>(std::forward<Args>(args)...);
    boxed_kernel_func.callBoxed(opHandle, dispatchKeySet, &stack);

    if constexpr (!std::is_same_v<void, Result>) {
      // op has pushed one or more values onto the stack.
      return PopResult<Result>::call(stack);
    } else {
      // ...
    }
  }
};

class TORCH_API CppFunction final {
  // ...
 public:
  /// This overload accepts function pointers, e.g., `CppFunction(&add_impl)`
  template <typename Func>
  explicit CppFunction(
      Func* f,
      std::enable_if_t<
          c10::guts::is_function_type<Func>::value,
          std::nullptr_t>  /*unused*/= nullptr)
      : func_(c10::KernelFunction::makeFromUnboxedRuntimeFunction(f)),
        cpp_signature_(c10::impl::CppSignature::make<Func>()),
        schema_(
            c10::detail::inferFunctionSchemaFromFunctor<std::decay_t<Func>>())
        {}

  /// This overload accepts compile time function pointers, e.g.,
  /// `CppFunction(TORCH_FN(add_impl))`
  template <typename FuncPtr>
  explicit CppFunction(
      FuncPtr f,
      std::enable_if_t<
          c10::is_compile_time_function_pointer<FuncPtr>::value,
          std::nullptr_t>  /*unused*/= nullptr)
      : func_(c10::KernelFunction::makeFromUnboxedFunction(f)),
        // ...
        {}

  /// This overload accepts lambdas, e.g., `CppFunction([](const Tensor& self) {
  /// ... })`
  template <typename Lambda>
  explicit CppFunction(
      Lambda&& f,
      std::enable_if_t<
          c10::guts::is_functor<std::decay_t<Lambda>>::value,
          std::nullptr_t>  /*unused*/= nullptr)
      : func_(c10::KernelFunction::makeFromUnboxedLambda(
            std::forward<Lambda>(f))),
        // ...
        {}

struct ConjFallback : MathOpFallback {
  ConjFallback() : MathOpFallback(DispatchKey::Conjugate, "conjugate") {}
  bool is_bit_set(const Tensor& tensor) override {
    return tensor.is_conj();
  }
};

static void conjugateFallback(const c10::OperatorHandle& op, DispatchKeySet dispatch_keys, torch::jit::Stack* stack) {
  ConjFallback object;
  object.fallback_impl(op, dispatch_keys, stack);
}

TORCH_LIBRARY_IMPL(_, Conjugate, m) {
  m.fallback(torch::CppFunction::makeFromBoxedFunction<&conjugateFallback>());
}

    // A valid kernel *always* has a boxed kernel and *may* have an
    // unboxed kernel. However, we typically do unboxed calls in at::
    // APIs, where the kernel 1) will very likely be valid and 2)
    // should have an unboxed kernel. Checking the unboxed kernel
    // first will allow us to avoid touching the boxed kernel at all
    // in the common case.

/// IValue (Interpreter Value) is a tagged union over the types
/// supported by the TorchScript interpreter. IValues contain their
/// values as an `IValue::Payload`, which holds primitive types
/// (`int64_t`, `bool`, `double`, `Device`) and `Tensor` as values,
/// and all other types as a `c10::intrusive_ptr`. In order to
/// optimize performance of the destructor and related operations by
/// making the `Tensor` and `c10::intrusive_ptr` paths generate the
/// same code, we represent a null `c10::intrusive_ptr` as
/// `UndefinedTensorImpl::singleton()`, *not* `nullptr`.

#define TORCH_FORALL_TAGS(_) \
  _(None)                    \
  _(Tensor)                  \
  _(Storage)                 \
  _(Double)                  \
  _(ComplexDouble)           \
  _(Int)                     \
  _(UInt)                    \
  _(SymInt)                  \
  _(SymFloat)                \
  _(SymBool)                 \
  _(Bool)                    \
  _(Tuple)                   \
  _(String)                  \
  _(Blob)                    \
  _(GenericList)             \
  _(GenericDict)             \
  _(Future)                  \
  _(Await)                   \
  _(Device)                  \
  _(Stream)                  \
  _(Object)                  \
  _(PyObject)                \
  _(Uninitialized)           \
  _(Capsule)                 \
  _(RRef)                    \
  _(Quantizer)               \
  _(Generator)               \
  _(Enum)
// ...
  enum class Tag : uint32_t {
#define DEFINE_TAG(x) x,
    TORCH_FORALL_TAGS(DEFINE_TAG)
#undef DEFINE_TAG
  };

  union Payload {
    // [TriviallyCopyablePayload]
    // We use a nested union here so that we can make the copy easy
    // and efficient in the non-tensor (i.e., trivially copyable)
    // case. Specifically, we do not have to do a switch-on-tag to
    // figure out which union member to assign; we can just use
    // TriviallyCopyablePayload::operator=.
    union TriviallyCopyablePayload {
      TriviallyCopyablePayload() : as_int(0) {}
      int64_t as_int;
      // See Note [Meaning of HAS_u]
      uint64_t as_uint;
      double as_double;
      bool as_bool;
      // Invariant: never nullptr; null state is represented as
      // c10::UndefinedTensorImpl::singleton() for consistency of
      // representation with Tensor.
      c10::intrusive_ptr_target* as_intrusive_ptr;
      struct {
        c10::DeviceType type;
        DeviceIndex index;
      } as_device;
    } u;
    static_assert(std::is_trivially_copyable_v<TriviallyCopyablePayload>);
    at::Tensor as_tensor;
    Payload() : u() {}
    Payload(const Payload&) = delete;
    Payload(Payload&&) = delete;
    Payload& operator=(const Payload&) = delete;
    Payload& operator=(Payload&&) = delete;
    // NOLINTNEXTLINE(modernize-use-equals-default)
    ~Payload() {}
  };
  // ...
  Payload payload;
  Tag tag{IValue::Tag::None};

  IValue(at::TensorBase t) : tag(Tag::Tensor) {
    new (&payload.as_tensor) at::Tensor(std::move(t));
  }
  bool isTensor() const {
    return Tag::Tensor == tag;
  }

 private:
  // Outlined error path so that toTensor() can be inlined.
  [[noreturn]] void reportToTensorTypeError() const;

 public:
  at::Tensor toTensor() &&;
  at::Tensor& toTensor() &;
  const at::Tensor& toTensor() const&;

inline at::Tensor IValue::toTensor() && {
  if (C10_UNLIKELY(!isTensor())) {
    reportToTensorTypeError();
  }
  auto result = std::move(payload.as_tensor);
  // ...
  clearToNone();
  return result;
}
inline at::Tensor& IValue::toTensor() & {
  if (C10_UNLIKELY(!isTensor())) {
    reportToTensorTypeError();
  }
  return payload.as_tensor;
}

  void destroy() {
    // We carefully construct this call to both 1) avoid UB by using
    // the "wrong" one of as_tensor and as_intrusive_ptr and 2) enable
    // the compiler to generate the same code for each case. It is
    // surprisingly difficult to get this right.
    if (isTensor() || isIntrusivePtr()) {
      c10::intrusive_ptr_target* p = isTensor()
          ? payload.as_tensor.unsafeGetTensorImpl()
          : payload.u.as_intrusive_ptr;
      c10::intrusive_ptr<intrusive_ptr_target, c10::UndefinedTensorImpl>::
          reclaim(p);
      // No need to make this destructor call!
      // payload.as_tensor.~Tensor();
    }
  }

static Tensor _linalg_cond_helper(const Tensor& self, std::variant<Scalar, std::string_view> ord_variant) {
  Tensor inverse, info;
  std::tie(inverse, info) = at::linalg_inv_ex(self);
  // ...
  return std::visit([&](auto&& ord) {
    Tensor norm_self = at::linalg_matrix_norm(self, ord);
    Tensor norm_inverse = at::linalg_matrix_norm(inverse, ord);
    Tensor result = norm_self * norm_inverse;
    // ...
    return result;
  }, ord_variant);
}

  // This will be returned by decrement_refcount when it is the last
  // reference remaining and after any pending copies have completed.
  using LastReference = std::unique_ptr<void, DeleterFnPtr>;

  // Decrements the refcount, returning a handle indicating what to
  // do with it.
  std::variant<NotLastReference, LastReference> decrement_refcount();

enum class DispatchKey : uint16_t {      // c10/core/DispatchKey.h
  Undefined = 0,
  // ...
};
enum class ScalarType : int8_t {          // torch/headeronly/core/ScalarType.h
#define DEFINE_ST_ENUM_VAL_(_1, n) n,
  AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(DEFINE_ST_ENUM_VAL_)
#undef DEFINE_ENUM_ST_ENUM_VAL_
      Undefined,
  NumOptions
};

/// The primary ATen error class.
/// Provides a complete error message with source location information via
/// `what()`, and a more concise message via `what_without_backtrace()`.
/// Don't throw this directly; use TORCH_CHECK/TORCH_INTERNAL_ASSERT instead.
///
/// NB: c10::Error is handled specially by the default torch to suppress the
/// backtrace, see torch/csrc/Exceptions.h
class C10_API Error : public std::exception {
 private:
  // The actual error message.
  std::string msg_;

  // Context for the message (in order of decreasing specificity).  ...
  std::vector<std::string> context_;

  // The C++ backtrace at the point when this exception was raised.  ...
  Backtrace backtrace_;
  // ...
 public:
  // PyTorch-style Error constructor.  NB: the implementation of this
  // is actually in Logging.cpp
  Error(SourceLocation source_location, std::string msg);
  // ...
  void add_context(std::string msg);
  // ...
  const char* what() const noexcept override;
  // ...
  virtual const char* what_without_backtrace() const noexcept {
    return what_without_backtrace_.c_str();
  }

// Used in ATen for out-of-bound indices that can reasonably only be detected
// lazily inside a kernel (See: advanced indexing).  These turn into
// IndexError when they cross to Python.
class C10_API IndexError : public Error {
 public:
  using Error::Error;
  IndexError(SourceLocation source_location, std::string msg);
};

// Used in ATen for invalid values.  These turn into
// ValueError when they cross to Python.
class C10_API ValueError : public Error {
  // ...
};

// Used in ATen for invalid types.  These turn into
// TypeError when they cross to Python.
class C10_API TypeError : public Error {
  // ...
};

// Used in ATen for functionality that is not implemented.  These turn into
// NotImplementedError when they cross to Python.
class C10_API NotImplementedError : public Error {
  // ...
};

#define TORCH_CHECK(cond, ...)                     \
  if (C10_UNLIKELY_OR_CONST(!(cond))) {            \
    ::c10::detail::torchCheckFail(                 \
        __func__,                                  \
        __FILE__,                                  \
        static_cast<uint32_t>(__LINE__),           \
        TORCH_CHECK_MSG(cond, "", ##__VA_ARGS__)); \
  }

void torchCheckFail(
    const char* func,
    const char* file,
    uint32_t line,
    const std::string& msg) {
  // NOLINTNEXTLINE(modernize-use-designated-initializers)
  throw ::c10::Error({func, file, line}, msg);
}

static PyObject* set_grad_enabled(PyObject* _unused, PyObject* args, PyObject* kwargs) {
  HANDLE_TH_ERRORS
  // ...
  END_HANDLE_TH_ERRORS
}

#define HANDLE_TH_ERRORS                              \
  try {                                               \
    torch::PyWarningHandler __enforce_warning_buffer; \
    try {
#define _CATCH_GENERIC_ERROR(ErrorType, PythonErrorType, retstmnt) \
  catch (const c10::ErrorType& e) {                                \
    auto msg = torch::get_cpp_stacktraces_enabled()                \
        ? e.what()                                                 \
        : e.what_without_backtrace();                              \
    PyErr_SetString(PythonErrorType, torch::processErrorMsg(msg)); \
    retstmnt;                                                      \
  }

// Only catch torch-specific exceptions
#define CATCH_CORE_ERRORS(retstmnt)                                           \
  catch (python_error & e) {                                                  \
    e.restore();                                                              \
    retstmnt;                                                                 \
  }                                                                           \
  // ...
  _CATCH_GENERIC_ERROR(IndexError, PyExc_IndexError, retstmnt)                \
  _CATCH_GENERIC_ERROR(ValueError, PyExc_ValueError, retstmnt)                \
  _CATCH_GENERIC_ERROR(TypeError, PyExc_TypeError, retstmnt)                  \
  _CATCH_GENERIC_ERROR(                                                       \
      NotImplementedError, PyExc_NotImplementedError, retstmnt)               \
  // ...
  _CATCH_GENERIC_ERROR(Error, PyExc_RuntimeError, retstmnt)                   \
  // ...

#define END_HANDLE_TH_ERRORS_RET(retval)                            \
  }                                                                 \
  catch (...) {                                                     \
    __enforce_warning_buffer.set_in_exception();                    \
    throw;                                                          \
  }                                                                 \
  }                                                                 \
  catch (const std::exception&) {                                   \
    torch::translate_exception_to_python(std::current_exception()); \
    return retval;                                                  \
  }

#define END_HANDLE_TH_ERRORS END_HANDLE_TH_ERRORS_RET(nullptr)

static C10_NOINLINE c10::TypedOperatorHandle<add_Tensor::schema> create_add_Tensor_typed_handle() {
  return c10::Dispatcher::singleton()
      .findSchemaOrThrow(add_Tensor::name, add_Tensor::overload_name)
      .typed<add_Tensor::schema>();
}
at::Tensor add_Tensor::call(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) {
    static auto op = create_add_Tensor_typed_handle();
    return op.call(self, other, alpha);
}

  template <class FuncType>
  TypedOperatorHandle<FuncType> typed() const {
    // ...
#if !defined C10_MOBILE
    operatorDef_->op.assertSignatureIsCorrect<FuncType>();
    // ...
#endif
    return TypedOperatorHandle<FuncType>(operatorIterator_);
  }

template <class Return, class... Args>
class TypedOperatorHandle<Return(Args...)> final : public OperatorHandle {
 public:
  // ...
  C10_ALWAYS_INLINE Return call(Args... args) const {
    return c10::Dispatcher::singleton().call<Return, Args...>(
        *this, std::forward<Args>(args)...);
  }

template <class Return, class... Args>
C10_ALWAYS_INLINE_UNLESS_MOBILE Return Dispatcher::call(
    const TypedOperatorHandle<Return(Args...)>& op,
    Args... args) const {
  auto dispatchKeySet =
      op.operatorDef_->op.dispatchKeyExtractor()
          .template getDispatchKeySetUnboxed<Args...>(args...);
#if defined(HAS_TORCH_SHOW_DISPATCH_TRACE) || !defined(NDEBUG)
  DispatchTraceNestingGuard debug_guard;
  if (show_dispatch_trace()) {
    detail::_print_dispatch_trace(
        "[call]", toString(op.operator_name()), dispatchKeySet);
  }
#endif
  const KernelFunction& kernel = op.operatorDef_->op.lookup(dispatchKeySet);
#ifndef PYTORCH_DISABLE_PER_OP_PROFILING
  auto step_callbacks =
      at::getStepCallbacksUnlessEmpty(at::RecordScope::FUNCTION);
  if (C10_UNLIKELY(
          step_callbacks.has_value() && op.operatorDef_->op.isObserved())) {
    return callWithDispatchKeySlowPath<Return, Args...>(
        op,
        *step_callbacks,
        dispatchKeySet,
        kernel,
        std::forward<Args>(args)...);
  }
#endif // PYTORCH_DISABLE_PER_OP_PROFILING
  // ...
  return kernel.template call<Return, Args...>(
      op, dispatchKeySet, std::forward<Args>(args)...);
}

  constexpr auto num_boxed_args = impl::boxed_size<Args...>();
  if constexpr (num_boxed_args != 0) {
    if (guard.needsInputs()) {
      // If we used std::array<IValue, num_boxed_args> here, we would
      // have to spend time default constructing the IValues in
      // boxedArgs. aligned_storage has no such requirement.
      // NOLINTNEXTLINE(*array*)
      alignas(IValue) std::byte boxedArgs[num_boxed_args * sizeof(IValue)];
      // ...
      IValue* boxedArgsPtr = reinterpret_cast<IValue*>(boxedArgs);
      impl::boxArgsToStack(boxedArgsPtr, args...);
      // ...
      runRecordFunction(
          guard,
          schema_ref,
          dispatchKey,
          dispatchKeySet,
          c10::ArrayRef<const c10::IValue>(
              reinterpret_cast<IValue*>(boxedArgs), num_boxed_args));
      boxedArgsPtr = reinterpret_cast<IValue*>(boxedArgs);
      for (size_t ii = 0; ii < num_boxed_args; ++ii) {
        (boxedArgsPtr + ii)->~IValue();
      }
    }
    // ...
  }

  const KernelFunction& lookup(DispatchKeySet ks) const {
    const auto idx = ks.getDispatchTableIndexForDispatchKeySet();
    if (C10_UNLIKELY(idx == -1)) {
      reportError(ks.highestPriorityTypeId());
    }
    const auto& kernel = dispatchTable_[idx];
    // A valid kernel *always* has a boxed kernel and *may* have an
    // unboxed kernel. However, we typically do unboxed calls in at::
    // APIs, where the kernel 1) will very likely be valid and 2)
    // should have an unboxed kernel. Checking the unboxed kernel
    // first will allow us to avoid touching the boxed kernel at all
    // in the common case.
    if (C10_UNLIKELY(!kernel.isValidUnboxed())) {
      if (!kernel.isValid()) {
        reportError(ks.highestPriorityTypeId());
      }
    }
    return kernel;
  }

  std::array<KernelFunction, c10::num_runtime_entries> dispatchTable_;

  // kernels_ stores all registered kernels for the corresponding dispatch key
  // and catchAllKernels_ stores the catch-all kernels.
  // If an operator library gets loaded that overwrites an already existing
  // kernel, both kernels will be in that list but only the newer one will be in
  // dispatchTable. If any of the kernels go away (say the library gets
  // unloaded), we remove the kernel from this list and update the
  // dispatchTable if necessary.
  // Kernels in the list are ordered by registration time descendingly,
  // newer registrations are before older registrations.
  // We do not combine dispatchTable and kernels into one hash map because
  // kernels is a larger data structure and accessed quite infrequently
  // while dispatchTable is accessed often and should be kept small to fit
  // into CPU caches.
  // Invariants:
  //  - dispatchTable[dispatch_key] == kernels_[dispatch_key].front()
  //  - dispatchTable[dispatch_key] does not exist if and only if
  //    kernels_[dispatch_key] does not exist
  //  - If kernels_[dispatch_key] exists, then it has elements.
  //    It is never an empty list.
  // ...
  ska::flat_hash_map<
      DispatchKey,
#ifdef C10_DISPATCHER_ONE_KERNEL_PER_DISPATCH_KEY
      // On mobile, we needn't worry about Jupyter notebooks.
      std::array<AnnotatedKernel, 1>
#else
      std::list<AnnotatedKernel>
#endif
      >
      kernels_;

OperatorEntry::AnnotatedKernelContainerIterator OperatorEntry::registerKernel(
  const c10::Dispatcher& dispatcher,
  std::optional<DispatchKey> dispatch_key,
  KernelFunction kernel,
  std::optional<CppSignature> cpp_signature,
  std::unique_ptr<FunctionSchema> inferred_function_schema,
  std::string debug
) {
  if (cpp_signature.has_value()) {
    auto& local_cpp_signature = kernel.isValidSymUnboxed() ? sym_cpp_signature_ : cpp_signature_;
    if (local_cpp_signature.has_value()) {
      TORCH_CHECK(*cpp_signature == local_cpp_signature->signature,
        "\nMismatch in kernel C++ signatures\n",
        // ...
      );
    } else {
      local_cpp_signature = CppSignatureWithDebug { *cpp_signature, debug, dispatch_key };
    }
  }
  // ...
  auto& k = dispatch_key.has_value() ? kernels_[*dispatch_key] : kernels_[DispatchKey::CompositeImplicitAutograd];
  // ...
  k.emplace_front(std::move(kernel), std::move(inferred_function_schema), std::move(debug));
  // ...
  AnnotatedKernelContainerIterator inserted = k.begin();
  if (dispatch_key.has_value()) {
    updateDispatchTable_(dispatcher, *dispatch_key);
  } else {
    updateDispatchTableFull_(dispatcher);
  }
  return inserted;
}

namespace {

at::Tensor wrapper_CPU_add_Tensor(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) {
  // ... 结构化 kernel 的 out 分配、TensorIterator 构建
  return at::native::add(self, other, alpha);   // 概念上如此；结构化算子的实际展开更复杂
}

} // anonymous namespace

TORCH_LIBRARY_IMPL(aten, CPU, m) {
  m.impl("add.Tensor", TORCH_FN(wrapper_CPU_add_Tensor));
}

// minic10/core/DispatchKey.h
#pragma once
#include <cstdint>

namespace minic10 {

// 与真实的 c10::DispatchKey（enum class DispatchKey : uint16_t）一样是 scoped enum：
// 不会隐式转成整数，也不会把枚举名泄漏到 minic10 命名空间里。
// 枚举值的顺序就是优先级：后面的键优先级更高（Autograd > Meta > CPU）。
enum class DispatchKey : uint8_t { CPU, Meta, Autograd, NumKeys };

constexpr uint8_t num_dispatch_keys = static_cast<uint8_t>(DispatchKey::NumKeys);

inline const char* toString(DispatchKey k) {
  switch (k) {
    case DispatchKey::CPU: return "CPU";
    case DispatchKey::Meta: return "Meta";
    case DispatchKey::Autograd: return "Autograd";
    case DispatchKey::NumKeys: break;
  }
  return "Unknown";
}

}  // namespace minic10

// minic10/dispatch/IValue.h
#pragma once
#include <cstdint>
#include <new>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include "minic10/core/Tensor.h"

namespace minic10 {

// IValue：一个"能装下任何算子参数"的盒子。对照 aten/src/ATen/core/ivalue.h：
// tag 说明 payload 里现在放的是什么，payload 是一个 union。
// 只支持 boxed 调用路径需要的四种类型：Tensor、double、int64_t、bool。
class IValue final {
 public:
  enum class Tag : uint8_t { None, Tensor, Double, Int, Bool };

  IValue() noexcept = default;
  /* implicit */ IValue(Tensor t) : tag_(Tag::Tensor) {
    new (&payload_.as_tensor) Tensor(std::move(t));   // placement new：手工在 union 里构造
  }
  /* implicit */ IValue(double d) : tag_(Tag::Double) { payload_.as_double = d; }
  /* implicit */ IValue(int64_t i) : tag_(Tag::Int) { payload_.as_int = i; }
  /* implicit */ IValue(bool b) : tag_(Tag::Bool) { payload_.as_bool = b; }

  // 拷贝/移动/析构必须自己写：union 不知道现在活着的是哪个成员，只有 tag 知道。
  IValue(const IValue& rhs) : tag_(rhs.tag_) {
    if (rhs.isTensor()) {
      new (&payload_.as_tensor) Tensor(rhs.payload_.as_tensor);   // 引用计数 +1
    } else {
      payload_.as_int = rhs.payload_.as_int;   // 非 Tensor 成员都是平凡可拷贝的，按位拷
    }
  }
  IValue(IValue&& rhs) noexcept { moveFrom(std::move(rhs)); }
  // 与 ivalue.h 里的写法相同：移动赋值 = 先销毁自己，再从 rhs 搬过来；拷贝赋值复用移动赋值。
  IValue& operator=(IValue&& rhs) noexcept {
    if (this != &rhs) {
      destroy();
      moveFrom(std::move(rhs));
    }
    return *this;
  }
  IValue& operator=(const IValue& rhs) {
    *this = IValue(rhs);
    return *this;
  }
  ~IValue() { destroy(); }

  Tag tag() const noexcept { return tag_; }
  bool isNone() const noexcept { return tag_ == Tag::None; }
  bool isTensor() const noexcept { return tag_ == Tag::Tensor; }
  bool isDouble() const noexcept { return tag_ == Tag::Double; }
  bool isInt() const noexcept { return tag_ == Tag::Int; }
  bool isBool() const noexcept { return tag_ == Tag::Bool; }

  // 和真实 IValue 一样：toX() 不做任何转换，只是"打开盒子"；tag 不对就抛异常。
  // 三个 ref-qualifier 重载：左值返回引用（不拷贝），右值把 Tensor 移出来。
  const Tensor& toTensor() const& { checkTag(Tag::Tensor, "Tensor"); return payload_.as_tensor; }
  Tensor& toTensor() & { checkTag(Tag::Tensor, "Tensor"); return payload_.as_tensor; }
  Tensor toTensor() && {
    checkTag(Tag::Tensor, "Tensor");
    Tensor result = std::move(payload_.as_tensor);
    payload_.as_tensor.~Tensor();
    tag_ = Tag::None;
    return result;
  }
  double toDouble() const { checkTag(Tag::Double, "Double"); return payload_.as_double; }
  int64_t toInt() const { checkTag(Tag::Int, "Int"); return payload_.as_int; }
  bool toBool() const { checkTag(Tag::Bool, "Bool"); return payload_.as_bool; }

  // 泛型出口：unboxing 时按 C++ 类型取值。if constexpr 让不匹配的分支根本不参与编译。
  template <class T>
  T to() && {
    if constexpr (std::is_same_v<T, Tensor>) {
      return std::move(*this).toTensor();
    } else if constexpr (std::is_same_v<T, double>) {
      return toDouble();
    } else if constexpr (std::is_same_v<T, int64_t>) {
      return toInt();
    } else if constexpr (std::is_same_v<T, bool>) {
      return toBool();
    } else {
      static_assert(sizeof(T) == 0, "IValue::to<T>: unsupported type");
    }
  }

  const char* tagKind() const noexcept {
    switch (tag_) {
      case Tag::None: return "None";
      case Tag::Tensor: return "Tensor";
      case Tag::Double: return "Double";
      case Tag::Int: return "Int";
      case Tag::Bool: return "Bool";
    }
    return "?";
  }

 private:
  void checkTag(Tag expected, const char* name) const {
    if (tag_ != expected) {
      throw std::runtime_error(std::string("Expected ") + name + " but got " + tagKind());
    }
  }
  void destroy() noexcept {
    if (isTensor()) payload_.as_tensor.~Tensor();   // 只有 Tensor 成员有析构函数需要手工调
    tag_ = Tag::None;
  }
  void moveFrom(IValue&& rhs) noexcept {
    tag_ = rhs.tag_;
    if (rhs.isTensor()) {
      new (&payload_.as_tensor) Tensor(std::move(rhs.payload_.as_tensor));
      rhs.payload_.as_tensor.~Tensor();
    } else {
      payload_.as_int = rhs.payload_.as_int;
    }
    rhs.tag_ = Tag::None;
  }

  // 有非平凡成员（Tensor）的 union：编译器不再生成构造/析构，必须自己管。
  union Payload {
    int64_t as_int;
    double as_double;
    bool as_bool;
    Tensor as_tensor;
    Payload() : as_int(0) {}
    ~Payload() {}   // 故意为空：由 IValue 按 tag 决定要不要调 ~Tensor
  } payload_;
  Tag tag_ = Tag::None;
};

// boxed 调用约定用的"栈"：参数按顺序压入，kernel 弹出参数、压入返回值。
using Stack = std::vector<IValue>;

}  // namespace minic10

// minic10/dispatch/KernelFunction.h
#pragma once
#include <cstddef>
#include <type_traits>
#include <utility>

#include "minic10/dispatch/IValue.h"
#include "minic10/util/intrusive_ptr.h"

namespace minic10 {

class OperatorHandle;   // 定义在 Dispatcher.h；这里只需要"有这么个类型"

// ---------------------------------------------------------------------------
// 1. 函数签名萃取：从函数指针 / 函数对象 / lambda 拿到返回类型和参数类型
//    对照 c10/util/TypeTraits.h 里的 guts::infer_function_traits
// ---------------------------------------------------------------------------
template <class... Ts>
struct typelist {};

template <class T>
struct function_traits;

template <class R, class... Args>
struct function_traits<R(Args...)> {
  using return_type = R;
  using parameter_types = typelist<Args...>;
  using func_type = R(Args...);
  static constexpr size_t arity = sizeof...(Args);
};
template <class R, class... Args>
struct function_traits<R (*)(Args...)> : function_traits<R(Args...)> {};
// 成员函数指针（函数对象和 lambda 的 operator()），const / 非 const 两种
template <class C, class R, class... Args>
struct function_traits<R (C::*)(Args...)> : function_traits<R(Args...)> {};
template <class C, class R, class... Args>
struct function_traits<R (C::*)(Args...) const> : function_traits<R(Args...)> {};

// 函数对象：看它的 operator()
template <class Functor>
struct infer_function_traits : function_traits<decltype(&Functor::operator())> {};
template <class R, class... Args>
struct infer_function_traits<R (*)(Args...)> : function_traits<R(Args...)> {};
template <class R, class... Args>
struct infer_function_traits<R(Args...)> : function_traits<R(Args...)> {};

// ---------------------------------------------------------------------------
// 2. OperatorKernel：所有被类型擦除的 kernel 对象的公共基类
//    对照 aten/src/ATen/core/boxing/OperatorKernel.h
//    它只有一个虚析构：KernelFunction 通过 intrusive_ptr<OperatorKernel> 持有派生类对象，
//    释放时必须调到派生类的析构函数。除此之外没有任何虚函数——调用不走 vtable。
// ---------------------------------------------------------------------------
struct OperatorKernel : intrusive_ptr_target {
  ~OperatorKernel() override = default;
};

namespace impl {

// 把一个编译期已知的函数指针包成函数对象（对照 WrapFunctionIntoFunctor.h）。
// Func 是非类型模板参数：编译器知道它指向哪个函数，可以把调用直接内联。
template <auto Func, class Sig>
struct WrapFunctionIntoFunctor_;
template <auto Func, class R, class... Params>
struct WrapFunctionIntoFunctor_<Func, R(Params...)> final : OperatorKernel {
  R operator()(Params... args) { return (*Func)(std::forward<Params>(args)...); }
};
template <auto Func>
using WrapFunctionIntoFunctor =
    WrapFunctionIntoFunctor_<Func, typename infer_function_traits<decltype(Func)>::func_type>;

// 把运行期的函数对象 / lambda 包成 OperatorKernel（对照 WrapFunctionIntoRuntimeFunctor.h）
template <class FuncType, class Sig>
struct WrapFunctionIntoRuntimeFunctor_;
template <class FuncType, class R, class... Params>
struct WrapFunctionIntoRuntimeFunctor_<FuncType, R(Params...)> final : OperatorKernel {
  explicit WrapFunctionIntoRuntimeFunctor_(FuncType f) : kernel_func_(std::move(f)) {}
  R operator()(Params... args) { return kernel_func_(std::forward<Params>(args)...); }
 private:
  FuncType kernel_func_;
};
template <class FuncType>
using WrapFunctionIntoRuntimeFunctor =
    WrapFunctionIntoRuntimeFunctor_<FuncType, typename infer_function_traits<FuncType>::func_type>;

// unboxed 包装：一个签名为 R(OperatorKernel*, Params...) 的静态函数。
// 它的地址会被存成 void*，调用时再按同一签名 cast 回来。
// 对照 make_boxed_from_unboxed_functor.h 里的 wrap_kernel_functor_unboxed_
template <class KernelFunctor, class Sig>
struct wrap_kernel_functor_unboxed_;
template <class KernelFunctor, class R, class... Params>
struct wrap_kernel_functor_unboxed_<KernelFunctor, R(Params...)> final {
  static R call(OperatorKernel* functor, Params... args) {
    // static_cast 而不是 dynamic_cast：注册时就知道 functor 的真实类型，不需要运行期检查
    KernelFunctor* f = static_cast<KernelFunctor*>(functor);
    return (*f)(std::forward<Params>(args)...);
  }
};
template <class KernelFunctor>
using wrap_kernel_functor_unboxed =
    wrap_kernel_functor_unboxed_<KernelFunctor, typename infer_function_traits<KernelFunctor>::func_type>;

// unboxing：从栈上的一个 IValue 取出 kernel 参数需要的 C++ 类型。
// Tensor 参数返回引用（不拷贝、不移动），其余类型按值取出。对照 ivalue_to_arg。
template <class T>
decltype(auto) ivalue_to_arg(IValue& v) {
  if constexpr (std::is_same_v<std::decay_t<T>, Tensor>) {
    return v.toTensor();   // Tensor&，可以绑定到 const Tensor& 形参
  } else {
    return std::move(v).to<std::decay_t<T>>();
  }
}

// boxed 包装：从 Stack 上取参数 → 调 unboxed functor → 把返回值压回栈。
// 对照 make_boxed_from_unboxed_functor
template <class KernelFunctor>
struct make_boxed_from_unboxed_functor final {
  static void call(OperatorKernel* functor, const OperatorHandle& /*op*/, Stack* stack) {
    using traits = infer_function_traits<KernelFunctor>;
    call_(functor, stack, std::make_index_sequence<traits::arity>{},
          static_cast<typename traits::parameter_types*>(nullptr));
  }

 private:
  template <size_t... I, class... Params>
  static void call_(OperatorKernel* functor, Stack* stack, std::index_sequence<I...>,
                    typelist<Params...>*) {
    using R = typename infer_function_traits<KernelFunctor>::return_type;
    constexpr size_t N = sizeof...(Params);
    const size_t base = stack->size() - N;   // 参数是栈顶的 N 个元素
    if constexpr (std::is_void_v<R>) {
      wrap_kernel_functor_unboxed<KernelFunctor>::call(
          functor, ivalue_to_arg<Params>((*stack)[base + I])...);
      stack->erase(stack->end() - N, stack->end());
    } else {
      R output = wrap_kernel_functor_unboxed<KernelFunctor>::call(
          functor, ivalue_to_arg<Params>((*stack)[base + I])...);
      stack->erase(stack->end() - N, stack->end());   // 先弹参数
      stack->emplace_back(std::move(output));         // 再压返回值
    }
  }
};

}  // namespace impl

// ---------------------------------------------------------------------------
// 3. KernelFunction：类型擦除的 kernel。对照 aten/src/ATen/core/boxing/KernelFunction.h
//    三个字段：
//      functor_             拥有 kernel 对象（可能为空，例如 boxed 函数指针）
//      boxed_kernel_func_   永远有效的 boxed 入口
//      unboxed_kernel_func_ 快路径；类型被擦成 void*，调用时按 Return(OperatorKernel*, Args...) cast 回来
// ---------------------------------------------------------------------------
class KernelFunction final {
 public:
  // 用户写 boxed kernel 时的签名（对照 BoxedKernel::BoxedKernelFunction）
  using BoxedKernelFunction = void(const OperatorHandle&, Stack*);
  // 内部统一存储的 boxed 签名，多一个 OperatorKernel* 用来传 functor
  using InternalBoxedKernelFunction = void(OperatorKernel*, const OperatorHandle&, Stack*);

  KernelFunction() = default;

  bool isValid() const noexcept { return boxed_kernel_func_ != nullptr; }
  bool isValidUnboxed() const noexcept { return unboxed_kernel_func_ != nullptr; }

  void callBoxed(const OperatorHandle& op, Stack* stack) const {
    if (!boxed_kernel_func_) throw std::runtime_error("callBoxed on an uninitialized KernelFunction");
    (*boxed_kernel_func_)(functor_.get(), op, stack);
  }

  // 注意 Args 不是 Args&&：调用方必须显式写出 <Return, Args...>，
  // 因为 unboxed_kernel_func_ 只有按注册时的精确签名 cast 才是合法的。
  // 对照 KernelFunction_impl.h 的 KernelFunction::call 与 [Note: Argument forwarding in the dispatcher]
  template <class Return, class... Args>
  Return call(const OperatorHandle& op, Args... args) const {
    if (unboxed_kernel_func_ != nullptr) {
      using ActualSignature = Return(OperatorKernel*, Args...);
      auto* func = reinterpret_cast<ActualSignature*>(unboxed_kernel_func_);
      return (*func)(functor_.get(), std::forward<Args>(args)...);
    }
    // 慢路径：kernel 只有 boxed 版本，把参数装箱后走 boxed 调用（对照 impl::BoxedKernelWrapper）
    Stack stack;
    stack.reserve(sizeof...(Args));
    (stack.emplace_back(std::forward<Args>(args)), ...);   // C++17 折叠表达式
    callBoxed(op, &stack);
    if constexpr (!std::is_void_v<Return>) {
      if (stack.size() != 1) throw std::runtime_error("boxed kernel must push exactly one return value");
      return std::move(stack[0]).to<Return>();
    }
  }

  // ---- 工厂函数：三种来源 ----

  // (a) 编译期函数指针：unboxed 与 boxed 两个入口都有；kernel 调用可被内联
  template <auto Func>
  static KernelFunction makeFromUnboxedFunction() {
    return makeFromUnboxedFunctor<impl::WrapFunctionIntoFunctor<Func>>(
        make_intrusive<impl::WrapFunctionIntoFunctor<Func>>());
  }

  // (b) 运行期函数对象 / lambda：同样两个入口都有，但多一次间接调用
  template <class Lambda>
  static KernelFunction makeFromUnboxedLambda(Lambda&& lambda) {
    using Functor = impl::WrapFunctionIntoRuntimeFunctor<std::decay_t<Lambda>>;
    return makeFromUnboxedFunctor<Functor>(make_intrusive<Functor>(std::forward<Lambda>(lambda)));
  }

  // (c) boxed 函数：只有 boxed 入口，unboxed_kernel_func_ 为空
  template <BoxedKernelFunction* Func>
  static KernelFunction makeFromBoxedFunction() {
    KernelFunction k;
    k.boxed_kernel_func_ = &make_boxed_function<Func>;
    return k;
  }

 private:
  template <class KernelFunctor>
  static KernelFunction makeFromUnboxedFunctor(intrusive_ptr<KernelFunctor> functor) {
    static_assert(std::is_base_of_v<OperatorKernel, KernelFunctor>,
                  "kernel functor must inherit from OperatorKernel");
    KernelFunction k;
    k.functor_ = intrusive_ptr<OperatorKernel>::reclaim(functor.release());   // 派生类指针转基类指针
    k.boxed_kernel_func_ = &impl::make_boxed_from_unboxed_functor<KernelFunctor>::call;
    k.unboxed_kernel_func_ =
        reinterpret_cast<void*>(&impl::wrap_kernel_functor_unboxed<KernelFunctor>::call);
    return k;
  }

  // 把用户的 boxed 函数适配到内部签名（多出的 OperatorKernel* 被丢弃）
  template <BoxedKernelFunction* Func>
  static void make_boxed_function(OperatorKernel* /*unused*/, const OperatorHandle& op, Stack* stack) {
    (*Func)(op, stack);
  }

  intrusive_ptr<OperatorKernel> functor_;
  InternalBoxedKernelFunction* boxed_kernel_func_ = nullptr;
  void* unboxed_kernel_func_ = nullptr;
};

}  // namespace minic10