From 525c3606a9c9e3c0dcc58f285a08830fd7c52f80 Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Tue, 9 Sep 2025 15:49:18 +0800
Subject: [PATCH 001/116] add atvos

---
 best_practices/atvos/atvos.h                  |  87 +++
 best_practices/atvos/block/block_elemwise.h   |  50 ++
 .../atvos/block/block_elemwise_impl.h         |  22 +
 best_practices/atvos/common/dagsch.h          |  28 +
 best_practices/atvos/common/expression.h      | 121 +++
 best_practices/atvos/common/impl/atvos_impl.h | 152 ++++
 best_practices/atvos/common/layout.h          | 116 +++
 best_practices/atvos/common/placeholder.h     | 323 ++++++++
 best_practices/atvos/device/device_vector.h   |  58 ++
 .../atvos/device/device_vector_impl.h         |  31 +
 best_practices/atvos/dfx/check.h              |  25 +
 best_practices/atvos/dfx/kernel_mirror.h      |  32 +
 best_practices/atvos/kernel/kernel_elemwise.h |  35 +
 .../atvos/kernel/kernel_elemwise_impl.h       |  24 +
 best_practices/atvos/tile/tile_alu.h          | 730 ++++++++++++++++++
 15 files changed, 1834 insertions(+)
 create mode 100644 best_practices/atvos/atvos.h
 create mode 100644 best_practices/atvos/block/block_elemwise.h
 create mode 100644 best_practices/atvos/block/block_elemwise_impl.h
 create mode 100644 best_practices/atvos/common/dagsch.h
 create mode 100644 best_practices/atvos/common/expression.h
 create mode 100644 best_practices/atvos/common/impl/atvos_impl.h
 create mode 100644 best_practices/atvos/common/layout.h
 create mode 100644 best_practices/atvos/common/placeholder.h
 create mode 100644 best_practices/atvos/device/device_vector.h
 create mode 100644 best_practices/atvos/device/device_vector_impl.h
 create mode 100644 best_practices/atvos/dfx/check.h
 create mode 100644 best_practices/atvos/dfx/kernel_mirror.h
 create mode 100644 best_practices/atvos/kernel/kernel_elemwise.h
 create mode 100644 best_practices/atvos/kernel/kernel_elemwise_impl.h
 create mode 100644 best_practices/atvos/tile/tile_alu.h

diff --git a/best_practices/atvos/atvos.h b/best_practices/atvos/atvos.h
new file mode 100644
index 000000000..f39122886
--- /dev/null
+++ b/best_practices/atvos/atvos.h
@@ -0,0 +1,87 @@
+#ifndef _ATVC_H_TEMP_H_
+#define _ATVC_H_TEMP_H_
+
+#include "common/impl/atvos_impl.h"
+
+namespace ATVOS {
+
+#pragma region "参数类型"
+template<typename DataType, typename Layout=void, class... Ext>
+using Input = __auxc::Param<__auxc::ParamType::INPUT, DataType, Layout, Ext...>;
+
+template<typename DataType, typename Layout=void, class... Ext>
+using Output = __auxc::Param<__auxc::ParamType::OUTPUT, DataType, Layout, Ext...>;
+
+#pragma endregion
+
+#pragma region "layout"
+template<typename Shape, typename Stride=void>
+struct Layout {
+    Shape shape;
+};
+
+template<class... Args>
+using Shape = std::tuple<Args...>;
+
+template<class... Args>
+Shape<Args...> MakeShape(Args... ts) {
+    return {ts...};
+}
+
+template<typename Shape, typename Stride=void>
+auto MakeLayout(Shape&& shape, Stride&& stride) {
+    return Layout{ shape};
+}
+template<typename Shape>
+auto MakeLayout(Shape&& shape) {
+    return Layout{ shape};
+}
+
+template<typename DataType, class Shape>
+auto MakeTensor(void* gmAddr, Shape&& layout) {
+    return Tensor<DataType,Layout<Shape, void>>{gmAddr, layout};
+}
+ 
+#pragma endregion "layout"
+
+
+template<class Traits>
+struct ArgumentsBase {
+    using LayoutArgs = typename __auxc::TraitsToTensor<Traits>::Type;
+private:
+    template<int offset, class Argc, class... Args>
+    static void SetArgs(LayoutArgs& obj, Argc const & argc, Args const& ... args)    
+    {
+        constexpr static auto size = std::tuple_size_v< std::remove_reference_t< LayoutArgs > >;
+
+        static_assert(offset<size, "sizeof...(args) >=  sizeof(LayoutArgs)");
+
+        //warning: 这个代码要修改，因为常量时 layout 与 传递的layout 的结构是不一样的
+        std::get<offset>(obj) = argc;
+
+        if constexpr ( offset < size - 1 && sizeof...(args) > 0 ) {
+            SetArgs<offset+1>(obj, args...);
+        }
+    }
+public:
+    template<class... Args>
+    ArgumentsBase(Args const &... args) {
+        SetArgs<0>(this->param, args...);
+    }
+    ArgumentsBase(){};
+public:
+    LayoutArgs  param;
+};
+
+
+} //ATVOS
+
+#include "dfx/kernel_mirror.h"
+#include "dfx/check.h"
+
+#include "common/placeholder.h"
+#include "common/expression.h"
+#include "common/dagsch.h"
+
+
+#endif 
\ No newline at end of file
diff --git a/best_practices/atvos/block/block_elemwise.h b/best_practices/atvos/block/block_elemwise.h
new file mode 100644
index 000000000..ff45114fb
--- /dev/null
+++ b/best_practices/atvos/block/block_elemwise.h
@@ -0,0 +1,50 @@
+#ifndef _BlockElemwise_H
+#define _BlockElemwise_H
+
+namespace ATVOS {
+
+template<class Op, class Traits=int, class Policy_=int, class Schedule=void, class... Args>
+class BlockElemwise {
+public:
+    using OpTraits = Traits;
+    using Arguments= ArgumentsBase<OpTraits>;
+    using Policy   = Policy_;
+public:
+    BlockElemwise(){}
+
+    bool CanImplement(Arguments const& arg){ return true;}; //检查参数的合法性
+    int64_t GetWorkspaceSize(Arguments& arg){ return 0; }; 
+    int64_t Run(Arguments const& arg, Policy* policy){ return 0; }; 
+};
+
+template<class DagOp,  class Traits>
+class BlockElemwise<DagOp, Traits, typename DagOp::Policy, typename DagOp::Schedule> {
+public:
+    using ComputeOp = DagOp; //DagSchedule<ComputeOp_>;
+    using OpTraits = Traits;
+    using Arguments= ArgumentsBase<OpTraits>;
+    using Policy   = int;
+
+public: 
+    static_assert( !(Dfx::IsVoid<OpTraits> /* && Dfx::IsVoid<typename ComputeOp::OpTraits> */ ), "OpTraits_ is not void");
+        
+public:
+    //using OpTraits = std::conditional_t<std::is_same_v<OpTraits_, void>, typename ComputeOp::OpTraits, OpTraits_>;
+    //using Arguments= std::conditional_t<std::is_same_v<OpTraits_,void>, typename ComputeOp::Arguments, ArgumentsBase<OpTraits>>;
+    //using Policy   = std::conditional_t<std::is_same_v<Policy_, void>, typename ComputeOp::Policy, Policy_>;
+
+public: 
+
+    BlockElemwise(){}
+
+    bool CanImplement(Arguments const& arg) { return 0; }; 
+    int64_t GetWorkspaceSize(Arguments& arg) { return 0; }; 
+    int64_t Run(Arguments const& arg, Policy* policy){ return 0; }; 
+
+}; 
+
+#include "block_elemwise_impl.h"
+
+} //ATVOS
+
+#endif //_BlockElemwise_H
\ No newline at end of file
diff --git a/best_practices/atvos/block/block_elemwise_impl.h b/best_practices/atvos/block/block_elemwise_impl.h
new file mode 100644
index 000000000..6a3d03ff0
--- /dev/null
+++ b/best_practices/atvos/block/block_elemwise_impl.h
@@ -0,0 +1,22 @@
+#ifndef _ATVOS_BLOCK_ELEMWISE_H_
+#define _ATVOS_BLOCK_ELEMWISE_H_
+
+/*
+template<class ComputeOp_, class OpTraits_>
+bool BlockElemwise<ComputeOp_, OpTraits_>::CanImplement(Arguments const& arg){
+    return 0;
+}
+template<class BlockOp, class OpTraits_>
+int64_t BlockElemwise<ComputeOp_, OpTraits_>::GetWorkspaceSize(Arguments& arg)
+{
+    return 0;
+}
+template<class BlockOp, class OpTraits_>
+int64_t BlockElemwise<ComputeOp_, OpTraits_>:: Run(Arguments const& arg, Policy* policy)
+{
+    std::cout << "cccc" << std::endl;
+    return 0;
+}
+ */     
+    
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos/common/dagsch.h b/best_practices/atvos/common/dagsch.h
new file mode 100644
index 000000000..a1459eca8
--- /dev/null
+++ b/best_practices/atvos/common/dagsch.h
@@ -0,0 +1,28 @@
+#ifndef _ATVOS_DAG_SCHEDUCLE_H_
+#define _ATVOS_DAG_SCHEDUCLE_H_
+
+
+namespace ATVOS {
+
+template<class OutList, class Traits_, class Policy_, class Path =void, class Enable=void>
+class DagSchedule {
+    using OpTraits  =  int;
+    using Arguments =  ArgumentsBase<OpTraits>;
+    using Policy    = int;
+
+public: 
+    //1, 从outlist 中获取输入，输出,  以及Scalar 类型
+    //2, 检查是否存在Copy 函数，决策是否生成Copy
+    //3, 计算Dag 存活节点
+    //4, 基于计算指令，分配地址； 
+    //5, 分析bank 冲突，重新计算地址
+    //6, 切分多核, 生成Tiling 的结构
+
+};
+
+}   // ATVOS
+
+
+
+
+#endif //_ATVOS_DAG_SCHEDUCLE_H_
\ No newline at end of file
diff --git a/best_practices/atvos/common/expression.h b/best_practices/atvos/common/expression.h
new file mode 100644
index 000000000..fdc3805c8
--- /dev/null
+++ b/best_practices/atvos/common/expression.h
@@ -0,0 +1,121 @@
+#ifndef _ATVOS_EXPRESSION_H_
+#define _ATVOS_EXPRESSION_H_
+
+namespace ATVOS {
+
+#if 0 
+/**
+ * @brief condition 
+ * 
+ */
+template<auto C, class T>
+struct TupleFilter {};
+
+template<auto C, class... Ts>
+struct TupleFilter<C, std::tuple<Ts...> >{
+    using Type = decltype(std::tuple_cat(
+        std::conditional_t< C<Ts>(), std::tuple<typename Ts>, std::tuple<>>{}...
+    ));
+};
+ 
+template<class T>
+constexpr bool GetRealArgs() { return true; }
+
+#endif
+
+/**
+ * @tparam Func 需要执行的向量操作函数
+ * @tparam Ts Func的入参
+ */
+template <typename Func, typename... Ts>
+struct Bind {
+public:
+  using Fun = Func;
+  using Args = std::tuple<Ts...>;
+  
+  constexpr static bool IsBindFun = true;
+
+  template<class... Args>
+  constexpr Bind(Args... args){};
+/*
+  using RealArgs = typename TupleFilter<GetRealArgs, Args>::Type;
+
+private:
+  template <typename... Rs>
+  struct CreateRealBind;
+
+  template <typename... Rs>
+  struct CreateRealBind<Elems<Rs...>> {
+    using Type = __aux::Condition<(Vec::IsCastNoOp<Func>::Value),
+                                   typename RealArgs::template At<0>,
+                                   Bind<Func, Rs...>>;
+  };
+
+public:
+  // 消除入参中CastNoOp之后的BindType
+  using RealBindType = typename CreateRealBind<RealArgs>::Type;
+
+  // 第 @offset 个出参Dtype
+  template <int offset>
+  using FunRetArgType = typename Fun::template FunRetArgType<offset>;
+  // 第 @offset 个入参Dtype
+  template <int offset>
+  using FunInArgType = typename Fun::template FunInArgType<offset>;
+
+public:
+  // 当前Bind的输出Dtype
+  using OutDataType = FunRetArgType<0>;
+  using DType = OutDataType;
+
+  // 入参中输出Placeholder的列表（输出GM)
+  using OutHolders = typename Args::template Filter<__aux::TypeIsOutHolder>;
+  // 入参列表（Args中过滤掉Placeholder::Out)
+  using InArgs = typename Args::template Filter<__aux::TypeIsInput>;
+  // 入参中输入Placeholder的列表（输入GM）
+  using InHolders = typename Args::template Filter<__aux::TypeIsInHolder>;
+  // 入参中函数列表（其他Bind类型）
+  using InFuns = typename Args::template Filter<__aux::TypeIsInFun>;
+  // 入参中Scalar变量列表
+  using Vars = typename Args::template Filter<__aux::TypeIsVar>;
+  // 入参中Const输入列表
+  using ConstValues = typename Args::template Filter<__aux::TypeIsConst>;
+  // 入参中输入是TensorScalar的列表
+  using InScalarHolders = typename InHolders::template Filter<__aux::TypeIsInScalarHolder>;
+  // 入参中函数是Scalar操作的列表
+  using InScalarFuns = typename InFuns::template Filter<__aux::TypeIsScalarBind>;
+  // 入参中ReduceOp操作列表
+  using InReduceOpFuns = typename InFuns::template Filter<__aux::TypeIsReduceOpBind>;
+  // 入参中非ScalarOp函数列表
+  using InNonScalarFuns = typename InFuns::template Remove<InScalarFuns>::template Remove<InReduceOpFuns>;
+
+  static_assert(InArgs::Size == InHolders::Size + InFuns::Size + Vars::Size + ConstValues::Size, "why?");
+
+  // 标识当前Bind是否是Scalar操作（不需要使用任何UB空间）
+  constexpr static bool IsScalarOp = InScalarHolders::Size == InHolders::Size && \
+                                     InScalarFuns::Size == InFuns::Size && \
+                                     !Vec::IsDuplicateOp<Fun>::Value;
+
+  // 入参个数
+  constexpr static uint32_t InputSize = InArgs::Size;
+  // 当前Bind的依赖列表：输入依赖 + 自身
+  using DependFuns = typename __aux::GetDependFunsAux<InFuns>::Type::template Append<RealBindType>;
+  // 溯源当前Bind的输入PlaceHolder
+  using SourceInHolders = typename __aux::GetSourceInHoldersAux<InFuns>::Type::template Union<InHolders>;
+
+*/  
+};
+
+
+
+
+template<class TileOp, class... Args>
+constexpr inline auto Expr(Args... agrs) {
+    return Bind<TileOp, Args...>(agrs...);
+}
+
+
+}  // namespace ATVOS
+
+    
+
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos/common/impl/atvos_impl.h b/best_practices/atvos/common/impl/atvos_impl.h
new file mode 100644
index 000000000..9584a636c
--- /dev/null
+++ b/best_practices/atvos/common/impl/atvos_impl.h
@@ -0,0 +1,152 @@
+#ifndef _ATVC_IMPL_H_IMPL_H_
+#define _ATVC_IMPL_H_IMPL_H_
+
+#include <tuple>
+
+namespace ATVOS {
+
+struct EmptyStruct {};    
+
+template<typename DataType, class Layout_>
+struct Tensor {
+    using Type = DataType;
+    using Layout = std::conditional_t< std::is_same_v<Layout_,void>, EmptyStruct, Layout_> ;
+
+    void* gmAddr; 
+    Layout layout;
+};    
+
+namespace __auxc {
+
+#pragma region "算子原型的类型定义"
+
+enum class ParamType {
+        Normal,          // 原生类型，不做处理
+        INPUT,           // GM
+        OUTPUT,          // GM
+        TEMP,            // UB
+        PRE_TEMP_OUTPUT, // UB 
+        POST_TEMP_INPUT, // UB 
+}; 
+template<ParamType paramType_, class DataType_, class Layout_, class... Ext>
+struct Param { 
+        constexpr static ParamType paramType = paramType_;
+        using DataType = DataType_;
+        using Layout =  Layout_;
+        using ExtList = std::tuple<Ext...>;
+};    
+#pragma endregion
+} //namespace  __auxc
+
+namespace __auxc {
+
+#pragma region "OpTraits To Tensor"   
+template<class T>
+struct ArgsToTensorType {
+    using Type = T;
+};
+template<class DataType_, class Layout_, class... Ext>
+struct ArgsToTensorType< Param<ParamType::Normal, DataType_, Layout_, Ext...> >  {
+    using Type = DataType_;
+};
+template<class DataType_, class Layout_, class... Ext>
+struct ArgsToTensorType< Param<ParamType::INPUT, DataType_, Layout_, Ext...> >  {    
+    using Type = Tensor<DataType_, Layout_>;
+};
+template<class DataType_, class Layout_, class... Ext>
+struct ArgsToTensorType< Param<ParamType::OUTPUT, DataType_, Layout_, Ext...> >  {
+    using Type = Tensor<DataType_, Layout_>;
+};
+template<class DataType_, class Layout_, class... Ext>
+struct ArgsToTensorType< Param<ParamType::TEMP, DataType_, Layout_, Ext...> >  {
+    using Type = Tensor<DataType_, Layout_>;
+};
+template<class DataType_, class Layout_, class... Ext>
+struct ArgsToTensorType< Param<ParamType::PRE_TEMP_OUTPUT, DataType_, Layout_, Ext...> >  {
+    using Type = Tensor<DataType_, Layout_>;
+};
+template<class DataType_, class Layout_, class... Ext>
+struct ArgsToTensorType< Param<ParamType::POST_TEMP_INPUT, DataType_, Layout_, Ext...> >  {
+    using Type = Tensor<DataType_, Layout_>;
+};
+
+
+template<class T>
+using ArgsToTensorType_t = typename ArgsToTensorType<T>::Type;
+
+template<class T>
+struct TraitsToTensor {  using Type = T; };
+
+template<class ...Ts>
+struct TraitsToTensor <std::tuple<Ts...> > {
+    using Type = std::tuple< ArgsToTensorType_t<Ts>... >;
+};
+#pragma endregion
+}   //namespace  __auxc
+
+ 
+
+namespace __auxc {
+
+template<class T, class E=void>
+struct GetParamLayout {
+    using Type = EmptyStruct;
+};
+
+template<class T>
+struct GetParamLayout<T, typename T::Layout>
+{
+    using Type = typename T::Layout;
+};
+
+template<class T>
+using GetParamLayoutT = typename GetParamLayout<T>::Type;
+
+
+
+//////////////////////// //////////// //////////// //////////// 
+template<class... Ts>
+struct _TemplateArgs {};
+
+template<>
+struct _TemplateArgs<> {};
+
+template<class T, class... Ts>
+struct _TemplateArgs<T, Ts...> : public _TemplateArgs<Ts...> {
+    using Type = GetParamLayoutT<T>;
+};
+
+
+/////////////////////////////////////////////////////////////
+template<class T>
+struct OpTraitsLayout{
+    using Type = T;
+};
+
+
+//  Ts 为: Input<half  
+template<class... Ts>
+struct OpTraitsLayout< std::tuple<Ts...> > {
+    using Type = _TemplateArgs<Ts...>; 
+};
+
+/////////////////////////////////////////////////////////////
+
+template<int offset, class R, class T, class... Shapes>
+void LayoutSet(R& layout,  T&& src, Shapes&&... ext){
+    layout.template SetLayout<offset>(src);
+    if constexpr( sizeof...(ext) > 0){
+        LayoutSet<offset+1>(layout, std::forward<T>(ext)...);
+    }
+}
+
+
+} //__auxc
+
+
+
+ 
+} //ATVOS
+
+
+#endif //_ATVC_IMPL_H_IMPL_H_
\ No newline at end of file
diff --git a/best_practices/atvos/common/layout.h b/best_practices/atvos/common/layout.h
new file mode 100644
index 000000000..73a5c1cc8
--- /dev/null
+++ b/best_practices/atvos/common/layout.h
@@ -0,0 +1,116 @@
+#ifndef _ATVOSS_LAYOUT_H_
+#define _ATVOSS_LAYOUT_H_
+
+#pragma once
+
+namespace ATVOS { 
+
+template <class... Shapes>
+using Shape = std::tuple<Shapes...>;
+
+template <class... Strides>
+using Stride = std::tuple<Strides...>;
+
+template <class... Coords>
+using Coord = std::tuple<Coords...>;
+
+template <class... Ts>
+constexpr Shape<Ts...> make_shape(Ts const&... t) {
+  return {t...};
+}
+template <class... Ts>
+constexpr Stride<Ts...> make_stride(Ts const&... t) {
+  return {t...};
+} 
+
+template <class... Ts>
+constexpr Coord<Ts...> make_coord(Ts const&... t) {
+  return {t...};
+}
+
+template <class Shape, class Stride = LayoutLeft::Apply<Shape> >
+struct Layout : private std::tuple<Shape, Stride>  {
+  constexpr Layout(Shape  const& shape  = {}, Stride const& stride = {})   : std::tuple<Shape, Stride>(shape, stride)
+  {}
+  constexpr decltype(auto) layout() {   return *this;  }
+
+  constexpr decltype(auto) layout() const {   return *this;  }
+
+  template <int... I>
+  constexpr decltype(auto) shape() {
+    return get<0,I...>(static_cast<std::tuple<Shape, Stride>&>(*this));
+  }
+
+  template <int... I>
+   constexpr   decltype(auto)   shape() const {
+    return get<0,I...>(static_cast<std::tuple<Shape, Stride> const&>(*this));
+  }
+
+  template <int... I>
+   constexpr   decltype(auto)   stride() {
+    return get<1,I...>(static_cast<std::tuple<Shape, Stride>&>(*this));
+  }
+
+  template <int... I>
+   constexpr   decltype(auto)   stride() const {
+    return get<1,I...>(static_cast<std::tuple<Shape, Stride> const&>(*this));
+  }
+  template <class Coord>   constexpr   auto   operator()(Coord const& coord) const {
+    if constexpr (has_underscore<Coord>::value) {
+      return slice(coord, *this);
+    } else {
+      return crd2idx(coord, shape(), stride());
+    }
+  }
+
+  // Convenience function for multi-dimensional coordinates
+  template <class Coord0, class Coord1, class... Coords>
+   constexpr
+  auto
+  operator()(Coord0 const& c0, Coord1 const& c1, Coords const&... cs) const {
+    return operator()(make_coord(c0,c1,cs...));
+  }
+
+};
+
+
+
+template <int... Is, class Shape, class Stride>
+constexpr decltype(auto) layout(Layout<Shape,Stride> const& layout)
+{
+  if constexpr (sizeof...(Is) == 0) {
+    return layout;
+  } else {
+    return get<Is...>(layout);
+  }
+}
+
+template <int... Is, class Shape, class Stride>
+constexpr decltype(auto) shape(Layout<Shape,Stride>& layout)
+{
+  return layout.template shape<Is...>();
+}
+
+template <int... Is, class Shape, class Stride>
+constexpr decltype(auto) shape(Layout<Shape,Stride> const& layout)
+{
+  return layout.template shape<Is...>();
+}
+
+template <int... Is, class Shape, class Stride>
+constexpr auto size(Layout<Shape,Stride> const& layout)
+{
+  return size(shape<Is...>(layout));
+} 
+
+template <int... Is, class Shape, class Stride>
+constexpr auto rank(Layout<Shape,Stride> const& layout)
+{
+  return rank(shape<Is...>(layout));
+} 
+ 
+} //ATVOS
+
+
+
+#endif //_ATVOSS_LAYOUT_H_
\ No newline at end of file
diff --git a/best_practices/atvos/common/placeholder.h b/best_practices/atvos/common/placeholder.h
new file mode 100644
index 000000000..bdca4cd9c
--- /dev/null
+++ b/best_practices/atvos/common/placeholder.h
@@ -0,0 +1,323 @@
+
+/**
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*!
+ * \file placeholder.h
+ * \brief
+ */
+#ifndef _ATVOS_PLACEHOLDER_H_
+#define _ATVOS_PLACEHOLDER_H_
+
+#ifndef __CCE_AICORE__
+#define __aicore__
+#define __global__
+#define __gm__
+#endif
+
+namespace Placeholder {
+
+#define CONCATENATE_DETAIL(name, idx) name##idx
+#define MAKE_UNIQ_NAME(name, idx) CONCATENATE_DETAIL(name, idx)
+#define MAKE_CONST(t, v)                                   \
+  struct MAKE_UNIQ_NAME(ConcatValue_##t##_, __COUNTER__) { \
+    constexpr static bool IsConstValue_ = true;            \
+    static constexpr t value = v;                          \
+  }
+
+enum HolderScope { GM, VECTOR };
+
+template <class T, class Attr_ = void, int cur = 0>
+struct Holder {
+  constexpr static int Pos = cur;
+  constexpr static bool IsHolder = true;
+  using DType = T;
+  using Attr = Attr_;
+};
+
+template <HolderScope scope = HolderScope::GM, int isScalar = 0>
+struct InAttr {
+  constexpr static int IsScalar = isScalar;
+  constexpr static HolderScope Scope = scope;
+};
+
+template <int isScalar = 0>
+struct ScalarAttr : public InAttr<HolderScope::GM, isScalar> {};
+
+template <HolderScope scope = HolderScope::GM>
+struct ScopeAttr : public InAttr<scope, 0> {};
+
+/** GM输入， 存在Scalar输入 */
+template <class T, class Attr = InAttr<>>
+struct In0 : public Holder<T, Attr, 0> {};
+template <class T, class Attr = InAttr<>>
+struct In1 : public Holder<T, Attr, 1> {};
+template <class T, class Attr = InAttr<>>
+struct In2 : public Holder<T, Attr, 2> {};
+template <class T, class Attr = InAttr<>>
+struct In3 : public Holder<T, Attr, 3> {};
+template <class T, class Attr = InAttr<>>
+struct In4 : public Holder<T, Attr, 4> {};
+template <class T, class Attr = InAttr<>>
+struct In5 : public Holder<T, Attr, 5> {};
+template <class T, class Attr = InAttr<>>
+struct In6 : public Holder<T, Attr, 6> {};
+template <class T, class Attr = InAttr<>>
+struct In7 : public Holder<T, Attr, 7> {};
+template <class T, class Attr = InAttr<>>
+struct In8 : public Holder<T, Attr, 8> {};
+template <class T, class Attr = InAttr<>>
+struct In9 : public Holder<T, Attr, 9> {};
+template <class T, class Attr = InAttr<>>
+struct In10 : public Holder<T, Attr, 10> {};
+template <class T, class Attr = InAttr<>>
+struct In11 : public Holder<T, Attr, 11> {};
+
+template <class T>
+struct IsInHolder {
+  constexpr static bool Value = false;
+};
+template <class U, class Attr, template <class, class> class T>
+struct IsInHolder<T<U, Attr>> {
+  constexpr static bool Value = false;
+};
+template <class U, class Attr>
+struct IsInHolder<In0<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In1<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In2<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In3<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In4<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In5<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In6<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In7<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In8<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In9<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In10<U, Attr>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr>
+struct IsInHolder<In11<U, Attr>> {
+  constexpr static bool Value = true;
+};
+
+/** 判断输入是否是Scalar输入 */
+template <class T>
+struct IsInScalar {
+  constexpr static bool Value = false;
+};
+template <class U, class Attr, template <class, class> class T>
+struct IsInScalar<T<U, Attr>> {
+  constexpr static bool Value = Attr::IsScalar == 1;
+};
+
+/** GM输出，不存在Scalar输出 */
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out0 : public Holder<T, Attr, 0> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out1 : public Holder<T, Attr, 1> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out2 : public Holder<T, Attr, 2> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out3 : public Holder<T, Attr, 3> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out4 : public Holder<T, Attr, 4> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out5 : public Holder<T, Attr, 5> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out6 : public Holder<T, Attr, 6> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out7 : public Holder<T, Attr, 7> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out8 : public Holder<T, Attr, 8> {
+  using Parent = Parent_;
+};
+template <typename T, class Attr = void, class Parent_ = void>
+struct Out9 : public Holder<T, Attr, 9> {
+  using Parent = Parent_;
+};
+
+template <class T>
+struct IsOutHolder {
+  constexpr static bool Value = false;
+};
+template <class U, class Attr, class P, template <class, class, class> class T>
+struct IsOutHolder<T<U, Attr, P>> {
+  constexpr static bool Value = false;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out0<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out1<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out2<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out3<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out4<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out5<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out6<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out7<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out8<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+template <class U, class Attr, class P>
+struct IsOutHolder<Out9<U, Attr, P>> {
+  constexpr static bool Value = true;
+};
+
+template <class T, int cur, class Attr = void>
+struct Var : public Holder<T, Attr, cur> {
+  constexpr static bool IsVarValue = true;
+};
+
+#define CHECK_TYPE(NAME, V)                                                 \
+  template <typename T>                                                     \
+  struct NAME {                                                             \
+    template <typename>                                                     \
+    static uint8_t has(...);                                                \
+    template <typename C>                                                   \
+    static uint32_t has(decltype(C::V));                                    \
+    constexpr static bool Value = sizeof(has<T>(NULL)) == sizeof(uint32_t); \
+  }
+
+CHECK_TYPE(IsVar, IsVarValue);
+CHECK_TYPE(IsConstValue, IsConstValue_);
+
+/** 值设置：定义值存储结构 */
+template <class... Ts>
+struct VarTypeStruct {};
+template <>
+struct VarTypeStruct<> {};
+template <class T>
+struct VarTypeStruct<T> {
+  using DataType = typename T::DType;
+  DataType value;
+  template <int offset = 0>
+  __aicore__ inline constexpr DataType Get() {
+    return value;
+  }
+  template <int offset = 0>
+  __aicore__ inline constexpr void Set(DataType v) {
+    value = v;
+  }
+};
+
+template <class T, class... Ts>
+struct VarTypeStruct<T, Ts...> : public VarTypeStruct<Ts...> {
+  using DataType = typename T::DType;
+  DataType value;
+  template <int offset = 0>
+  __aicore__ inline constexpr DataType Get() {
+    if constexpr (offset == 0) {
+      return value;
+    } else {
+      return VarTypeStruct<Ts...>::template Get<offset - 1>();
+    }
+  }
+  template <int offset = 0>
+  __aicore__ inline constexpr void Set(DataType v) {
+    if constexpr (offset == 0) {
+      value = v;
+    } else {
+      VarTypeStruct<Ts...>::template Set<offset - 1>(v);
+    }
+  }
+};
+
+template <class... Ts>
+struct VarTypeAux {
+  using Type = VarTypeStruct<Ts...>;
+};
+
+
+}  // namespace Placeholder
+
+#pragma region 
+template<auto v>
+struct Int {
+    constexpr static int value = v;
+};
+#pragma endregion 
+
+
+
+#endif  // _ATVOS_PLACEHOLDER_H_
diff --git a/best_practices/atvos/device/device_vector.h b/best_practices/atvos/device/device_vector.h
new file mode 100644
index 000000000..e312fe073
--- /dev/null
+++ b/best_practices/atvos/device/device_vector.h
@@ -0,0 +1,58 @@
+#ifndef _DEVICE_VECTOR_H_
+#define _DEVICE_VECTOR_H_
+
+#include "../dfx/check.h"
+
+
+namespace ATVOS {
+
+
+using Stream = int*;
+
+/**
+ * @brief 
+ * 
+ * @tparam OpTraits_    需要的Layout 信息
+ * @tparam KernelOp     kernel 的入口
+ * @tparam Policy       策略
+ * @tparam Enable 
+ */
+template<class KernelOp, class OpTraits_=void,  class Policy_=void, class Schedule =void, class Enable=void>
+class DeviceAdapt {
+public: 
+    using OpTraits  = std::conditional_t<std::is_same_v<OpTraits_,void>, typename KernelOp::OpTraits, OpTraits_>;
+    using Arguments = std::conditional_t<std::is_same_v<OpTraits_,void>, typename KernelOp::Arguments, ArgumentsBase<OpTraits_>>;
+    using Policy    = std::conditional_t<std::is_same_v<Policy_, void>, typename KernelOp::Policy, Policy_>;
+public:   
+    static_assert( Dfx::IsTupleV<OpTraits>, "OpTraits_ is std::tuple");
+public:    
+    DeviceAdapt(){};
+
+    bool CanImplement(Arguments& arg); //检查参数的合法性
+    int64_t GetWorkspaceSize(Arguments& arg); 
+    int64_t Run(Arguments& args, Policy* policy=nullptr, Stream stream = nullptr);
+
+}; 
+
+#include "device_vector_impl.h"
+
+
+
+
+} // ATVOS
+
+
+     
+#endif //_DEVICE_VECTOR_H_
+ 
+
+
+
+
+
+
+
+
+
+
+ 
\ No newline at end of file
diff --git a/best_practices/atvos/device/device_vector_impl.h b/best_practices/atvos/device/device_vector_impl.h
new file mode 100644
index 000000000..3b52be84e
--- /dev/null
+++ b/best_practices/atvos/device/device_vector_impl.h
@@ -0,0 +1,31 @@
+#ifndef __ATVOS_DEVECOR_VECTOR_IMPPL_H_
+#define __ATVOS_DEVECOR_VECTOR_IMPPL_H_
+
+
+
+template<class KernelOp, class OpTraits_,  class Policy_, class Schedule, class Enable>
+bool DeviceAdapt<KernelOp, OpTraits_,  Policy_, Schedule, Enable>::CanImplement(Arguments& arg){
+    //检查KernelOp 的In,out 是否进行了 gm 地址的赋值
+    return 0;
+};
+template<class KernelOp, class OpTraits_, class Policy_, class Schedule, class Enable>
+int64_t DeviceAdapt< KernelOp, OpTraits_, Policy_, Schedule, Enable>::GetWorkspaceSize(Arguments& arg)
+{
+    return 0;
+}; 
+
+template<class KernelOp, class OpTraits_, class Policy_, class Schedule, class Enable>
+int64_t DeviceAdapt<KernelOp, OpTraits_,  Policy_, Schedule, Enable>::Run(Arguments&  arg, Policy* policy, Stream stream){
+    //构建Kernel 对象，然后调用 
+    KernelOp op;
+     
+    op.Run(arg, nullptr);
+    return 0;
+};
+
+
+
+
+
+#endif //__ATVOS_DEVECOR_VECTOR_IMPPL_H_
+
diff --git a/best_practices/atvos/dfx/check.h b/best_practices/atvos/dfx/check.h
new file mode 100644
index 000000000..604ac7db4
--- /dev/null
+++ b/best_practices/atvos/dfx/check.h
@@ -0,0 +1,25 @@
+#ifndef  _ATVOS_DFX_CHECK_H_
+#define _ATVOS_DFX_CHECK_H_
+
+namespace ATVOS {
+namespace Dfx {
+
+template<class T>
+struct IsTuple { constexpr static bool Value = false; };
+
+template<class... T>
+struct IsTuple< std::tuple<T...> > { constexpr static bool Value = true; };
+
+template<class T>
+constexpr bool IsTupleV = IsTuple<T>::Value;
+
+template<class T>
+constexpr bool IsVoid = std::is_same_v<T, void>;
+
+
+} //namespace Dfx
+} //namespace ATVOS
+
+
+ 
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos/dfx/kernel_mirror.h b/best_practices/atvos/dfx/kernel_mirror.h
new file mode 100644
index 000000000..214dc0b42
--- /dev/null
+++ b/best_practices/atvos/dfx/kernel_mirror.h
@@ -0,0 +1,32 @@
+#ifndef _ATVOS_DFX_KERNEL_MIRROR_H_
+#define _ATVOS_DFX_KERNEL_MIRROR_H_
+
+
+
+#ifdef __CCE_AICORE__
+#include "kernel_operator.h"
+using namespace AscendC;
+#else
+// CPU编译过程中需要Mock掉Kernel侧的实现
+#define __aicore__
+#define __global__
+#define __gm__
+struct half {
+  uint16_t value;
+};
+struct bfloat16_t {
+  uint16_t value;
+};
+template <class T>
+struct LocalTensor {};
+
+template <class T>
+struct GlobalTensor {
+  void SetGlobalBuffer(T* y) {}
+};
+#endif
+
+
+ 
+    
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos/kernel/kernel_elemwise.h b/best_practices/atvos/kernel/kernel_elemwise.h
new file mode 100644
index 000000000..870b17241
--- /dev/null
+++ b/best_practices/atvos/kernel/kernel_elemwise.h
@@ -0,0 +1,35 @@
+#ifndef __KERNEL_ELEMWISE_H_  
+#define __KERNEL_ELEMWISE_H_
+
+namespace ATVOS {
+
+template<class BlockOp, class OpTraits_=void, class Policy_=void,  class Schedule=void, class Enable=void >
+class KernelElemwise
+{
+public: 
+    static_assert( !(Dfx::IsVoid<OpTraits_> && Dfx::IsVoid<typename BlockOp::OpTraits>), "OpTraits_ is not void");
+        
+public:
+    using OpTraits = std::conditional_t<std::is_same_v<OpTraits_, void>, typename BlockOp::OpTraits, OpTraits_>;
+    using Arguments= std::conditional_t<std::is_same_v<OpTraits_,void>, typename BlockOp::Arguments, ArgumentsBase<OpTraits>>;
+    using Policy   = std::conditional_t<std::is_same_v<Policy_, void>, typename BlockOp::Policy, Policy_>;
+public:
+    static_assert( Dfx::IsTupleV<OpTraits>, "OpTraits_ is std::tuple");
+public:    
+    KernelElemwise(){};
+
+    bool CanImplement(Arguments& arg); //检查参数的合法性
+    int64_t GetWorkspaceSize(Arguments& arg); 
+    int64_t Run(Arguments& args, Policy* policy);
+
+protected:    
+    Policy policy;
+};  
+
+
+#include "kernel_elemwise_impl.h"  
+
+} // ATVOS
+
+
+#endif //__KERNEL_ELEMWISE_H_
\ No newline at end of file
diff --git a/best_practices/atvos/kernel/kernel_elemwise_impl.h b/best_practices/atvos/kernel/kernel_elemwise_impl.h
new file mode 100644
index 000000000..7bf3e0ca5
--- /dev/null
+++ b/best_practices/atvos/kernel/kernel_elemwise_impl.h
@@ -0,0 +1,24 @@
+#ifndef  _ATVOS_KERNLE_ELELMWISE_H_
+#define  _ATVOS_KERNLE_ELELMWISE_H_
+
+template<class BlockOp, class OpTraits_,  class Policy_, class Schedule,  class Enable>
+bool KernelElemwise<BlockOp, OpTraits_, Policy_, Schedule, Enable>::CanImplement(Arguments& arg){
+    //检查KernelOp 的In,out 是否进行了 gm 地址的赋值
+    return true;
+};
+template<class BlockOp, class OpTraits_, class Policy_, class Schedule,  class Enable>
+int64_t KernelElemwise<BlockOp, OpTraits_, Policy_, Schedule, Enable>::GetWorkspaceSize(Arguments& arg)
+{
+    return 0;
+}; 
+
+template<class BlockOp, class OpTraits_, class Policy_, class Schedule,  class Enable>
+int64_t KernelElemwise<BlockOp, OpTraits_, Policy_, Schedule, Enable>::Run(Arguments& args, Policy* policy){
+
+    BlockOp op;
+    op.Run(args, policy);
+    return 0;
+};
+
+
+#endif
diff --git a/best_practices/atvos/tile/tile_alu.h b/best_practices/atvos/tile/tile_alu.h
new file mode 100644
index 000000000..9fae50a6c
--- /dev/null
+++ b/best_practices/atvos/tile/tile_alu.h
@@ -0,0 +1,730 @@
+/**
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*!
+ * \file vec.h
+ * \brief
+ */
+
+#ifndef _ATVOS_VECTOR_ALU_H_
+#define _ATVOS_VECTOR_ALU_H_
+
+namespace ATVOS {
+namespace Tile {
+
+#pragma region "TileOpBase"
+
+template <int outSize, int inSize, int tempSize = 0, int fixedBuf = 0, bool isAdvanced=false, class... DataType_>
+struct FunBase {
+  constexpr static int OutputSize = outSize;
+  constexpr static int InputSize = inSize;
+  constexpr static int TempSize = tempSize;
+  constexpr static int FixedSize = fixedBuf;
+  constexpr static bool IsAdvanced = isAdvanced;
+
+  // 数据类型列表
+  using DataTypes = typename std::tuple<DataType_...>;
+
+  // 输入的数据类型列表
+  template <int offset>
+  using FunRetArgType = typename std::tuple_element<offset, DataTypes>::type;
+
+  // 输出的数据类型列表
+  template <int offset>
+  using FunInArgType =  typename std::tuple_element<offset + outSize, DataTypes>::type;
+};
+
+// 单输入
+template <class R, class In1,
+          int tempBufSize = 0, int fixedBuf = 0, bool isAdvanced = false>
+struct ElemwiseUnaryOP : public FunBase<1, 1, tempBufSize, fixedBuf, isAdvanced, R, In1> {};
+
+// 双输入
+template <class R, class In1, class In2,
+          int tempBufSize = 0, int fixedBuf = 0, bool isAdvanced = false>
+struct ElemwiseBinaryOP : public FunBase<1, 2, tempBufSize, fixedBuf, isAdvanced, R, In1, In2> {};
+
+// 三输入
+template <class R, class In1, class In2, class In3,
+          int tempBufSize = 0, int fixedBuf = 0, bool isAdvanced = false>
+struct ElemwiseTernaryOP : public FunBase<1, 3, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3> {};
+
+// 四输入
+template <class R, class In1, class In2, class In3, class In4,
+          int tempBufSize = 0, int fixedBuf = 0, bool isAdvanced = false>
+struct ElemwiseQuaternaryOP : public FunBase<1, 4, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4> {};
+
+// 五输入
+template <class R, class In1, class In2, class In3, class In4, class In5,
+          int tempBufSize = 0, int fixedBuf = 0, bool isAdvanced = false>
+struct ElemwiseQuinaryOP : public FunBase<1, 5, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5> {};
+
+// 六输入
+template <class R, class In1, class In2, class In3, class In4, class In5, class In6,
+          int tempBufSize = 0, int fixedBuf = 0, bool isAdvanced = false>
+struct Elemwise6OP : public FunBase<1, 6, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5, In6> {};
+
+// 7 输入
+template <class R, class In1, class In2, class In3, class In4, class In5, class In6, class In7,
+          int32_t tempBufSize = 0, int32_t fixedBuf = 0, bool isAdvanced = false>
+struct Elemwise7OP : public FunBase<1, 7, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5, In6, In7> {};
+
+// 8 输入
+template <class R, class In1, class In2, class In3, class In4, class In5, class In6, class In7, class In8,
+          int32_t tempBufSize = 0, int32_t fixedBuf = 0, bool isAdvanced = false>
+struct Elemwise8OP : public FunBase<1, 8, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5, In6, In7, In8> {};
+
+// 9 输入
+template <class R, class In1, class In2, class In3, class In4, class In5, class In6, class In7, class In8, class In9,
+          int32_t tempBufSize = 0, int32_t fixedBuf = 0, bool isAdvanced = false>
+struct Elemwise9OP : public FunBase<1, 9, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5, In6, In7, In8, In9> {};
+
+// 10 
+template <class R, class In1, class In2, class In3, class In4, class In5, class In6, class In7, class In8, class In9, class In10,
+          int32_t tempBufSize = 0, int32_t fixedBuf = 0, bool isAdvanced = false>
+struct Elemwise10OP : public FunBase<1, 10, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5, In6, In7, In8, In9, In10> {};
+
+// 11
+template <class R, class In1, class In2, class In3, class In4, class In5, class In6, class In7, class In8, class In9, class In10,
+          class In11, int32_t tempBufSize = 0, int32_t fixedBuf = 0, bool isAdvanced = false>
+struct Elemwise11OP : public FunBase<1, 11, tempBufSize, fixedBuf, isAdvanced, R, In1, In2, In3, In4, In5, In6, In7, In8, In9, In10, In11> {};
+
+
+#pragma region "单输入"
+
+template <class T>
+struct Duplicate : public ElemwiseUnaryOP<T, T> {
+__aicore__ inline Duplicate(const LocalTensor<T>& dstLocal, const T& scalar, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Duplicate(dstLocal, scalar, count);
+#endif
+  }
+};
+
+template <class T>
+struct Reciprocal : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Reciprocal(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Reciprocal(dstLocal, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Log : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Log(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Log(dst, src, count);
+#endif
+  }
+};
+template <class T>
+struct Copy : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Copy(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Copy(dst, src, count);
+#endif
+  }
+};
+template <class T>
+struct Abs : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Abs(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Abs(dst, src, count);
+#endif
+  }
+};
+template <class R, class T, int roundMode>
+struct Cast : public ElemwiseUnaryOP<R, T> {
+  __aicore__ inline Cast(LocalTensor<R>& dst, LocalTensor<T>& src, const uint32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Cast(dst, src, static_cast<AscendC::RoundMode>(roundMode), count);
+#endif
+  }
+};
+
+
+template <class T>
+struct Exp : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Exp(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Exp(dst, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Sin : public ElemwiseUnaryOP<T, T, 0, 0, true> {
+  __aicore__ inline Sin(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    static constexpr SinConfig config = { SinAlgo::RADIAN_REDUCTION };
+    AscendC::Sin<T, false, config>(dst, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Cos : public ElemwiseUnaryOP<T, T, 0, 0, true> {
+  __aicore__ inline Cos(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    static constexpr CosConfig config = { CosAlgo::RADIAN_REDUCTION };
+    AscendC::Cos<T, false, config>(dst, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Sqrt : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Sqrt(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Sqrt(dst, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct ReduceOp : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline ReduceOp(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    (void)dst;
+    (void)src;
+    (void)count;
+#endif
+  }
+};
+
+template <class T, int roundMode>
+struct Truncate : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Truncate(LocalTensor<T>& dst, LocalTensor<T>& src, const uint32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Truncate<T, static_cast<AscendC::RoundMode>(roundMode)>(dst, src, count);
+#endif
+  }
+};
+
+template <class T, int group = 0, int constRank=-1>
+struct Brc : public ElemwiseUnaryOP<T, T>{
+  __aicore__ inline Brc(LocalTensor<T>& dst, LocalTensor<T>& src, int count)
+  // __aicore__ inline Brc(LocalTensor<T>& dst, LocalTensor<T>& src, const uint32_t* dstShape, const uint32_t* srcShape, BroadcastTiling* tiling)
+  {
+#ifdef __CCE_AICORE__
+    // AscendC::Broadcast<T, constRank>(dst, src, dstShape, srcShape, tiling);
+#endif
+  }
+};
+
+template <class T>
+struct Not : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline Not(LocalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Not(dst, src, count);
+#endif
+  }
+};
+#pragma endregion "单输入"
+
+#pragma region "Copy"
+
+template <class T>
+struct CopyIn : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline CopyIn(const LocalTensor<T>& dst, const GlobalTensor<T>& src, uint32_t count) {
+#ifdef __CCE_AICORE__
+    DataCopyExtParams copyParams{1, static_cast<uint32_t>(count * sizeof(T)), 0, 0, 0};
+    AscendC::DataCopyPadExtParams<T> padParams{false, 0, 0, 0};
+    AscendC::DataCopyPad(dst, src, copyParams, padParams);
+#endif
+  }
+};
+
+static constexpr uint8_t NDDMA_DIM = 5;
+template <class T, int group = 0>
+struct CopyInBrc : public ElemwiseUnaryOP<T, T, 1>{
+#ifdef __DAV_C310__
+  __aicore__ inline CopyInBrc(const LocalTensor<T>& dst, const GlobalTensor<T>& src,
+                              const MultiCopyParams<T, NDDMA_DIM>& params,
+                              const MultiCopyConfig& config = kDefaultMultiCopyConfig)
+  {
+    AscendC::DataCopy<T, NDDMA_DIM, config>(dst, src, params);
+  }
+#endif
+  __aicore__ inline CopyInBrc(const LocalTensor<T>& dst, const GlobalTensor<T>& src, uint32_t count)
+  {
+#ifdef __CCE_AICORE__
+    AscendC::DataCopyExtParams copyParams{1, static_cast<uint32_t>(count * sizeof(T)), 0, 0, 0};
+    AscendC::DataCopyPadExtParams<T> padParams{false, 0, 0, 0};
+    AscendC::DataCopyPad(dst, src, copyParams, padParams);
+#endif
+  }
+};
+template <class T>
+struct CopyOut : public ElemwiseUnaryOP<T, T> {
+  __aicore__ inline CopyOut(GlobalTensor<T>& dst, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    DataCopyExtParams copyParams{1, static_cast<uint32_t>(count * sizeof(T)), 0, 0, 0};
+    AscendC::DataCopyPad(dst, src, copyParams);
+#endif
+  }
+};
+#pragma endreigon "Copy"
+
+#pragma region "双输入"
+
+template <class T>
+struct Add : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Add(const LocalTensor<T>& dst, const LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Add(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Fmod : public ElemwiseBinaryOP<T, T, T, 0, 0, true> {
+  __aicore__ inline Fmod(const LocalTensor<T>& dst, const LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Fmod(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Adds : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Adds(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Adds(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Adds(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Adds(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Adds(T& dst, T& scalar0, T& scalar1, int count) {
+    dst = scalar0 + scalar1;;
+  }
+};
+
+template <class T>
+struct Relu : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Relu(const LocalTensor<T>& dst, const LocalTensor<T>& src, int32_t count) {
+#ifdef __CCE_AICORE__
+    AscendC::Relu(dst, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Max : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Max(const LocalTensor<T>& dst, const LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Max(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Maxs : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Maxs(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Maxs(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Maxs(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Duplicate(dst, scalar, count);
+    AscendC::Max(dst, dst, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Min : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Min(const LocalTensor<T>& dst, const LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Min(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Mins : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Mins(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Mins(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Mins(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Mins(dst, src, scalar, count);
+#endif
+  }
+};
+
+template <class T>
+struct Sub : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Sub(LocalTensor<T>& dst, LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Sub(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Mul : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Mul(LocalTensor<T>& dst, LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Mul(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Muls : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Muls(const LocalTensor<T>& dst, const T& scalar, const LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Muls(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Muls(const LocalTensor<T>& dst, const LocalTensor<T>& src, const T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Muls(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Muls(T& dst, T& scalar0, T& scalar1, int count) {
+    dst = scalar0 * scalar1;;
+  }
+};
+
+template <class T>
+struct Div : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Div(LocalTensor<T>& dst, LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Div(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct DivHighPrecision : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline DivHighPrecision(LocalTensor<T>& dst, LocalTensor<T>& src1, LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    static constexpr DivConfig config = {DivAlgo::DIFF_COMPENSATION};
+    AscendC::Div<T, config>(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Divs : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Divs(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Duplicate(dst, scalar, count);
+    AscendC::Div(dst, src, dst, count);
+#endif
+  }
+  __aicore__ inline Divs(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Duplicate(dst, scalar, count);
+    AscendC::Div(dst, dst, src, count);
+#endif
+  }
+  __aicore__ inline Divs(T& dst, T& scalar0, T& scalar1, int count) {
+    dst = scalar0 / scalar1;;
+  }
+};
+
+template <class T>
+struct Subs : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Subs(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Duplicate(dst, scalar, count);
+    AscendC::Sub(dst, src, dst, count);
+#endif
+  }
+  __aicore__ inline Subs(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Duplicate(dst, scalar, count);
+    AscendC::Sub(dst, dst, src, count);
+#endif
+  }
+  __aicore__ inline Subs(T& dst, T& scalar0, T& scalar1, int count) {
+    dst = scalar0 - scalar1;;
+  }
+};
+
+template <class T>
+struct LeakyRelu : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline LeakyRelu(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalarValue, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::LeakyRelu(dst, src, scalarValue, count);
+#endif
+  }
+};
+
+template <class R, class T, int cmpMode>
+struct Compare : public ElemwiseBinaryOP<R, T, T> {
+  __aicore__ inline Compare(LocalTensor<R>& dstLocal, LocalTensor<T>& src0Local, LocalTensor<T>& src1Local,
+                            uint32_t count) {
+#ifdef __CCE_AICORE__
+    AscendC::Compare(dstLocal, src0Local, src1Local, static_cast<AscendC::CMPMODE>(cmpMode), count);
+#endif
+  }
+
+  __aicore__ inline Compare(LocalTensor<R>& dstLocal, LocalTensor<T>& src0Local, T src1Scalar, uint32_t count) {
+#ifdef __CCE_AICORE__
+    AscendC::CompareScalar(dstLocal, src0Local, src1Scalar, static_cast<AscendC::CMPMODE>(cmpMode), count);
+#endif
+  }
+};
+
+template <class T>
+struct And : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline And(LocalTensor<T>& dst, LocalTensor<T>& src1, LocalTensor<T>& src2, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::And(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Ands : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Ands(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Ands(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Ands(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Ands(dst, scalar, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Or : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Or(LocalTensor<T>& dst, LocalTensor<T>& src1, LocalTensor<T>& src2, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Or(dst, src1, src2, count);
+#endif
+  }
+};
+
+template <class T>
+struct Ors : public ElemwiseBinaryOP<T, T, T> {
+  __aicore__ inline Ors(LocalTensor<T>& dst, LocalTensor<T>& src, T& scalar, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Ors(dst, src, scalar, count);
+#endif
+  }
+  __aicore__ inline Ors(LocalTensor<T>& dst, T& scalar, LocalTensor<T>& src, const int32_t& count) {
+#ifdef __CCE_AICORE__
+    AscendC::Ors(dst, scalar, src, count);
+#endif
+  }
+};
+
+template <class T>
+struct Power : public ElemwiseBinaryOP<T, T, T> {
+    __aicore__ inline Power(LocalTensor<T>& dstLocal, LocalTensor<T>& src0Local, LocalTensor<T>& src1Local,
+                            uint32_t count) {
+#ifdef __CCE_AICORE__
+    static constexpr PowerConfig config = {PowerAlgo::DOUBLE_FLOAT_TECH};
+    AscendC::Power<T, false, config>(dstLocal, src0Local, src1Local, count);
+#endif
+  }
+
+  __aicore__ inline Power(LocalTensor<T>& dstLocal, LocalTensor<T>& src0Local, T& src1Scalar, uint32_t count) {
+#ifdef __CCE_AICORE__
+    static constexpr PowerConfig config = {PowerAlgo::DOUBLE_FLOAT_TECH};
+    AscendC::Power<T, false, config>(dstLocal, src0Local, src1Scalar, count);
+#endif
+  }
+
+  __aicore__ inline Power(LocalTensor<T>& dstLocal, T& src0Scalar, LocalTensor<T>& src1Local, uint32_t count) {
+#ifdef __CCE_AICORE__
+    static constexpr PowerConfig config = {PowerAlgo::DOUBLE_FLOAT_TECH};
+    AscendC::Power<T, false, config>(dstLocal, src0Scalar, src1Local, count);
+#endif
+  }
+};
+#pragma endregion "双输入"
+
+#pragma region "三输入"
+
+template <class U, class T, int selMode>
+struct Select : public ElemwiseTernaryOP<T, U, T, T> {
+  __aicore__ inline Select(const LocalTensor<T>& dstLocal, const LocalTensor<U>& selMask,
+                           const LocalTensor<T>& src0Local, const LocalTensor<T>& src1Local, uint32_t count) {
+#ifdef __CCE_AICORE__
+    AscendC::Select(dstLocal, selMask, src0Local, src1Local, static_cast<AscendC::SELMODE>(selMode), count);
+#endif
+  }
+
+  __aicore__ inline Select(const LocalTensor<T>& dstLocal, const LocalTensor<U>& selMask,
+                           const LocalTensor<T>& src0Local, T src1Scalar, uint32_t count) {
+#ifdef __CCE_AICORE__
+    AscendC::Select(dstLocal, selMask, src0Local, src1Scalar,
+                    AscendC::SELMODE::VSEL_TENSOR_SCALAR_MODE, count);
+#endif
+  }
+
+   __aicore__ inline Select(const LocalTensor<T>& dstLocal, const LocalTensor<U>& selMask,
+                            T src0Scalar, const LocalTensor<T>& src1Local, uint32_t count) {
+#ifdef __CCE_AICORE__
+    AscendC::Select(dstLocal, selMask, src0Scalar, src1Local,
+                    AscendC::SELMODE::VSEL_TENSOR_SCALAR_MODE, count);
+#endif
+  }
+};
+
+/**
+ * dst = src1 + src2 * alpha
+ */
+template <class T>
+struct FusedMulAdd : public ElemwiseTernaryOP<T, T, T, T> {
+  __aicore__ inline FusedMulAdd(const LocalTensor<T>& dst, const LocalTensor<T>& src1, const LocalTensor<T>& src2,
+                                const LocalTensor<T>& alpha, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::FusedMulAdd(src2, alpha, src1, count);
+    AscendC::Copy(dst, src2, count);
+#endif
+  }
+};
+
+/**
+ * dst = src1 + src2 * scalar
+ */
+template <class T>
+struct Axpy : public ElemwiseTernaryOP<T, T, T, T> {
+  __aicore__ inline Axpy(const LocalTensor<T>& dst, const T& scalar, const LocalTensor<T>& src1, 
+                         const LocalTensor<T>& src2, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Axpy(src1, src2, scalar, count);
+    AscendC::Copy(dst, src1, count);
+#endif
+  }
+  __aicore__ inline Axpy(const LocalTensor<T>& dst, const LocalTensor<T>& src1, const LocalTensor<T>& src2,
+                         const T& scalar, int count) {
+#ifdef __CCE_AICORE__
+    AscendC::Axpy(src1, src2, scalar, count);
+    AscendC::Copy(dst, src1, count);
+#endif
+  }
+};
+#pragma endregion "三输入"
+
+
+} //namespace Tile
+} //namespace ATVOS
+
+
+
+#if 0
+
+template <class T>
+struct IsCastOp {
+  constexpr static bool Value = false;
+};
+
+template <class U, class T, int mode>
+struct IsCastOp<Cast<U, T, mode>> {
+  constexpr static bool Value = true;
+};
+
+template <class T>
+struct IsCastNoOp {
+  constexpr static bool Value = false;
+};
+
+template <class U, class T, int mode>
+struct IsCastNoOp<Cast<U, T, mode>> {
+  constexpr static bool Value = std::is_same<U, T>::value;
+};
+
+template <class T>
+struct IsCopyInBrcOp {
+  constexpr static bool Value = false;
+};
+
+template <class T, int group>
+struct IsCopyInBrcOp<CopyInBrc<T, group>> {
+  constexpr static bool Value = true;
+};
+
+template <class... T>
+struct IsCopyInOp {
+  constexpr static bool Value = false;
+};
+
+template <class T>
+struct IsCopyInOp<CopyIn<T>> {
+  constexpr static bool Value = true;
+};
+
+template <class T, int group>
+struct IsCopyInOp<CopyInBrc<T, group>> {
+  constexpr static bool Value = true;
+};
+
+template <class T>
+struct IsVecBrcOp {
+  constexpr static bool Value = false;
+};
+
+template <class T, int group, int constRank>
+struct IsVecBrcOp<Brc<T, group, constRank>> {
+  constexpr static bool Value = true;
+};
+
+template <class... T>
+struct IsCopyOutOp {
+  constexpr static bool Value = false;
+};
+
+template <class T>
+struct IsCopyOutOp<CopyOut<T>> {
+  constexpr static bool Value = true;
+};
+
+template <class T>
+struct IsCopyOutOp<ReduceOp<T>> {
+  constexpr static bool Value = true;
+};
+
+template <class... T>
+struct IsReduceOp {
+  constexpr static bool Value = false;
+};
+
+template <class T>
+struct IsReduceOp<ReduceOp<T>> {
+  constexpr static bool Value = true;
+};
+
+template <class... T>
+struct IsDuplicateOp {
+  constexpr static bool Value = false;
+};
+
+template <class T>
+struct IsDuplicateOp<Duplicate<T>> {
+  constexpr static bool Value = true;
+};
+
+#endif 
+
+
+#endif //_ATVOS_VECTOR_ALU_H_
\ No newline at end of file
-- 
Gitee


From ff608d8af484fc3ec044ab3dffb4524cadefeb48 Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Tue, 9 Sep 2025 16:47:42 +0800
Subject: [PATCH 002/116] fix compile err

---
 best_practices/atvos/{ => include}/atvos.h    |   0
 .../{ => include}/block/block_elemwise.h      |   0
 .../{ => include}/block/block_elemwise_impl.h |   0
 .../atvos/{ => include}/common/dagsch.h       |   0
 .../atvos/{ => include}/common/expression.h   |   0
 .../{ => include}/common/impl/atvos_impl.h    |   0
 .../atvos/{ => include}/common/layout.h       |   0
 .../atvos/{ => include}/common/placeholder.h  |   0
 .../{ => include}/device/device_vector.h      |   0
 .../{ => include}/device/device_vector_impl.h |   0
 .../atvos/{ => include}/dfx/check.h           |   0
 .../atvos/{ => include}/dfx/kernel_mirror.h   |   0
 .../{ => include}/kernel/kernel_elemwise.h    |   0
 .../kernel/kernel_elemwise_impl.h             |   0
 .../atvos/{ => include}/tile/tile_alu.h       |   0
 best_practices/atvos/main/main.cpp            | 112 ++++++++++++++++++
 16 files changed, 112 insertions(+)
 rename best_practices/atvos/{ => include}/atvos.h (100%)
 rename best_practices/atvos/{ => include}/block/block_elemwise.h (100%)
 rename best_practices/atvos/{ => include}/block/block_elemwise_impl.h (100%)
 rename best_practices/atvos/{ => include}/common/dagsch.h (100%)
 rename best_practices/atvos/{ => include}/common/expression.h (100%)
 rename best_practices/atvos/{ => include}/common/impl/atvos_impl.h (100%)
 rename best_practices/atvos/{ => include}/common/layout.h (100%)
 rename best_practices/atvos/{ => include}/common/placeholder.h (100%)
 rename best_practices/atvos/{ => include}/device/device_vector.h (100%)
 rename best_practices/atvos/{ => include}/device/device_vector_impl.h (100%)
 rename best_practices/atvos/{ => include}/dfx/check.h (100%)
 rename best_practices/atvos/{ => include}/dfx/kernel_mirror.h (100%)
 rename best_practices/atvos/{ => include}/kernel/kernel_elemwise.h (100%)
 rename best_practices/atvos/{ => include}/kernel/kernel_elemwise_impl.h (100%)
 rename best_practices/atvos/{ => include}/tile/tile_alu.h (100%)
 create mode 100644 best_practices/atvos/main/main.cpp

diff --git a/best_practices/atvos/atvos.h b/best_practices/atvos/include/atvos.h
similarity index 100%
rename from best_practices/atvos/atvos.h
rename to best_practices/atvos/include/atvos.h
diff --git a/best_practices/atvos/block/block_elemwise.h b/best_practices/atvos/include/block/block_elemwise.h
similarity index 100%
rename from best_practices/atvos/block/block_elemwise.h
rename to best_practices/atvos/include/block/block_elemwise.h
diff --git a/best_practices/atvos/block/block_elemwise_impl.h b/best_practices/atvos/include/block/block_elemwise_impl.h
similarity index 100%
rename from best_practices/atvos/block/block_elemwise_impl.h
rename to best_practices/atvos/include/block/block_elemwise_impl.h
diff --git a/best_practices/atvos/common/dagsch.h b/best_practices/atvos/include/common/dagsch.h
similarity index 100%
rename from best_practices/atvos/common/dagsch.h
rename to best_practices/atvos/include/common/dagsch.h
diff --git a/best_practices/atvos/common/expression.h b/best_practices/atvos/include/common/expression.h
similarity index 100%
rename from best_practices/atvos/common/expression.h
rename to best_practices/atvos/include/common/expression.h
diff --git a/best_practices/atvos/common/impl/atvos_impl.h b/best_practices/atvos/include/common/impl/atvos_impl.h
similarity index 100%
rename from best_practices/atvos/common/impl/atvos_impl.h
rename to best_practices/atvos/include/common/impl/atvos_impl.h
diff --git a/best_practices/atvos/common/layout.h b/best_practices/atvos/include/common/layout.h
similarity index 100%
rename from best_practices/atvos/common/layout.h
rename to best_practices/atvos/include/common/layout.h
diff --git a/best_practices/atvos/common/placeholder.h b/best_practices/atvos/include/common/placeholder.h
similarity index 100%
rename from best_practices/atvos/common/placeholder.h
rename to best_practices/atvos/include/common/placeholder.h
diff --git a/best_practices/atvos/device/device_vector.h b/best_practices/atvos/include/device/device_vector.h
similarity index 100%
rename from best_practices/atvos/device/device_vector.h
rename to best_practices/atvos/include/device/device_vector.h
diff --git a/best_practices/atvos/device/device_vector_impl.h b/best_practices/atvos/include/device/device_vector_impl.h
similarity index 100%
rename from best_practices/atvos/device/device_vector_impl.h
rename to best_practices/atvos/include/device/device_vector_impl.h
diff --git a/best_practices/atvos/dfx/check.h b/best_practices/atvos/include/dfx/check.h
similarity index 100%
rename from best_practices/atvos/dfx/check.h
rename to best_practices/atvos/include/dfx/check.h
diff --git a/best_practices/atvos/dfx/kernel_mirror.h b/best_practices/atvos/include/dfx/kernel_mirror.h
similarity index 100%
rename from best_practices/atvos/dfx/kernel_mirror.h
rename to best_practices/atvos/include/dfx/kernel_mirror.h
diff --git a/best_practices/atvos/kernel/kernel_elemwise.h b/best_practices/atvos/include/kernel/kernel_elemwise.h
similarity index 100%
rename from best_practices/atvos/kernel/kernel_elemwise.h
rename to best_practices/atvos/include/kernel/kernel_elemwise.h
diff --git a/best_practices/atvos/kernel/kernel_elemwise_impl.h b/best_practices/atvos/include/kernel/kernel_elemwise_impl.h
similarity index 100%
rename from best_practices/atvos/kernel/kernel_elemwise_impl.h
rename to best_practices/atvos/include/kernel/kernel_elemwise_impl.h
diff --git a/best_practices/atvos/tile/tile_alu.h b/best_practices/atvos/include/tile/tile_alu.h
similarity index 100%
rename from best_practices/atvos/tile/tile_alu.h
rename to best_practices/atvos/include/tile/tile_alu.h
diff --git a/best_practices/atvos/main/main.cpp b/best_practices/atvos/main/main.cpp
new file mode 100644
index 000000000..82b565b12
--- /dev/null
+++ b/best_practices/atvos/main/main.cpp
@@ -0,0 +1,112 @@
+#include <iostream>
+
+#include "../include/atvos.h"
+#include "../include/tile/tile_alu.h"
+#include "../include/block/block_elemwise.h" 
+#include "../include/kernel/kernel_elemwise.h"
+#include "../include/device/device_vector.h"
+
+
+
+using namespace ATVOS;
+
+// 1, 描述算子原型
+using Input0 = Input<int, Layout<Shape<int, int>> >;  //描述每个Block的输入，以及处理的Shape 大小
+using Input1 = Input<int, Layout<Shape<int, int>> >;                    //描述每个Block的输入, 自动推导
+using out = Output<int, Layout<Shape<int,int>> >;                   //描述每个Block的输入，自动推导
+
+using OpTraits =  std::tuple<out, Input0, Input1, int>;
+
+// 2, 描述Compute 过程     
+template<class Traits_>
+struct MyComputer { 
+    using T = Traits_;
+    constexpr static auto myAdd = Expr<Tile::Add<int>>( Placeholder::In1<T>{}, Placeholder::In2<T>{});
+    constexpr static auto subs = Expr<Tile::Add<int>>(myAdd, 0.5 );
+    constexpr static auto out =  std::tuple{subs};
+};
+
+#if 0 
+template<class Traits_>
+struct MyComputer { 
+    using T = Traits_;
+    template<auto pattern, class... Args>
+    void Run(LocalTensor<T> out, LocalTensor<T>& in1, LocalTensor<T>& in2,  int a ){
+      auto myAdd = Expr<Tile::Add<int>>( in1, in2);
+      auto subs = Expr<Tile::Add<int>>(myAdd, 0.5 );
+      out = Evaluate(subs);
+    }
+
+    template<class... Args>
+    auto Run(){
+      auto myAdd = Expr<Tile::Add<int>>( in1, in2);
+      auto subs = Expr<Tile::Add<int>>(myAdd, 0.5 );
+      return subs;
+    }
+};
+#endif 
+
+// 3, 选择 Block 模版（进行调度)
+template<class Traits_>
+using MyBlock = BlockElemwise<decltype(MyComputer<Traits_>::out), Traits_>;
+
+// 4, 选择 kerne 类型( 处理整尾核)
+template<class Traits_>
+using MyKernel = KernelElemwise< MyBlock<Traits_>>;
+
+// 5,  Device 侧 host+device 混合编程
+using device =  DeviceAdapt< MyKernel<OpTraits> >;   
+
+int main(int argc, const char* argv[]) {
+    
+
+    device op; 
+
+    void* gmAddr = nullptr;
+    auto tensor = MakeTensor<int>(gmAddr, MakeShape(1024,1024)); //硬件可能的Shape
+
+    device::Arguments  arguments( tensor, tensor, MakeTensor<int>(gmAddr, MakeShape(1024,1024)), 20) ;
+  
+    // 校验参数是否合理(当前device能否支持arguments)
+    auto status = op.CanImplement(arguments);       
+    size_t sizeWorkspace = op.GetWorkspaceSize(arguments);   
+
+    op.Run(arguments); 
+  
+    std::cout << "run" << std::endl;
+
+    return 0;
+     
+}
+ 
+
+#if 0
+
+void kernel() {
+  TPipe pipe; 
+  constexpr TQue<VecIn,   1, {.db=2, .dataLen=1024} > queIn;     //编译时分配资源
+  constexpr TQue<VecOut,  1, {.db=2, .dataLen=1024} > queOut;    //编译时分配资源
+  constexpr TQue<VecCalc, 1, {.db=2, .dataLen=1024} > queCalc;    //编译时分配资源
+
+  //vector 操作
+  LocalTensor<half> tensor; 
+  LocalTensor<half> tensorOut, tensorOut2; 
+  DataCopy(tensor, gmTesnor, 1024);
+  queIn.Enque(tensor);
+  queIn.Deque(tensor);
+
+  Add(tensorOut, tensor, tensor, 1024)
+
+  //Cube 操作
+  TQue<VecOut, A1>::EnQue(tensorOut);  
+  TQue<VecOut, A1>::DeQue(tensorOut);  
+  Conv(tensorOut2, tensorOut, ...);  
+  TQue<CO1, VecOut>::EnQue(tensorOut2); 
+  TQue<CO1, VecOut>::DeQue(tensorOut2); 
+   
+  DataCopy(gm2, tensorOut2, 1024)
+
+  pipe.staticInitBuffer(queIn); 
+  pipe.staticInitBuffer(queOut);
+}
+#endif 
-- 
Gitee


From 857ca9f2e2129246a987e9bc1e1fed135a535ee6 Mon Sep 17 00:00:00 2001
From: wwx921016 <wwx921016@huawei.com>
Date: Wed, 10 Sep 2025 09:23:42 +0800
Subject: [PATCH 003/116] Add expression template demo

---
 .../expr_template_demo.cpp                    | 801 ++++++++++++++++++
 1 file changed, 801 insertions(+)
 create mode 100644 best_practices/expression_template/expr_template_demo.cpp

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
new file mode 100644
index 000000000..3d6fec071
--- /dev/null
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -0,0 +1,801 @@
+#include <cstddef>
+#include <iostream>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+
+/* Utilities */
+
+namespace Util {
+
+template <typename T>
+struct AlwaysFalse : std::false_type {};
+
+template <typename T>
+inline constexpr bool AlwaysFalse_v = AlwaysFalse<T>::value;
+
+template <template <typename...> class T, typename U>
+struct IsSpecializationOf : std::false_type {};
+
+template <template <typename...> class T, typename... Us>
+struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
+
+template <template <typename...> class T, typename U>
+inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
+
+namespace TMP {
+
+template <typename... Ts>
+struct TypeList {};
+
+template <typename List>
+struct First;
+
+template <typename H, typename... Ts>
+struct First<TypeList<H, Ts...>> {
+    using Type = H;
+};
+
+template <typename List>
+using First_t = typename First<List>::Type;
+
+template <typename List>
+struct Size;
+
+template <typename... Ts>
+struct Size<TypeList<Ts...>> {
+    static constexpr std::size_t value = sizeof...(Ts);
+};
+
+template <typename List>
+inline constexpr std::size_t Size_v = Size<List>::value;
+
+template <typename T, typename List>
+struct Prepend;
+
+template <typename T, typename... Ts>
+struct Prepend<T, TypeList<Ts...>> {
+    using Type = TypeList<T, Ts...>;
+};
+
+template <typename T, typename List>
+using Prepend_t = typename Prepend<T, List>::Type;
+
+template <typename... Lists>
+struct Concatenate;
+
+template <>
+struct Concatenate<> {
+    using Type = TypeList<>;
+};
+
+template <typename... Ts>
+struct Concatenate<TypeList<Ts...>> {
+    using Type = TypeList<Ts...>;
+};
+
+template <typename... Ts, typename... Us>
+struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
+    using Type = TypeList<Ts..., Us...>;
+};
+
+template <typename List1, typename List2, typename List3, typename... Lists>
+struct Concatenate<List1, List2, List3, Lists...> {
+    using Type =
+        typename Concatenate<typename Concatenate<List1, List2>::Type,
+                             List3, Lists...>::Type;
+};
+
+template <typename... Lists>
+using Concatenate_t = typename Concatenate<Lists...>::Type;
+
+template <template <typename> class Pred, typename List, typename = void>
+struct Find;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<Pred<Head>::value>> {
+    using Type = Head;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<!Pred<Head>::value>>
+    : Find<Pred, TypeList<Tail...>> {};
+
+template <template <typename> class Pred>
+struct Find<Pred, TypeList<>, void> {
+    static_assert(AlwaysFalse_v<Pred<void>>,
+                  "Cannot find the specified element");
+};
+
+template <template <typename> class Pred, typename List>
+using Find_t = typename Find<Pred, List>::Type;
+
+template <template <typename> class Pred, typename List>
+struct Filter;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Filter<Pred, TypeList<Head, Tail...>> {
+    using Type = typename std::conditional_t<
+        Pred<Head>::value,
+        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
+        typename Filter<Pred, TypeList<Tail...>>::Type>;
+};
+
+template <template <typename> class Pred>
+struct Filter<Pred, TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <template <typename> class Pred, typename List>
+using Filter_t = typename Filter<Pred, List>::Type;
+
+template <typename List, std::size_t N>
+struct Get;
+
+template <typename T, typename... Ts, std::size_t N>
+struct Get<TypeList<T, Ts...>, N> {
+    using Type = typename Get<TypeList<Ts...>, N - 1>::Type;
+};
+
+template <typename T, typename... Ts>
+struct Get<TypeList<T, Ts...>, 0> {
+    using Type = T;
+};
+
+template <std::size_t N>
+struct Get<TypeList<>, N> {
+    static_assert(N < 0, "Index out of bounds in Get");
+};
+
+template <typename List, std::size_t N>
+using Get_t = typename Get<List, N>::Type;
+
+template <typename List>
+struct Unique;
+
+template <typename Head, typename... Tail>
+struct Unique<TypeList<Head, Tail...>> {
+    template <typename T>
+    struct IsNotHead : std::bool_constant<!std::is_same_v<T, Head>> {};
+
+    using Type = Prepend_t<
+        Head,
+        typename Unique<Filter_t<IsNotHead, TypeList<Tail...>>>::Type>;
+};
+
+template <>
+struct Unique<TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <typename List>
+using Unique_t = typename Unique<List>::Type;
+
+template <template <typename> class Pred, typename List>
+struct FindUnique {
+    using ResultList = Filter_t<Pred, List>;
+    static_assert(Size_v<ResultList> != 0, "Cannot find the specified element");
+    static_assert(Size_v<ResultList> == 1, "A unique result is expected");
+    using Type = First_t<ResultList>;
+};
+
+template <template <typename> class Pred, typename List>
+using FindUnique_t = typename FindUnique<Pred, List>::Type;
+
+} // namespace TMP
+
+} // namespace Util
+
+
+/* Expression templates */
+
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
+// NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTBEGIN(misc-unconventional-assign-operator)
+
+namespace ExprTmpl {
+
+using Util::TMP::TypeList;
+
+template <typename T>
+struct Expression {
+    static_assert(!std::is_rvalue_reference_v<T>,
+                  "Rvalue references cannot be stored");
+    using Type = T;
+    T const data{};  // NOLINT(misc-non-private-member-variables-in-classes)
+
+    explicit Expression(T&& t) : data(std::forward<T>(t)) {}
+    Expression() = default;
+    Expression(const Expression&) = default;
+    ~Expression() = default;
+
+    template <typename U>
+    [[nodiscard]] constexpr auto operator=(Expression<U> u);
+
+    [[nodiscard]] constexpr auto operator=(Expression rhs)
+    {
+        return operator=<T>(rhs);  // Invoke the templated version
+    }
+};
+
+// Let T deduce to value type or lvalue reference type
+template <typename T>
+Expression(T&& value) -> Expression<T>;
+
+template <typename T>
+using IsExpression = Util::IsSpecializationOf<Expression, T>;
+
+template <typename T>
+inline constexpr bool IsExpression_v = IsExpression<T>::value;
+
+template <std::size_t N, typename T, typename L = void>
+struct LocalVar {
+    static_assert(!std::is_reference_v<T>,
+                  "A LocalVar must not be a reference");
+    using Type = T;
+    using Like = L;
+    static constexpr std::size_t number = N;
+
+    template <typename V>
+    constexpr auto operator=(Expression<V>)
+    {
+        static_assert(Util::AlwaysFalse_v<V>,
+                      "Please use Expression<LocalVar> for assignment");
+    }
+};
+
+template <typename T>
+struct IsLocalVar : std::false_type {};
+
+template <std::size_t N, typename T, typename L>
+struct IsLocalVar<LocalVar<N, T, L>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsLocalVar_v = IsLocalVar<T>::value;
+
+enum class ParamUsage {
+    in,
+    out,
+    in_out,
+    //temporary,
+};
+
+template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
+struct Param {
+    using Type = T;
+    static constexpr std::size_t number = N;
+    static constexpr ParamUsage usage = U;
+
+    template <typename V>
+    constexpr auto operator=(Expression<V>)
+    {
+        static_assert(Util::AlwaysFalse_v<V>,
+                      "Please use Expression<Param> for assignment");
+    }
+};
+
+template <typename T>
+struct IsParam : std::false_type {};
+
+template <std::size_t N, typename T, ParamUsage U>
+struct IsParam<Param<N, T, U>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsParam_v = IsParam<T>::value;
+
+template <std::size_t N, typename T>
+constexpr auto DefineLocalVar()
+{
+    return Expression<LocalVar<N, T>>{};
+}
+
+template <std::size_t N, typename T, typename L>
+constexpr auto DefineLocalVar(Expression<L> /*unused*/)
+{
+    static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
+    return Expression<LocalVar<N, T, L>>{};
+}
+
+template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
+constexpr auto DefineParam()
+{
+    return Expression<Param<N, T, U>>{};
+}
+
+template <std::size_t N>
+struct CheckVarNum {
+    template <typename T>
+    struct Checker {
+        static constexpr bool value = (T::number == N);
+    };
+};
+
+template <typename T, typename U>
+struct BinaryOp {
+    static_assert(!(std::is_rvalue_reference_v<T> ||
+                    std::is_rvalue_reference_v<U>),
+                  "Rvalue references cannot be stored");
+    using IsBinaryOp = void;
+    using LhsType = T;
+    using RhsType = U;
+    T lhs;
+    U rhs;
+};
+
+namespace Detail {
+
+template <typename T, typename = void>
+struct LocalVarCollector {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::enable_if_t<IsLocalVar_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::void_t<typename T::IsBinaryOp>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename LocalVarCollector<typename T::LhsType>::Type,
+        typename LocalVarCollector<typename T::RhsType>::Type>;
+};
+
+template <typename T, typename = void>
+struct ParamCollector {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct ParamCollector<T, std::enable_if_t<IsParam_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct ParamCollector<T, std::void_t<typename T::IsBinaryOp>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename ParamCollector<typename T::LhsType>::Type,
+        typename ParamCollector<typename T::RhsType>::Type>;
+};
+
+} // namespace Detail
+
+template <typename T>
+struct LocalVars {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::LocalVarCollector<T>::Type>;
+};
+
+template <typename T>
+using LocalVars_t = typename LocalVars<T>::Type;
+
+template <typename T>
+struct Params {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+};
+
+template <typename T>
+using Params_t = typename Params<T>::Type;
+
+template <typename T>
+struct InParams {
+    template <typename U>
+    struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
+                                        U::usage == ParamUsage::in_out> {};
+    using Type =
+        Util::TMP::Filter_t<IsInVar, typename Params<T>::Type>;
+};
+
+template <typename T>
+using InParams_t = typename InParams<T>::Type;
+
+template <typename T>
+struct OutParams {
+    template <typename U>
+    struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
+                                         U::usage == ParamUsage::in_out> {};
+    using Type =
+        Util::TMP::Filter_t<IsOutVar, typename Params<T>::Type>;
+};
+
+template <typename T>
+using OutParams_t = typename OutParams<T>::Type;
+
+template <typename T, typename U>
+struct OpAssign : BinaryOp<T, U> {};
+
+template <typename T>
+template <typename U>
+[[nodiscard]] constexpr auto Expression<T>::operator=(Expression<U> u)
+{
+    static_assert(
+        (IsParam_v<T> || IsLocalVar_v<T> || std::is_lvalue_reference_v<T>),
+        "Only a Param, LocalVar, or reference can appear on the left side "
+        "of assignment");
+    return Expression<OpAssign<T, U>>{{data, u.data}};
+}
+
+template <typename T, typename U>
+struct OpAndThen : BinaryOp<T, U> {};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
+{
+    return Expression<OpAndThen<T, U>>{{t.data, u.data}};
+}
+
+// Disallow dangerous expressions like (Expression{2}, 3)
+template <typename T, typename U>
+constexpr auto operator,(Expression<T>t, U&& u) = delete;
+
+template <typename T, typename U>
+struct OpAdd : BinaryOp<T, U> {};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
+{
+    return Expression<OpAdd<T, U>>{{lhs.data, rhs.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(Expression<T> lhs, U&& rhs)
+{
+    return Expression<OpAdd<T, U>>{{lhs.data, std::forward<U>(rhs)}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(T&& lhs, Expression<U> rhs)
+{
+    return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
+}
+
+// Base class to express that a class is a maker of calculation expression template
+class Maker {};
+
+} // namespace ExprTmpl
+
+// NOLINTEND(misc-unconventional-assign-operator)
+// NOLINTEND(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
+
+
+/* Evaluation */
+
+namespace DemoEval {
+
+using Util::TMP::FindUnique_t;
+using Util::TMP::Size_v;
+
+using namespace ExprTmpl;
+
+// Primary template
+template <typename T>
+struct Evaluator {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(const T& value,
+                              ArgTup& args,
+                              LocalVarTup& localVars) const
+    {
+        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
+            return value(args, localVars);
+        } else {
+            return value;
+        }
+    }
+};
+
+template <std::size_t N, typename T>
+constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
+{
+    using ResultType = typename Evaluator<T>::Type;
+    return Expression<LocalVar<N, ResultType>>{};
+}
+
+namespace Detail {
+
+template <typename T, std::size_t... Ints>
+constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
+{
+    using LocalVars = typename LocalVars<T>::Type;
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              LocalVars>::Type{}...);
+}
+
+template <typename T>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename L, typename T, typename ArgTup>
+void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
+{
+    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
+    if constexpr (!std::is_same_v<typename L::Like, void>) {
+        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
+    }
+}
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup, std::size_t... Ints>
+void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
+                            std::index_sequence<Ints...>)
+{
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(std::get<Ints>(localVars), args), ...);
+}
+
+} // namespace Detail
+
+template <typename T>
+constexpr auto GetLocalVarTuple()
+{
+    using LocalVars = typename LocalVars<T>::Type;
+    constexpr auto localVarCount = Size_v<LocalVars>;
+    return Detail::GetLocalVarTupleImpl<T>(
+        std::make_index_sequence<localVarCount>{});
+};
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup>
+void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
+{
+    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
+        localVars, args,
+        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
+}
+
+template <typename T, typename... Args>
+auto Evaluate(const Expression<T>& expr, Args&&... args)
+{
+    // Declare local variables so that we can always use xTup& in
+    // Evaluator<>::operator()
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+    using LocalVars = typename LocalVars<T>::Type;
+    auto localVars = GetLocalVarTuple<T>();
+    MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
+    return Evaluator<T>{}(expr.data, argTuple, localVars);
+}
+
+// Treat Evaluator<Expression<T>> as Evaluator<T>
+template <typename T>
+struct Evaluator<Expression<T>> : Evaluator<T> {};
+
+// Partial specialization for LocalVar
+template <std::size_t N, typename T, typename L>
+struct Evaluator<LocalVar<N, T, L>> {
+    using Type = T&;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              ArgTup& /*args*/,
+                              LocalVarTup& localVars) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return std::get<N - 1>(localVars);
+    }
+};
+
+// Partial specialization for Param
+template <std::size_t N, typename T, ParamUsage U>
+struct Evaluator<Param<N, T, U>> {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+                              ArgTup& args,
+                              LocalVarTup& /*localVars*/) const
+    {
+        static_assert(N > 0, "Param number starts from 1");
+        static_assert(U == ParamUsage::in || std::is_reference_v<T>,
+                      "Only in-parameters can have value types");
+        constexpr auto index = N - 1;
+        using NthType =
+            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
+        if constexpr (std::is_same_v<T&, NthType> ||
+                      std::is_same_v<T&&, NthType>) {
+            return std::get<index>(args);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(std::get<index>(args));
+        }
+    }
+};
+
+template <typename T, typename U>
+void Assign(T& dst, const U& src)
+{
+    dst = src;
+}
+
+// Partial specializtion for E_y = E_x
+template <typename T, typename U>
+struct Evaluator<OpAssign<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Assign(Evaluator<T>{}(op.lhs, args, localVars),
+                      Evaluator<U>{}(op.rhs, args, localVars));
+    }
+};
+
+// Partial specializtion for E_x, E_y
+template <typename T, typename U>
+struct Evaluator<OpAndThen<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAndThen<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        // operator, evaluates sequentially
+        return Evaluator<T>{}(op.lhs, args, localVars),
+               Evaluator<U>{}(op.rhs, args, localVars);
+    }
+};
+
+template <typename T, typename U>
+auto Add(const T& src1, const U& src2)
+{
+    return src1 + src2;
+}
+
+template <typename T, typename U, typename V>
+void AddAssign(T& dst, const U& src1, const V& src2)
+{
+    dst = src1 + src2;
+}
+
+template <typename T>
+void AddAssign(std::vector<T>& dst,
+               const std::vector<T>& src1,
+               const std::vector<T>& src2)
+{
+    if (src1.size() != src2.size()) {
+        throw std::logic_error("vector sizes do not match");
+    }
+    if (src1.size() != dst.size()) {
+        throw std::logic_error("Destination vector should be like source");
+    }
+    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+// Partial specializtion for E_x + E_y
+template <typename T, typename U>
+struct Evaluator<OpAdd<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAdd<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Add(Evaluator<T>{}(op.lhs, args, localVars),
+                   Evaluator<U>{}(op.rhs, args, localVars));
+    }
+};
+
+// Partial specializtion for E_z = E_x + E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
+                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
+                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
+    }
+};
+
+} // namespace DemoEval
+
+namespace Emulation {
+
+template <
+    typename T, typename ExprMaker, typename... Args,
+    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(ExprMaker maker, Args&&... args)
+{
+    return DemoEval::Evaluate(maker.template Get<std::vector<T>>(),
+                              std::forward<Args>(args)...);
+}
+
+} // namespace Emulation
+
+
+/* Test */
+
+template <typename T>
+struct type_displayer;
+
+#define CONCAT(x, y) x ## y
+#define PASTE(x, y) CONCAT(x, y)
+#define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
+
+struct MyAddOp : ExprTmpl::Maker {
+    template <typename VectorType>
+    constexpr auto Get() const
+    {
+        using namespace ExprTmpl;
+        auto _1 = DefineParam<1, VectorType>();
+        auto _2 = DefineParam<2, VectorType>();
+        auto _3 = DefineParam<3, VectorType>();
+        auto _4 = DefineParam<4, VectorType>();
+        auto _5 = DefineParam<5, VectorType&, ParamUsage::out>();
+        auto tmp1 = DefineLocalVar<1, VectorType>(_1);
+        auto tmp2 = DefineLocalVar<2, VectorType>(_3);
+        return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2);
+    }
+};
+
+int main() // NOLINT(bugprone-exception-escape)
+{
+    using namespace ExprTmpl;
+    using namespace DemoEval;
+
+    auto _1 = DefineParam<1, int>();
+    auto _2 = DefineParam<2, int>();
+    [[maybe_unused]] auto result1 = _1 + _2;
+    [[maybe_unused]] auto result2 = _1 + Expression{3};
+    [[maybe_unused]] auto result3 = 42 + _1;
+    auto result4 = (Expression<Param<2, int&, ParamUsage::out>>{} = result3);
+    //TYPE_DISPLAY(OutParams_t<decltype(result4)::Type>{});
+    int out{};
+    Evaluate(result4, 1, out);
+    std::cout << out << '\n';
+
+    auto outVar = Expression{out};
+
+    auto tmp1 = DefineLocalVar<1, int>();
+    auto tmp2 = DefineAutoLocalVar<2>(tmp1 + tmp1);
+    auto result5 = (tmp1 = _1 + _2,
+                    tmp2 = tmp1 + tmp1,
+                    outVar = tmp2,
+                    tmp2);
+    std::cout << Evaluate(result5, 1, 2) << '\n';
+    //TYPE_DISPLAY(LocalVars_t<decltype(result5)::Type>{});
+    std::cout << out << '\n';
+
+    // Hack for direct computing
+    auto compute = [](auto& args, auto& /*localVars*/) {
+        return std::get<0>(args) + std::get<1>(args);
+    };
+    auto result6 = (_1, _2, Expression{compute});
+    //TYPE_DISPLAY(Params_t<decltype(result6)::Type>{});
+    static_assert(std::is_same_v<Params_t<decltype(result6)::Type>,
+                                 TypeList<Param<1, int>, Param<2, int>>>);
+    auto r = Evaluate(result6, 1, 2);
+    std::cout << r << '\n';
+
+    [[maybe_unused]] auto result7 = MyAddOp{}.Get<std::vector<float>>();
+    //TYPE_DISPLAY(result7);
+    //TYPE_DISPLAY(InParams_t<decltype(result7)::Type>{});
+    std::vector<float> v1(300, 1.0F);
+    std::vector<float> v2(300, 2.0F);
+    std::vector<float> v3(300, 3.0F);
+    std::vector<float> v4(300, 4.0F);
+    std::vector<float> v5(300);
+    Emulation::DoElementwise<float>(MyAddOp{}, v1, v2, v3, v4, v5);
+    std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
+              << '\n';
+}
-- 
Gitee


From ca6ede276493063e8cb51575a98b347861f1d2fc Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 10:11:45 +0800
Subject: [PATCH 004/116] Define and use `DefineLocalVarLike`

---
 .../expression_template/expr_template_demo.cpp         | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 3d6fec071..2377630e2 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -294,11 +294,11 @@ constexpr auto DefineLocalVar()
     return Expression<LocalVar<N, T>>{};
 }
 
-template <std::size_t N, typename T, typename L>
-constexpr auto DefineLocalVar(Expression<L> /*unused*/)
+template <std::size_t N, typename L>
+constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
 {
     static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
-    return Expression<LocalVar<N, T, L>>{};
+    return Expression<LocalVar<N, typename L::Type, L>>{};
 }
 
 template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
@@ -742,8 +742,8 @@ struct MyAddOp : ExprTmpl::Maker {
         auto _3 = DefineParam<3, VectorType>();
         auto _4 = DefineParam<4, VectorType>();
         auto _5 = DefineParam<5, VectorType&, ParamUsage::out>();
-        auto tmp1 = DefineLocalVar<1, VectorType>(_1);
-        auto tmp2 = DefineLocalVar<2, VectorType>(_3);
+        auto tmp1 = DefineLocalVarLike<1>(_1);
+        auto tmp2 = DefineLocalVarLike<2>(_3);
         return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2);
     }
 };
-- 
Gitee


From 2b1b7cb79540fe11235968cf5c240a25623b5cf0 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 10:27:07 +0800
Subject: [PATCH 005/116] Rename some parameters for clarity and consistency

---
 .../expression_template/expr_template_demo.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 2377630e2..abb050115 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -34,9 +34,9 @@ struct TypeList {};
 template <typename List>
 struct First;
 
-template <typename H, typename... Ts>
-struct First<TypeList<H, Ts...>> {
-    using Type = H;
+template <typename Head, typename... Tail>
+struct First<TypeList<Head, Tail...>> {
+    using Type = Head;
 };
 
 template <typename List>
@@ -137,14 +137,14 @@ using Filter_t = typename Filter<Pred, List>::Type;
 template <typename List, std::size_t N>
 struct Get;
 
-template <typename T, typename... Ts, std::size_t N>
-struct Get<TypeList<T, Ts...>, N> {
-    using Type = typename Get<TypeList<Ts...>, N - 1>::Type;
+template <typename Head, typename... Tail, std::size_t N>
+struct Get<TypeList<Head, Tail...>, N> {
+    using Type = typename Get<TypeList<Tail...>, N - 1>::Type;
 };
 
-template <typename T, typename... Ts>
-struct Get<TypeList<T, Ts...>, 0> {
-    using Type = T;
+template <typename Head, typename... Tail>
+struct Get<TypeList<Head, Tail...>, 0> {
+    using Type = Head;
 };
 
 template <std::size_t N>
-- 
Gitee


From 8867768c0cb2e59ab2db3b3ffe024b8ae9827281 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 10:52:38 +0800
Subject: [PATCH 006/116] Add metafunction `Check`

---
 .../expression_template/expr_template_demo.cpp  | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index abb050115..7e9dcdd71 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -92,6 +92,23 @@ struct Concatenate<List1, List2, List3, Lists...> {
 template <typename... Lists>
 using Concatenate_t = typename Concatenate<Lists...>::Type;
 
+template <template <typename> class Pred, typename List>
+struct Check;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Check<Pred, TypeList<Head, Tail...>> {
+    static constexpr bool value =
+        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
+};
+
+template <template <typename> class Pred>
+struct Check<Pred, TypeList<>> {
+    static constexpr bool value = true;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr bool Check_v = Check<Pred, List>::value;
+
 template <template <typename> class Pred, typename List, typename = void>
 struct Find;
 
-- 
Gitee


From 9f518d518b9e985a1c659cbdccf507f8d0e4247a Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 11:11:04 +0800
Subject: [PATCH 007/116] Check LocalVar and Param for better diagnostics

---
 .../expr_template_demo.cpp                    | 27 +++++++++++++++----
 1 file changed, 22 insertions(+), 5 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 7e9dcdd71..478ad8d3a 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -386,6 +386,15 @@ template <typename T>
 struct LocalVars {
     using Type =
         Util::TMP::Unique_t<typename Detail::LocalVarCollector<T>::Type>;
+
+private:
+    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
+
+    template <typename U>
+    struct InRange
+        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
+    static_assert(Util::TMP::Check_v<InRange, Type>,
+                  "LocalVars must be numbered sequentially from 1");
 };
 
 template <typename T>
@@ -395,6 +404,15 @@ template <typename T>
 struct Params {
     using Type =
         Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+
+private:
+    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
+
+    template <typename U>
+    struct InRange
+        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
+    static_assert(Util::TMP::Check_v<InRange, Type>,
+                  "Params must be numbered sequentially from 1");
 };
 
 template <typename T>
@@ -405,8 +423,7 @@ struct InParams {
     template <typename U>
     struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
                                         U::usage == ParamUsage::in_out> {};
-    using Type =
-        Util::TMP::Filter_t<IsInVar, typename Params<T>::Type>;
+    using Type = Util::TMP::Filter_t<IsInVar, Params_t<T>>;
 };
 
 template <typename T>
@@ -417,8 +434,7 @@ struct OutParams {
     template <typename U>
     struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
                                          U::usage == ParamUsage::in_out> {};
-    using Type =
-        Util::TMP::Filter_t<IsOutVar, typename Params<T>::Type>;
+    using Type = Util::TMP::Filter_t<IsOutVar, Params_t<T>>;
 };
 
 template <typename T>
@@ -574,7 +590,8 @@ auto Evaluate(const Expression<T>& expr, Args&&... args)
     // Declare local variables so that we can always use xTup& in
     // Evaluator<>::operator()
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
-    using LocalVars = typename LocalVars<T>::Type;
+    using LocalVars = LocalVars_t<T>;
+    [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
     auto localVars = GetLocalVarTuple<T>();
     MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
     return Evaluator<T>{}(expr.data, argTuple, localVars);
-- 
Gitee


From 3acad093eeb88efe47632eed5d6dc1aa0944c232 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 15:38:33 +0800
Subject: [PATCH 008/116] Simplify Expression code and add comment

---
 .../expression_template/expr_template_demo.cpp   | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 478ad8d3a..1bba68bb4 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -219,6 +219,12 @@ namespace ExprTmpl {
 
 using Util::TMP::TypeList;
 
+// Type for a basic "expression".  If T is trivial (as it should normally
+// be), Expression<T> is trivially copy-constructible and trivially move-
+// constructible, but is not trivially assignable.  Objects of the same
+// Expression type cannot be assigned, because the data member is const.
+// Objects of different Expression types can be assigned, but it will
+// result in a new Expression object (and is not a "normal" assignment).
 template <typename T>
 struct Expression {
     static_assert(!std::is_rvalue_reference_v<T>,
@@ -226,18 +232,8 @@ struct Expression {
     using Type = T;
     T const data{};  // NOLINT(misc-non-private-member-variables-in-classes)
 
-    explicit Expression(T&& t) : data(std::forward<T>(t)) {}
-    Expression() = default;
-    Expression(const Expression&) = default;
-    ~Expression() = default;
-
     template <typename U>
     [[nodiscard]] constexpr auto operator=(Expression<U> u);
-
-    [[nodiscard]] constexpr auto operator=(Expression rhs)
-    {
-        return operator=<T>(rhs);  // Invoke the templated version
-    }
 };
 
 // Let T deduce to value type or lvalue reference type
-- 
Gitee


From 0c10ad0b3ac653991dcc088c03f4971c38f6d61f Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 16:06:52 +0800
Subject: [PATCH 009/116] Implement HasDataTrait

---
 .../expression_template/expr_template_demo.cpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 1bba68bb4..b8aed3fdb 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -219,6 +219,16 @@ namespace ExprTmpl {
 
 using Util::TMP::TypeList;
 
+template <typename T, typename = void>
+struct HasDataTrait {
+    static constexpr bool value = true;
+};
+
+template <typename T>
+struct HasDataTrait<T, std::void_t<decltype(T::hasData)>> {
+    static constexpr bool value = T::hasData;
+};
+
 // Type for a basic "expression".  If T is trivial (as it should normally
 // be), Expression<T> is trivially copy-constructible and trivially move-
 // constructible, but is not trivially assignable.  Objects of the same
@@ -230,7 +240,9 @@ struct Expression {
     static_assert(!std::is_rvalue_reference_v<T>,
                   "Rvalue references cannot be stored");
     using Type = T;
-    T const data{};  // NOLINT(misc-non-private-member-variables-in-classes)
+    static constexpr bool hasData = HasDataTrait<T>::value;
+
+    T const data{};
 
     template <typename U>
     [[nodiscard]] constexpr auto operator=(Expression<U> u);
@@ -253,6 +265,7 @@ struct LocalVar {
     using Type = T;
     using Like = L;
     static constexpr std::size_t number = N;
+    static constexpr bool hasData = false;
 
     template <typename V>
     constexpr auto operator=(Expression<V>)
@@ -283,6 +296,7 @@ struct Param {
     using Type = T;
     static constexpr std::size_t number = N;
     static constexpr ParamUsage usage = U;
+    static constexpr bool hasData = false;
 
     template <typename V>
     constexpr auto operator=(Expression<V>)
@@ -333,6 +347,8 @@ struct BinaryOp {
     static_assert(!(std::is_rvalue_reference_v<T> ||
                     std::is_rvalue_reference_v<U>),
                   "Rvalue references cannot be stored");
+    static constexpr bool hasData =
+        HasDataTrait<T>::value || HasDataTrait<U>::value;
     using IsBinaryOp = void;
     using LhsType = T;
     using RhsType = U;
-- 
Gitee


From 64e1e5bdba835fd82de7d26e020740194c301366 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 19:49:19 +0800
Subject: [PATCH 010/116] Add a static assertion using `hasData`

---
 best_practices/expression_template/expr_template_demo.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index b8aed3fdb..816a9a2a1 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -834,6 +834,7 @@ int main() // NOLINT(bugprone-exception-escape)
     std::cout << r << '\n';
 
     [[maybe_unused]] auto result7 = MyAddOp{}.Get<std::vector<float>>();
+    static_assert(!decltype(result7)::hasData);
     //TYPE_DISPLAY(result7);
     //TYPE_DISPLAY(InParams_t<decltype(result7)::Type>{});
     std::vector<float> v1(300, 1.0F);
-- 
Gitee


From a86878a54a858fed38afd0060e9dac0066ff3f0d Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Sep 2025 20:07:03 +0800
Subject: [PATCH 011/116] Make value type of vector flexible

---
 .../expr_template_demo.cpp                    | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 816a9a2a1..77ea53ccb 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -755,14 +755,17 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
 
 } // namespace DemoEval
 
+template <typename T>
+using VectorType = std::vector<T>;
+
 namespace Emulation {
 
 template <
-    typename T, typename ExprMaker, typename... Args,
+    typename ExprMaker, typename... Args,
     typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
 void DoElementwise(ExprMaker maker, Args&&... args)
 {
-    return DemoEval::Evaluate(maker.template Get<std::vector<T>>(),
+    return DemoEval::Evaluate(maker.template Get<VectorType>(),
                               std::forward<Args>(args)...);
 }
 
@@ -779,15 +782,15 @@ struct type_displayer;
 #define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
 
 struct MyAddOp : ExprTmpl::Maker {
-    template <typename VectorType>
+    template <template <typename> class VectorType>
     constexpr auto Get() const
     {
         using namespace ExprTmpl;
-        auto _1 = DefineParam<1, VectorType>();
-        auto _2 = DefineParam<2, VectorType>();
-        auto _3 = DefineParam<3, VectorType>();
-        auto _4 = DefineParam<4, VectorType>();
-        auto _5 = DefineParam<5, VectorType&, ParamUsage::out>();
+        auto _1 = DefineParam<1, VectorType<float>>();
+        auto _2 = DefineParam<2, VectorType<float>>();
+        auto _3 = DefineParam<3, VectorType<float>>();
+        auto _4 = DefineParam<4, VectorType<float>>();
+        auto _5 = DefineParam<5, VectorType<float>&, ParamUsage::out>();
         auto tmp1 = DefineLocalVarLike<1>(_1);
         auto tmp2 = DefineLocalVarLike<2>(_3);
         return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2);
@@ -833,7 +836,7 @@ int main() // NOLINT(bugprone-exception-escape)
     auto r = Evaluate(result6, 1, 2);
     std::cout << r << '\n';
 
-    [[maybe_unused]] auto result7 = MyAddOp{}.Get<std::vector<float>>();
+    [[maybe_unused]] auto result7 = MyAddOp{}.Get<VectorType>();
     static_assert(!decltype(result7)::hasData);
     //TYPE_DISPLAY(result7);
     //TYPE_DISPLAY(InParams_t<decltype(result7)::Type>{});
@@ -842,7 +845,7 @@ int main() // NOLINT(bugprone-exception-escape)
     std::vector<float> v3(300, 3.0F);
     std::vector<float> v4(300, 4.0F);
     std::vector<float> v5(300);
-    Emulation::DoElementwise<float>(MyAddOp{}, v1, v2, v3, v4, v5);
+    Emulation::DoElementwise(MyAddOp{}, v1, v2, v3, v4, v5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
 }
-- 
Gitee


From 39cf16cd5670a814cfb20f11d9b08d47e339b40c Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Wed, 10 Sep 2025 20:57:25 +0800
Subject: [PATCH 012/116] add atvos demo

---
 .../atvos/include/device/device_vector.h      |   2 +-
 best_practices/atvos/main/main.cpp            |  26 +-
 .../atvos_demo/include/block/block_elewise.h  |  43 +
 .../include/device/device_elewise.h           |  97 +++
 .../atvos_demo/include/device/device_vector.h |  58 ++
 .../include/device/device_vector_impl.h       |  31 +
 .../include/kernel/kernel_elewise.h           |  28 +
 .../atvos_demo/include/tile/tile_elewise.h    |   9 +
 .../include/utils/expression/expression.h     | 745 ++++++++++++++++++
 best_practices/atvos_demo/test/demo           | Bin 0 -> 71816 bytes
 best_practices/atvos_demo/test/main.cpp       |  44 ++
 11 files changed, 1060 insertions(+), 23 deletions(-)
 create mode 100644 best_practices/atvos_demo/include/block/block_elewise.h
 create mode 100644 best_practices/atvos_demo/include/device/device_elewise.h
 create mode 100644 best_practices/atvos_demo/include/device/device_vector.h
 create mode 100644 best_practices/atvos_demo/include/device/device_vector_impl.h
 create mode 100644 best_practices/atvos_demo/include/kernel/kernel_elewise.h
 create mode 100644 best_practices/atvos_demo/include/tile/tile_elewise.h
 create mode 100644 best_practices/atvos_demo/include/utils/expression/expression.h
 create mode 100755 best_practices/atvos_demo/test/demo
 create mode 100644 best_practices/atvos_demo/test/main.cpp

diff --git a/best_practices/atvos/include/device/device_vector.h b/best_practices/atvos/include/device/device_vector.h
index e312fe073..9ec8a0d74 100644
--- a/best_practices/atvos/include/device/device_vector.h
+++ b/best_practices/atvos/include/device/device_vector.h
@@ -14,7 +14,7 @@ using Stream = int*;
  * 
  * @tparam OpTraits_    需要的Layout 信息
  * @tparam KernelOp     kernel 的入口
- * @tparam Policy       策略
+ * @tparam Policy       策略: 决策KernelOp的处理策略， 例如：Reduce 时分解为2个OpKernel， 前一个OpKernel 处理Reduce 到workspace,  后一个OpKernel 从workspace 到gm
  * @tparam Enable 
  */
 template<class KernelOp, class OpTraits_=void,  class Policy_=void, class Schedule =void, class Enable=void>
diff --git a/best_practices/atvos/main/main.cpp b/best_practices/atvos/main/main.cpp
index 82b565b12..c48a9f333 100644
--- a/best_practices/atvos/main/main.cpp
+++ b/best_practices/atvos/main/main.cpp
@@ -10,8 +10,10 @@
 
 using namespace ATVOS;
 
+
+/* ------------方案1： ATVOSS方案 -------*/
 // 1, 描述算子原型
-using Input0 = Input<int, Layout<Shape<int, int>> >;  //描述每个Block的输入，以及处理的Shape 大小
+using Input0 = Input<int, Layout<Shape<int, int>> >;  //描述每个Block的输入，以及处理的Shape stride大小
 using Input1 = Input<int, Layout<Shape<int, int>> >;                    //描述每个Block的输入, 自动推导
 using out = Output<int, Layout<Shape<int,int>> >;                   //描述每个Block的输入，自动推导
 
@@ -26,26 +28,6 @@ struct MyComputer {
     constexpr static auto out =  std::tuple{subs};
 };
 
-#if 0 
-template<class Traits_>
-struct MyComputer { 
-    using T = Traits_;
-    template<auto pattern, class... Args>
-    void Run(LocalTensor<T> out, LocalTensor<T>& in1, LocalTensor<T>& in2,  int a ){
-      auto myAdd = Expr<Tile::Add<int>>( in1, in2);
-      auto subs = Expr<Tile::Add<int>>(myAdd, 0.5 );
-      out = Evaluate(subs);
-    }
-
-    template<class... Args>
-    auto Run(){
-      auto myAdd = Expr<Tile::Add<int>>( in1, in2);
-      auto subs = Expr<Tile::Add<int>>(myAdd, 0.5 );
-      return subs;
-    }
-};
-#endif 
-
 // 3, 选择 Block 模版（进行调度)
 template<class Traits_>
 using MyBlock = BlockElemwise<decltype(MyComputer<Traits_>::out), Traits_>;
@@ -55,7 +37,7 @@ template<class Traits_>
 using MyKernel = KernelElemwise< MyBlock<Traits_>>;
 
 // 5,  Device 侧 host+device 混合编程
-using device =  DeviceAdapt< MyKernel<OpTraits> >;   
+using device =  DeviceAdapt< MyKernel<OpTraits> >;
 
 int main(int argc, const char* argv[]) {
     
diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
new file mode 100644
index 000000000..8f583b719
--- /dev/null
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -0,0 +1,43 @@
+namespace ATVC::Block {
+
+template <
+    typename T, typename ExprMaker, typename ArgTup,
+    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(const Config& configBlock, ArgTup& argTuple)
+{
+    // 配置规划，特别是需要确定使用的 Local Memory 大小
+    Tile::Config configTile = MakeConfig<ExprMaker>(configBlock, argTuple);
+
+    auto expr = maker.Get<LocalTensor<T>>();
+    using Expr = decltype(expr);
+    using LocalVars = ExprTmpl::LocalVars_t<Expr>;
+    using Params = ExprTmpl::Params_t<Expr>;
+    using InParams = ExprTmpl::InParams_t<Expr>;
+    using OutParams = ExprTmpl::OutParams_t<Expr>;
+
+    // 得到 tuple<LocalTensor, ...>，向量变成了 LocalTensor 类型
+    auto params = PrepareParams<Params>(configTile);
+    // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
+    auto inParams = PrepareInParams<InParams>(params);
+    auto outParams = PrepareOutParams<InParams>(params);
+    // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
+    auto localVars = PrepareLocalVars<LocalVars>(params);
+
+    // 把 argTuple 里的向量替换成 params 里的对应 Tensor
+    auto combinedArgs = CombineArgs(params, argTuple);
+
+    // 循环执行
+    for (int i = 0; i < configTile.wholeBlockCount; ++i) {
+        CopyIn<InParams>(inParams, argTuple);
+        Tile::Evaluate<Expr>(combinedArgs, localVars);
+        CopyOut<OutParams>(outParams, argTuple);
+    }
+    // 尾块的处理
+    for (int i = 0; i < configTile.tileBlockCount; ++i) {
+        CopyIn<InParams>(inParams, argTuple);
+        Tile::Evaluate<Expr>(combinedArgs, localVars);
+        CopyOut<OutParams>(outParams, argTuple);
+    }
+}
+
+} // namespace ATVC::Block
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
new file mode 100644
index 000000000..efdf16513
--- /dev/null
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -0,0 +1,97 @@
+#include "acl/acl.h"
+
+#define CHECK_ACL(x)                                                                        \
+    do {                                                                                    \
+        aclError __ret = x;                                                                 \
+        if (__ret != ACL_ERROR_NONE) {                                                      \
+            std::cerr << __FILE__ << ":" << __LINE__ << " aclError:" << __ret << std::endl; \
+        }                                                                                   \
+    } while (0)
+
+void InitializeACL(aclrtContext &context, aclrtStream &stream, int32_t deviceId)
+{
+    CHECK_ACL(aclInit(nullptr));
+    CHECK_ACL(aclrtSetDevice(deviceId));
+    CHECK_ACL(aclrtCreateContext(&context, deviceId));
+    CHECK_ACL(aclrtCreateStream(&stream));
+}
+
+void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
+{
+    CHECK_ACL(aclrtDestroyStream(stream));
+    CHECK_ACL(aclrtDestroyContext(context));
+    CHECK_ACL(aclrtResetDevice(deviceId));
+    CHECK_ACL(aclFinalize());
+}
+
+template<class KernelOp, class... Args>
+__global__ __aicore__ void MyKernel(GM_ADDR configDevice, Args... args)
+{
+    KernelOp op;
+    op.Run(configDevice, args...);
+}
+
+namespace ATVC::Device {
+
+template<class KernelOp, class... Args>
+void LaunchKernelWithDataTuple(uint32_t blockNum, uint8_t* configDevice, Args... args)
+{
+    aclrtContext context;
+    int32_t deviceId = 0;
+    aclrtStream stream = nullptr;
+    InitializeACL(context, stream, deviceId);
+    MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, args...);
+    CleanACL(stream, context, deviceId);
+}
+/*
+ExprMaker maker: 描述计算表达信息
+Args&&... args： 输入输出信息
+*/
+template <
+    typename T, typename ExprMaker, typename... Args,
+    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(ExprMaker maker, Args&&... args)
+{
+    // 配置规划
+    auto config = MakeConfig(maker, std::forward<Args>(args)...);
+
+    auto expr = maker.template Get<Tensor<T>>(); // Tensor 为表达 Device 层向量的类型
+    using Expr = decltype(expr);
+    static_assert(!Expr::hasData, "设备侧使用的表达式模板不应包含数据")
+    using Params = ExprTmpl::Params_t<Expr>;
+    using InParams = ExprTmpl::InParams_t<Expr>;
+    using OutParams = ExprTmpl::OutParams_t<Expr>;
+
+    // 得到 tuple<Tensor, ...>，向量变成了 Device 专用的 Tensor 类型
+    auto params = PrepareParams<Params>();
+    // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
+    auto inParams = PrepareInParams<InParams>(params);
+    auto outParams = PrepareOutParams<InParams>(params);
+
+    // 参数打包成 tuple
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args...));
+
+    // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
+    CopyIn<InParams>(inParams, argTuple);
+
+    // 把 config 复制到 GM
+    uint8_t* configDevice;
+    CopyConfig(config, configDevice);
+
+    // 把 argTuple 里的向量替换成 params 里的对应 Tensor
+    auto combinedArgs = CombineArgs(params, argTuple);
+    // 传递参数到设备侧执行
+    LaunchKernelWithDataTuple<Kernel::DoElementwise<T, ExprMaker>>(config.blockNum, configDevice, argTuple);
+
+    // 同步，等待执行结束
+    WaitForCompletion();
+
+    // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
+    CopyOut<OutParams>(outParams, argTuple);
+
+    // Tensor 和 configDevice 需手工清理
+    ClearConfig(configDevice);
+    ClearTensors(params);
+}
+
+} // namespace ATVC::Device
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_vector.h b/best_practices/atvos_demo/include/device/device_vector.h
new file mode 100644
index 000000000..7dbabaeda
--- /dev/null
+++ b/best_practices/atvos_demo/include/device/device_vector.h
@@ -0,0 +1,58 @@
+#ifndef _DEVICE_VECTOR_H_
+#define _DEVICE_VECTOR_H_
+
+#include "../dfx/check.h"
+
+
+namespace ATVOS {
+
+
+using Stream = int*;
+
+/**
+ * @brief 
+ * 
+ * @tparam OpTraits_    需要的Layout 信息
+ * @tparam KernelOp     kernel 的入口
+ * @tparam Policy       策略: 决策KernelOp的处理策略， 例如：Reduce 时分解为2个OpKernel， 前一个OpKernel 处理Reduce 到workspace,  后一个OpKernel 从workspace 到gm
+ * @tparam Enable 
+ */
+template<class KernelOp, class Policy_=void, class Schedule =void, class Enable=void>
+class DeviceAdapt {
+public: 
+    using OpTraits  = std::conditional_t<std::is_same_v<OpTraits_,void>, typename KernelOp::OpTraits, OpTraits_>;
+    using Arguments = std::conditional_t<std::is_same_v<OpTraits_,void>, typename KernelOp::Arguments, ArgumentsBase<OpTraits_>>;
+    using Policy    = std::conditional_t<std::is_same_v<Policy_, void>, typename KernelOp::Policy, Policy_>;
+public:   
+    static_assert( Dfx::IsTupleV<OpTraits>, "OpTraits_ is std::tuple");
+public:
+    DeviceAdapt(){};
+
+    bool CanImplement(Arguments& arg); //检查参数的合法性
+    int64_t GetWorkspaceSize(Arguments& arg); 
+    int64_t Run(Arguments& args, Policy* policy=nullptr, Stream stream = nullptr);
+
+}; 
+
+#include "device_vector_impl.h"
+
+
+
+
+} // ATVOS
+
+
+     
+#endif //_DEVICE_VECTOR_H_
+ 
+
+
+
+
+
+
+
+
+
+
+ 
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_vector_impl.h b/best_practices/atvos_demo/include/device/device_vector_impl.h
new file mode 100644
index 000000000..3b52be84e
--- /dev/null
+++ b/best_practices/atvos_demo/include/device/device_vector_impl.h
@@ -0,0 +1,31 @@
+#ifndef __ATVOS_DEVECOR_VECTOR_IMPPL_H_
+#define __ATVOS_DEVECOR_VECTOR_IMPPL_H_
+
+
+
+template<class KernelOp, class OpTraits_,  class Policy_, class Schedule, class Enable>
+bool DeviceAdapt<KernelOp, OpTraits_,  Policy_, Schedule, Enable>::CanImplement(Arguments& arg){
+    //检查KernelOp 的In,out 是否进行了 gm 地址的赋值
+    return 0;
+};
+template<class KernelOp, class OpTraits_, class Policy_, class Schedule, class Enable>
+int64_t DeviceAdapt< KernelOp, OpTraits_, Policy_, Schedule, Enable>::GetWorkspaceSize(Arguments& arg)
+{
+    return 0;
+}; 
+
+template<class KernelOp, class OpTraits_, class Policy_, class Schedule, class Enable>
+int64_t DeviceAdapt<KernelOp, OpTraits_,  Policy_, Schedule, Enable>::Run(Arguments&  arg, Policy* policy, Stream stream){
+    //构建Kernel 对象，然后调用 
+    KernelOp op;
+     
+    op.Run(arg, nullptr);
+    return 0;
+};
+
+
+
+
+
+#endif //__ATVOS_DEVECOR_VECTOR_IMPPL_H_
+
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
new file mode 100644
index 000000000..bb90d658c
--- /dev/null
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -0,0 +1,28 @@
+namespace ATVC::Kernel {
+
+template <
+    typename T, typename ExprMaker, typename... Args,
+    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(uint8_t* configKernel, Args... args)
+{
+    // 配置规划
+    Block::Config configBlock = MakeConfig<ExprMaker>(configKernel, args...);
+
+    auto expr = maker.Get<GlobalTensor<T>>();
+    using Expr = decltype(expr);
+    using Params = ExprTmpl::Params_t<Expr>;
+    using InParams = ExprTmpl::InParams_t<Expr>;
+    using OutParams = ExprTmpl::OutParams_t<Expr>;
+
+    // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
+    // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
+    auto params = PrepareParams<Params>(args...);
+
+    // 执行计算
+    // 循环执行
+    for (int i = 0; i < configKernel.wholeBlockCount; ++i) {
+        Block::DoElementwise<T, Maker>(configBlock, params);
+    }
+}
+
+} // namespace ATVC::Kernel
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
new file mode 100644
index 000000000..f3ae0eb98
--- /dev/null
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -0,0 +1,9 @@
+namespace ATVC::Tile {
+
+template <typename Expr, typename ArgTup, typename LocalVarTup>
+void Evaluate(ArgTup& args, LocalVarTup& localVars)
+{
+    Evaluator<Expr::Type>{}(args, localVars);
+}
+
+} // namespace ATVC::Tile
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/utils/expression/expression.h b/best_practices/atvos_demo/include/utils/expression/expression.h
new file mode 100644
index 000000000..e9e65c7ba
--- /dev/null
+++ b/best_practices/atvos_demo/include/utils/expression/expression.h
@@ -0,0 +1,745 @@
+#include <cstddef>
+#include <iostream>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+
+/* Utilities */
+
+namespace Util {
+
+template <typename T>
+struct AlwaysFalse : std::false_type {};
+
+template <typename T>
+inline constexpr bool AlwaysFalse_v = AlwaysFalse<T>::value;
+
+template <template <typename...> class T, typename U>
+struct IsSpecializationOf : std::false_type {};
+
+template <template <typename...> class T, typename... Us>
+struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
+
+template <template <typename...> class T, typename U>
+inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
+
+namespace TMP {
+
+template <typename... Ts>
+struct TypeList {};
+
+template <typename List>
+struct First;
+
+template <typename Head, typename... Tail>
+struct First<TypeList<Head, Tail...>> {
+    using Type = Head;
+};
+
+template <typename List>
+using First_t = typename First<List>::Type;
+
+template <typename List>
+struct Size;
+
+template <typename... Ts>
+struct Size<TypeList<Ts...>> {
+    static constexpr std::size_t value = sizeof...(Ts);
+};
+
+template <typename List>
+inline constexpr std::size_t Size_v = Size<List>::value;
+
+template <typename T, typename List>
+struct Prepend;
+
+template <typename T, typename... Ts>
+struct Prepend<T, TypeList<Ts...>> {
+    using Type = TypeList<T, Ts...>;
+};
+
+template <typename T, typename List>
+using Prepend_t = typename Prepend<T, List>::Type;
+
+template <typename... Lists>
+struct Concatenate;
+
+template <>
+struct Concatenate<> {
+    using Type = TypeList<>;
+};
+
+template <typename... Ts>
+struct Concatenate<TypeList<Ts...>> {
+    using Type = TypeList<Ts...>;
+};
+
+template <typename... Ts, typename... Us>
+struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
+    using Type = TypeList<Ts..., Us...>;
+};
+
+template <typename List1, typename List2, typename List3, typename... Lists>
+struct Concatenate<List1, List2, List3, Lists...> {
+    using Type =
+        typename Concatenate<typename Concatenate<List1, List2>::Type,
+                             List3, Lists...>::Type;
+};
+
+template <typename... Lists>
+using Concatenate_t = typename Concatenate<Lists...>::Type;
+
+template <template <typename> class Pred, typename List>
+struct Check;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Check<Pred, TypeList<Head, Tail...>> {
+    static constexpr bool value =
+        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
+};
+
+template <template <typename> class Pred>
+struct Check<Pred, TypeList<>> {
+    static constexpr bool value = true;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr bool Check_v = Check<Pred, List>::value;
+
+template <template <typename> class Pred, typename List, typename = void>
+struct Find;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<Pred<Head>::value>> {
+    using Type = Head;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<!Pred<Head>::value>>
+    : Find<Pred, TypeList<Tail...>> {};
+
+template <template <typename> class Pred>
+struct Find<Pred, TypeList<>, void> {
+    static_assert(AlwaysFalse_v<Pred<void>>,
+                  "Cannot find the specified element");
+};
+
+template <template <typename> class Pred, typename List>
+using Find_t = typename Find<Pred, List>::Type;
+
+template <template <typename> class Pred, typename List>
+struct Filter;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Filter<Pred, TypeList<Head, Tail...>> {
+    using Type = typename std::conditional_t<
+        Pred<Head>::value,
+        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
+        typename Filter<Pred, TypeList<Tail...>>::Type>;
+};
+
+template <template <typename> class Pred>
+struct Filter<Pred, TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <template <typename> class Pred, typename List>
+using Filter_t = typename Filter<Pred, List>::Type;
+
+template <typename List, std::size_t N>
+struct Get;
+
+template <typename Head, typename... Tail, std::size_t N>
+struct Get<TypeList<Head, Tail...>, N> {
+    using Type = typename Get<TypeList<Tail...>, N - 1>::Type;
+};
+
+template <typename Head, typename... Tail>
+struct Get<TypeList<Head, Tail...>, 0> {
+    using Type = Head;
+};
+
+template <std::size_t N>
+struct Get<TypeList<>, N> {
+    static_assert(N < 0, "Index out of bounds in Get");
+};
+
+template <typename List, std::size_t N>
+using Get_t = typename Get<List, N>::Type;
+
+template <typename List>
+struct Unique;
+
+template <typename Head, typename... Tail>
+struct Unique<TypeList<Head, Tail...>> {
+    template <typename T>
+    struct IsNotHead : std::bool_constant<!std::is_same_v<T, Head>> {};
+
+    using Type = Prepend_t<
+        Head,
+        typename Unique<Filter_t<IsNotHead, TypeList<Tail...>>>::Type>;
+};
+
+template <>
+struct Unique<TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <typename List>
+using Unique_t = typename Unique<List>::Type;
+
+template <template <typename> class Pred, typename List>
+struct FindUnique {
+    using ResultList = Filter_t<Pred, List>;
+    static_assert(Size_v<ResultList> != 0, "Cannot find the specified element");
+    static_assert(Size_v<ResultList> == 1, "A unique result is expected");
+    using Type = First_t<ResultList>;
+};
+
+template <template <typename> class Pred, typename List>
+using FindUnique_t = typename FindUnique<Pred, List>::Type;
+
+} // namespace TMP
+
+} // namespace Util
+
+
+/* Expression templates */
+
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
+// NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTBEGIN(misc-unconventional-assign-operator)
+
+namespace ExprTmpl {
+
+using Util::TMP::TypeList;
+
+template <typename T>
+struct Expression {
+    static_assert(!std::is_rvalue_reference_v<T>,
+                  "Rvalue references cannot be stored");
+    using Type = T;
+    T const data{};  // NOLINT(misc-non-private-member-variables-in-classes)
+
+    explicit Expression(T&& t) : data(std::forward<T>(t)) {}
+    Expression() = default;
+    Expression(const Expression&) = default;
+    ~Expression() = default;
+
+    template <typename U>
+    [[nodiscard]] constexpr auto operator=(Expression<U> u);
+
+    [[nodiscard]] constexpr auto operator=(Expression rhs)
+    {
+        return operator=<T>(rhs);  // Invoke the templated version
+    }
+};
+
+// Let T deduce to value type or lvalue reference type
+template <typename T>
+Expression(T&& value) -> Expression<T>;
+
+template <typename T>
+using IsExpression = Util::IsSpecializationOf<Expression, T>;
+
+template <typename T>
+inline constexpr bool IsExpression_v = IsExpression<T>::value;
+
+template <std::size_t N, typename T, typename L = void>
+struct LocalVar {
+    static_assert(!std::is_reference_v<T>,
+                  "A LocalVar must not be a reference");
+    using Type = T;
+    using Like = L;
+    static constexpr std::size_t number = N;
+
+    template <typename V>
+    constexpr auto operator=(Expression<V>)
+    {
+        static_assert(Util::AlwaysFalse_v<V>,
+                      "Please use Expression<LocalVar> for assignment");
+    }
+};
+
+template <typename T>
+struct IsLocalVar : std::false_type {};
+
+template <std::size_t N, typename T, typename L>
+struct IsLocalVar<LocalVar<N, T, L>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsLocalVar_v = IsLocalVar<T>::value;
+
+enum class ParamUsage {
+    in,
+    out,
+    in_out,
+    //temporary,
+};
+
+template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
+struct Param {
+    using Type = T;
+    static constexpr std::size_t number = N;
+    static constexpr ParamUsage usage = U;
+
+    template <typename V>
+    constexpr auto operator=(Expression<V>)
+    {
+        static_assert(Util::AlwaysFalse_v<V>,
+                      "Please use Expression<Param> for assignment");
+    }
+};
+
+template <typename T>
+struct IsParam : std::false_type {};
+
+template <std::size_t N, typename T, ParamUsage U>
+struct IsParam<Param<N, T, U>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsParam_v = IsParam<T>::value;
+
+template <std::size_t N, typename T>
+constexpr auto DefineLocalVar()
+{
+    return Expression<LocalVar<N, T>>{};
+}
+
+template <std::size_t N, typename L>
+constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
+{
+    static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
+    return Expression<LocalVar<N, typename L::Type, L>>{};
+}
+
+template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
+constexpr auto DefineParam()
+{
+    return Expression<Param<N, T, U>>{};
+}
+
+template <std::size_t N>
+struct CheckVarNum {
+    template <typename T>
+    struct Checker {
+        static constexpr bool value = (T::number == N);
+    };
+};
+
+template <typename T, typename U>
+struct BinaryOp {
+    static_assert(!(std::is_rvalue_reference_v<T> ||
+                    std::is_rvalue_reference_v<U>),
+                  "Rvalue references cannot be stored");
+    using IsBinaryOp = void;
+    using LhsType = T;
+    using RhsType = U;
+    T lhs;
+    U rhs;
+};
+
+namespace Detail {
+
+template <typename T, typename = void>
+struct LocalVarCollector {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::enable_if_t<IsLocalVar_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::void_t<typename T::IsBinaryOp>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename LocalVarCollector<typename T::LhsType>::Type,
+        typename LocalVarCollector<typename T::RhsType>::Type>;
+};
+
+template <typename T, typename = void>
+struct ParamCollector {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct ParamCollector<T, std::enable_if_t<IsParam_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct ParamCollector<T, std::void_t<typename T::IsBinaryOp>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename ParamCollector<typename T::LhsType>::Type,
+        typename ParamCollector<typename T::RhsType>::Type>;
+};
+
+} // namespace Detail
+
+template <typename T>
+struct LocalVars {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::LocalVarCollector<T>::Type>;
+
+private:
+    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
+
+    template <typename U>
+    struct InRange
+        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
+    static_assert(Util::TMP::Check_v<InRange, Type>,
+                  "LocalVars must be numbered sequentially from 1");
+};
+
+template <typename T>
+using LocalVars_t = typename LocalVars<T>::Type;
+
+template <typename T>
+struct Params {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+
+private:
+    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
+
+    template <typename U>
+    struct InRange
+        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
+    static_assert(Util::TMP::Check_v<InRange, Type>,
+                  "Params must be numbered sequentially from 1");
+};
+
+template <typename T>
+using Params_t = typename Params<T>::Type;
+
+template <typename T>
+struct InParams {
+    template <typename U>
+    struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
+                                        U::usage == ParamUsage::in_out> {};
+    using Type = Util::TMP::Filter_t<IsInVar, Params_t<T>>;
+};
+
+template <typename T>
+using InParams_t = typename InParams<T>::Type;
+
+template <typename T>
+struct OutParams {
+    template <typename U>
+    struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
+                                         U::usage == ParamUsage::in_out> {};
+    using Type = Util::TMP::Filter_t<IsOutVar, Params_t<T>>;
+};
+
+template <typename T>
+using OutParams_t = typename OutParams<T>::Type;
+
+template <typename T, typename U>
+struct OpAssign : BinaryOp<T, U> {};
+
+template <typename T>
+template <typename U>
+[[nodiscard]] constexpr auto Expression<T>::operator=(Expression<U> u)
+{
+    static_assert(
+        (IsParam_v<T> || IsLocalVar_v<T> || std::is_lvalue_reference_v<T>),
+        "Only a Param, LocalVar, or reference can appear on the left side "
+        "of assignment");
+    return Expression<OpAssign<T, U>>{{data, u.data}};
+}
+
+template <typename T, typename U>
+struct OpAndThen : BinaryOp<T, U> {};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
+{
+    return Expression<OpAndThen<T, U>>{{t.data, u.data}};
+}
+
+// Disallow dangerous expressions like (Expression{2}, 3)
+template <typename T, typename U>
+constexpr auto operator,(Expression<T>t, U&& u) = delete;
+
+template <typename T, typename U>
+struct OpAdd : BinaryOp<T, U> {};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
+{
+    return Expression<OpAdd<T, U>>{{lhs.data, rhs.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(Expression<T> lhs, U&& rhs)
+{
+    return Expression<OpAdd<T, U>>{{lhs.data, std::forward<U>(rhs)}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(T&& lhs, Expression<U> rhs)
+{
+    return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
+}
+
+// Base class to express that a class is a maker of calculation expression template
+class Maker {};
+
+} // namespace ExprTmpl
+
+// NOLINTEND(misc-unconventional-assign-operator)
+// NOLINTEND(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
+
+
+/* Evaluation */
+
+namespace DemoEval {
+
+using Util::TMP::FindUnique_t;
+using Util::TMP::Size_v;
+
+using namespace ExprTmpl;
+
+// Primary template
+template <typename T>
+struct Evaluator {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(const T& value,
+                              ArgTup& args,
+                              LocalVarTup& localVars) const
+    {
+        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
+            return value(args, localVars);
+        } else {
+            return value;
+        }
+    }
+};
+
+template <std::size_t N, typename T>
+constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
+{
+    using ResultType = typename Evaluator<T>::Type;
+    return Expression<LocalVar<N, ResultType>>{};
+}
+
+namespace Detail {
+
+template <typename T, std::size_t... Ints>
+constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
+{
+    using LocalVars = typename LocalVars<T>::Type;
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              LocalVars>::Type{}...);
+}
+
+template <typename T>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename L, typename T, typename ArgTup>
+void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
+{
+    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
+    if constexpr (!std::is_same_v<typename L::Like, void>) {
+        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
+    }
+}
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup, std::size_t... Ints>
+void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
+                            std::index_sequence<Ints...>)
+{
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(std::get<Ints>(localVars), args), ...);
+}
+
+} // namespace Detail
+
+template <typename T>
+constexpr auto GetLocalVarTuple()
+{
+    using LocalVars = typename LocalVars<T>::Type;
+    constexpr auto localVarCount = Size_v<LocalVars>;
+    return Detail::GetLocalVarTupleImpl<T>(
+        std::make_index_sequence<localVarCount>{});
+};
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup>
+void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
+{
+    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
+        localVars, args,
+        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
+}
+
+template <typename T, typename... Args>
+auto Evaluate(const Expression<T>& expr, Args&&... args)
+{
+    // Declare local variables so that we can always use xTup& in
+    // Evaluator<>::operator()
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+    using LocalVars = LocalVars_t<T>;
+    [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
+    auto localVars = GetLocalVarTuple<T>();
+    MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
+    return Evaluator<T>{}(expr.data, argTuple, localVars);
+}
+
+// Treat Evaluator<Expression<T>> as Evaluator<T>
+template <typename T>
+struct Evaluator<Expression<T>> : Evaluator<T> {};
+
+// Partial specialization for LocalVar
+template <std::size_t N, typename T, typename L>
+struct Evaluator<LocalVar<N, T, L>> {
+    using Type = T&;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              ArgTup& /*args*/,
+                              LocalVarTup& localVars) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return std::get<N - 1>(localVars);
+    }
+};
+
+// Partial specialization for Param
+template <std::size_t N, typename T, ParamUsage U>
+struct Evaluator<Param<N, T, U>> {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+                              ArgTup& args,
+                              LocalVarTup& /*localVars*/) const
+    {
+        static_assert(N > 0, "Param number starts from 1");
+        static_assert(U == ParamUsage::in || std::is_reference_v<T>,
+                      "Only in-parameters can have value types");
+        constexpr auto index = N - 1;
+        using NthType =
+            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
+        if constexpr (std::is_same_v<T&, NthType> ||
+                      std::is_same_v<T&&, NthType>) {
+            return std::get<index>(args);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(std::get<index>(args));
+        }
+    }
+};
+
+template <typename T, typename U>
+void Assign(T& dst, const U& src)
+{
+    dst = src;
+}
+
+// Partial specializtion for E_y = E_x
+template <typename T, typename U>
+struct Evaluator<OpAssign<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Assign(Evaluator<T>{}(op.lhs, args, localVars),
+                      Evaluator<U>{}(op.rhs, args, localVars));
+    }
+};
+
+// Partial specializtion for E_x, E_y
+template <typename T, typename U>
+struct Evaluator<OpAndThen<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAndThen<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        // operator, evaluates sequentially
+        return Evaluator<T>{}(op.lhs, args, localVars),
+               Evaluator<U>{}(op.rhs, args, localVars);
+    }
+};
+
+template <typename T, typename U>
+auto Add(const T& src1, const U& src2)
+{
+    return src1 + src2;
+}
+
+template <typename T, typename U, typename V>
+void AddAssign(T& dst, const U& src1, const V& src2)
+{
+    dst = src1 + src2;
+}
+
+template <typename T>
+void AddAssign(std::vector<T>& dst,
+               const std::vector<T>& src1,
+               const std::vector<T>& src2)
+{
+    if (src1.size() != src2.size()) {
+        throw std::logic_error("vector sizes do not match");
+    }
+    if (src1.size() != dst.size()) {
+        throw std::logic_error("Destination vector should be like source");
+    }
+    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+// Partial specializtion for E_x + E_y
+template <typename T, typename U>
+struct Evaluator<OpAdd<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAdd<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Add(Evaluator<T>{}(op.lhs, args, localVars),
+                   Evaluator<U>{}(op.rhs, args, localVars));
+    }
+};
+
+// Partial specializtion for E_z = E_x + E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
+                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
+                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
+    }
+};
+
+} // namespace DemoEval
+
diff --git a/best_practices/atvos_demo/test/demo b/best_practices/atvos_demo/test/demo
new file mode 100755
index 0000000000000000000000000000000000000000..a5c0c3ee00f3768202cdb86ab15faf0e45e2f720
GIT binary patch
literal 71816
zcmeI1eQZ=$cEHcfGsa)Q7z{Y!!$X2r?6OS87!oICmGK7{s|H-+q+VL><$2~|&t|?f
z^9)0%6sL;XZM&*WNwa8olSNV00&Tj|D&1_QY->`fN>#N&OA_(N1`)JbMct@kHy^?(
zj(g61_t<aV%tZMk{iD*k=)QB$x#!%E-@Erd&*ka;BL~8v5O4~^tDv>!gf@9kfHxw`
zJ_+cBW=KF6Y=uVjYQW5X2~%Qu$AqzLLSIT2W{T?#lSVQ@Vo7e&8URb~o#YBr=ZS>T
zJb8VUr?LcZHu_0py>r*AzjL=w7g!c(K$yN|B*)S4C@!)<wIsbbmUCwOEO~x3H_BtC
zek`0ojr0Tw7}U>YNxqau-*Zz`j<;zQWkMHNj(BEZ$#K7faWu})n<B>XsOhgBmnOr5
zCBKIUGU<s2GO1mebZ)x5%eITjsR#GOO8Ho~H}4K?pF)QYKMrr@+Wz{xPw$+$vdP-_
zO8ZxT+Wf;OHqy9h4AdU^P$K`8x&%Pj=v7iZ&nt?mdA)FY_{kq*Ro(QjShKc9?KkS!
z&)2bk741>X!Spw1sMY>cb?h{cDCS_=f`(|&i28qEuGRj5I`)68W1p#GcZ~gbQvyrA
zq=v^1sgzT6CetO?DUKZ)$mDa*m_3nkK&i=WKBr2qU38TK?ONOM*x|?A-gLgCChU^4
zXE>L32fO#51a&Nx8AYKc%Vkw?iluzc&ZOPb>SP@2a;LKRtco1ak&ow2rE@8D)G1A8
zX(YJ*l4c}XJDo#IvTQ5cb;@ZMvQD<-xL{A@i!Pw&WYI26>9ODvB|{-&yC?F+tWoV!
z(#fTg8KV}bb8b58ux3yg)hQP9MU}O4_M}rZwn8y~!Y-tZHtDEjK1-x%_QvRSVQ2D_
z#*obx?20;-n$8xC1*hgDO}XTzk~?>z5_^z_PGj~;lSy<Vt()xRj`pE}0o4<W!@&4>
zU;nV`j`hIM$Z$WZXx`(M)$Ul&a<Tg%eEnhEeGRzVR-g>wKhi1l-Xq&3T*S0zqnJm(
zbh?#x`W3WMqKH{jA4mP#51+(ix)J`(*xWDw1s;tSyy^3Q)zne^D`%g_u2#TJWBZQQ
z!|*HPe|@o!+#rMp2cNN|-}KpA$gq_9bt#PgrU|V#!Lr>P&DtLE*_S>6SkvjV`@cI;
zpPd;|LpywS|2X45JD*|X-|MqClfk5f&yJv%(m|iyd?IvRSJZlI;mki@TCm{k?*lxy
zaOTRzIZM5L8*R4%Znu9rG#|P3=-Ftv>uvJojGy({_Hbf85(ZtT^+we1^XV<9_xtqK
zs89IxwW$B0Pv3z0OFsQx)L-}MTT#E|)9*t)99r)GOQ_%H=}Qx@Q&>3jPnSMyg?XCy
zI-E=C_0ZXy*1F68y}0<Dn>g<<+WL=&&cf}X`FGL&VQXT3;mqq7Z!IovWCmMc=4V?m
zzh}Yacdf+yt^48ZFR?xBau%*`KWkxK1LiB(=2grT*8|W&k{DAz@WIf00+;a|wo5i{
z8yDX!TnL@TKe1-Fp?nnJS9ADh0Itc|ZIJ`>HpbkxLYD#G3&jQfw*mb7eRrR}*4OsT
zpKZI_ckT-M<GP*g?>I0&p<}~KvD7E=AQr@gcpQJJ@8KDMy*F^&QJ6V;{H4&t%z*m)
z1&(*&%ug?UjQ$@T3F}yRe&*<(qCb3M9r+NMyuYdWM@^&Qc>s7BcN69?W(#uz<`tM5
zF|Wkjgt-}W3+7hLZJ1YKUX6JT<_P9?%xf{P!`y*+J?0IVH)8I@d=KV(F>k`W8S@s*
zTQPTGe&%b?fVl~C8|Db+4$PgHH)D=s-u}$jn#ORfIESy(98%#UAJH7F@Q?oAj2~I^
z9CqLw-nF{E62|#_jPvL~{ie14@&+wCjK1#jTCI0|<)b70_%3OU|BK%L6m!$+xZHyE
zxNbT;eck0o(@qmgZ{2uj2cH{sp4UpDP1bMG-=1`~&E8#HY`}$l6=e$b$im`c8D$*h
zEXw03{|e;=ls`dv73I%SzKL=K<0wTu0imakLPL3LXj5C4wsoRCh3)R6`o5K0>F-JU
zTTJ&!Hj^lR5c7HTjr(llSbl}$u^h#m!F-eb`c_9@Xn4`;KNmiD<DF}(u}b$#<Ng4B
z@Ux+le|(`o@W!_tYiNAW{*M{o;OgkXwk^?f4KFsn(3EQHiXL1I*KWMC*=qvlHac<?
zFuL{ozy6Ik@69yNUaY6KX0SiP-SmJ77+f76Y1<M%7k;kcFPmO$d7-VvdM(t}6(7N7
z-+b%FJA>XAVR13EL4Q!+3^jdV!Fj9c=N4SBj+<6Q2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwWK
z7eSyUp<9`2^5oTKPlmJ=;F^)F|01A&7|_GUk^Lh9y(^&i1oXau{zO2Z4Cuvx{%k;>
z4d_1z=$8Wet441#^Lk@tLYGz<y`jz1?=kwFyM4N}$><Ry?=`Y%!K>fQx{)7$x|pZp
z`EY^+tk6$@NJB!G8jU^|PUupLegb@A#@A}}P9xVF$-**)_ZPkX!$!YtWQUO}jofJD
z^~QuQvHhaan@oM&$YvwC|4$da`Rp+Mi$>>h+%|fnsW;*OXCh*_f8Gvmn)m!g$zZ?7
z&Hfr17<eSQW9abXUygRiV?D8M*d5=!cUQc3*Y4i2?mdshAAY2#cW1o!k$60s%-Fff
z=t-woO6POY?!B>iY%jG-??SILTnj^e+e1BeH-Oo<`;4sRGid6@Kf{OD`*p*kRy({0
zB4#gqmJj>Z^5H(1c`YCAqto;i<m%Tg2tjW+;Wz2B1z{MgX}6$U)84SOFa3>KxJ&11
z`Zq4^+e-hHP;0$g_y&2ORQfjq@3%^O3-G?Iw6_AkuS$CxFw;u=D&TXz(!Lt_JyqJ*
zKrQYTuD*DU_hCUh%+$26h1XUk{7vh!1?zy%Pk*Ha9l+;irF}ir+Se9rfUD-5tMuOp
zeEwD1J7E<1{U%+u;2xN&Y3I|tGQ@&SFca{n<GBHTy;$k#?OA~8_121xA)h^J0=@Gb
zzdB~Ga(mu+y9)LM?6h|P`9Bxn@7b&0Be$QZ)6T^}JKM4KTJz#|_-xU`z{gI^VORxh
z=kJZ@U%hTUd-Xc({mgz_fzJ@`m)qfUgYDm})6S#XVHGsAB-mBULH(>=w@=iu{~p?D
zzP!KoX+MCHmdkcyhB6jHxZVn8{g}@>{IPaewzL1YbzvPq;JbEK+dJWSU>!cM?f2q}
zs7&9}YCA*&`|$$WKkNM-53G~FMSq%a(EhTq&j$Rxb=V2xfpN|mfBw4@Rh{0(C-LF^
z$b7tZs?Ud8+P~V~jDa*x2)tjfo$B*vJ^F`goJ*en8i)q=g=cSvxtjLn@q4oZxPXOP
zoVlH!1m4RYJ)U+5+Nr%-?euH^>ho}1+pEt{8}0PhMDRTK_EGhB#6|yY;pO$_jT@i~
zTUm>om-dnQgY(-c$<F5(?+g07d~LXTzduiQ8d4x#M0*6+L-4$PxsLyw@#po!&HZN`
z|8L<qqfq@_cn|&CalXNI`x~@Jxlx~N!**(ovjgqzuzU_Tn3(%DA72Ben5fgv2(^Rb
z3C?T0PCMU3d$hWF_#@qZ^?c81d-b~gL7jH~-n0`O&p)7@-Xs6r%R_j}*jZ=!%R2TJ
z`~lI9@4al!4PI{>(7rZY{T<m%c5c)s_h|oBz~4LOKT^lPPtU7*y+N|*cE|FtJq1eH
z6KUnzld!#v%BiAVP+2>jBbPL~B<)N_opS6a)d_9OQCK+^2mB47oO04BxEMW=apKq-
z{t!?@BS-rCMwBW|PpDztR4iF2P|R*n#~yP>dX-A&)48-u0X_8CLyx`mc#s|sQQswZ
z`oxJ?5>iglnM{{lr>NYlN@nsor-b87<<(>+KVfH7%FP!`%APJmGM_DE9M?(V=xTbX
z6WFb?i$(jia&m6*G@K~fSx2R&v)R)a;?ooju)<ZT14sJ~?N|E`4=S}Z%_9d6Jhp#K
zjrH}9>__Y1*AMp{8Xmy5@W+wbf6&An96SnxzZ)w$Ct^xXmdmPuKZo);JCk-#tCKid
z8W?1qY{_vGLnFie18R4y`ys$l;u|`a%8Z`$%;V##2XQGiQ7WmDYZqM_%j3CI>0C-3
zbxPA&CqXZ!$3sxct0_B|$~d5g#||kbId*7(IF8Y4!?v&!YGwEcwwOxi)O5+Ab&*L=
zBuyW*AeP3}!~L5$h0QUQW4Tk=%8^pP%kMDIbINvYuM7W_usoT~=a%Q^kRMsA$R!5G
z$NTz+RW~jqdm>+~q<8G_V{UIcUs4lx$=NfEZ*;JGe<jID<)$;~+~jXNxB%##V>ijN
zt!&pRrz=}aWe{K{pTsH}nww6lLK^v1_c9Rd1!ASsS==Qk-J&O_xRlP}+AcsWmv^1m
zWNtb(F`dq&cBNCsgwxwa+f&y~*`+CnrB3ItJx{ttug3hqu22-#;gD?#Fr`Aqg_xda
z3}=XCz4Btkyha>zrpzXoN?|N(*l03YvDv*gy#3*|!DZ~q&Zd(XlE>EZ5z}3I&Eu+t
z7;e)n?mlm%da^Owb&KhVX&1Nl7n0~63qNi6H<Ooo!wFsJH3q)t@@hR_E|a_;Gu<6=
zJpb+<GluQt<V$=Gv*|%B_~Xmrgsv)^_^8&FAHn!Rtoj7+nz;Y-;e>WRALyU&+xUB;
zo$zrOb1P<!p9?2Y1N_~u1&k6LOmsg-MUL+zBPRNNfS;75c)rhzn1S;B9r;o+&3Otw
zzk!+V&bWWRKWH=;f_#t2<7YpXPhvdX#j(!!3_DEx4AxU3mBz{ACmW@wFw;;up6??r
zns~nd<Ni6G=l`sU??*|A?=7yIc)ow6c)D{8#{W6mh>3Auy5D%iTu5?1=%SOs$}0Q`
zmi+O24|3DQ&n<a+1$~d^vpt7pe?0%5n==C)Bxt^r@Rh0fUCjP?zE^257s~uQn8SkO
zzhL5-Ki|J}n)u-SnIE@zF%Zvx*T+r#2s;`X?ElAsc)rh>G4cCoa=sMoe-7)&g~!kL
zKCj_V07|@mJ<VHdTqgN5%&RdoX1*V~bC+t(y{A{yPwt=P4YaPo%<+7W)U@CQv7e_c
zuRpf`7gq4zARoSOikNsl2Y7vQ9Iqq#{}7r#_s{oISIv!3z4yoM+zG_<{nh&>ehTaT
ziQ`y?uycR^e9twit$@F9Dig=CbtMLqjmOV_*H3-U_%_o&pA+0J$M><pNE$08mh}7E
zY*lUN-+O;&Jj^oCb@T|XUuuWf-jWj*E)p0_Gv+^1wqSV_GtZy7(En@j+_AWncF@Ey
b6#|u>b;(WNw**{t<@q(9=gvStK!yJWYx{<@

literal 0
HcmV?d00001

diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
new file mode 100644
index 000000000..ac90cdf7d
--- /dev/null
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -0,0 +1,44 @@
+#include <cstddef>
+#include <iostream>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <kernel_operator.h>
+#include "../include/utils/expression/expression.h"
+#include "../include/kernel/kernel_elewise.h"
+#include "../include/device/device_elewise.h"
+
+
+
+using namespace ATVOS;
+using namespace ExprTmpl;
+
+描述计算逻辑
+struct MyAddOp : ATVC::ExprTmpl::Maker {
+template <typename <typename> class VectorType>
+constexpr auto Get() const
+{
+using namespace ATVC::ExprTmpl;
+auto _1 = DefinePlaceholder<1, VectorType<float>>();
+auto _2 = DefinePlaceholder<2, VectorType<float>>();
+auto _3 = DefinePlaceholder<3, VectorType<float>, VarUsage::out>();
+return (_3 = _1 + _2);
+}
+};
+
+// template<class KernelOp>
+// __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
+// {
+//     KernelOp op;
+//     op.Run(configDevice, x, y, z);
+// }
+
+int main() {
+    std::vector<float> v1(300, 1.0F);
+    std::vector<float> v2(300, 2.0F);
+    std::vector<float> v3(300);
+    ATVC::Device::DoElementwise<float>(MyAddOp{}, v1, v2, v3); // 完成 core num计算 kernel launch
+    return 0;
+}
\ No newline at end of file
-- 
Gitee


From 08ec71f2e3055a43e82b77829cd74c52abd0d57d Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Thu, 11 Sep 2025 15:39:13 +0800
Subject: [PATCH 013/116] fix compile err

---
 .../atvos_demo/include/block/block_elewise.h  | 125 +++--
 .../include/device/device_elewise.h           | 142 ++++--
 .../atvos_demo/include/device/device_vector.h |  58 ---
 .../include/device/device_vector_impl.h       |  31 --
 .../include/kernel/kernel_elewise.h           |  86 +++-
 .../atvos_demo/include/tile/tile_elewise.h    |  27 +-
 .../include/utils/expression/expression.h     | 460 +-----------------
 best_practices/atvos_demo/test/main.cpp       |  37 +-
 8 files changed, 295 insertions(+), 671 deletions(-)
 delete mode 100644 best_practices/atvos_demo/include/device/device_vector.h
 delete mode 100644 best_practices/atvos_demo/include/device/device_vector_impl.h

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index 8f583b719..4d135c3dd 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -1,43 +1,94 @@
 namespace ATVC::Block {
 
-template <
-    typename T, typename ExprMaker, typename ArgTup,
-    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
-void DoElementwise(const Config& configBlock, ArgTup& argTuple)
-{
-    // 配置规划，特别是需要确定使用的 Local Memory 大小
-    Tile::Config configTile = MakeConfig<ExprMaker>(configBlock, argTuple);
-
-    auto expr = maker.Get<LocalTensor<T>>();
-    using Expr = decltype(expr);
-    using LocalVars = ExprTmpl::LocalVars_t<Expr>;
-    using Params = ExprTmpl::Params_t<Expr>;
-    using InParams = ExprTmpl::InParams_t<Expr>;
-    using OutParams = ExprTmpl::OutParams_t<Expr>;
-
-    // 得到 tuple<LocalTensor, ...>，向量变成了 LocalTensor 类型
-    auto params = PrepareParams<Params>(configTile);
-    // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
-    auto inParams = PrepareInParams<InParams>(params);
-    auto outParams = PrepareOutParams<InParams>(params);
-    // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
-    auto localVars = PrepareLocalVars<LocalVars>(params);
-
-    // 把 argTuple 里的向量替换成 params 里的对应 Tensor
-    auto combinedArgs = CombineArgs(params, argTuple);
-
-    // 循环执行
-    for (int i = 0; i < configTile.wholeBlockCount; ++i) {
-        CopyIn<InParams>(inParams, argTuple);
-        Tile::Evaluate<Expr>(combinedArgs, localVars);
-        CopyOut<OutParams>(outParams, argTuple);
+struct Config {// block层的切分信息
+    uint32_t wholeBlockCount = 0;
+    uint32_t tileBlockCount = 0;
+    uint32_t basicNum = 0;
+};
+
+template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
+class BlockEleWise{
+public: 
+    BlockEleWise(){}
+
+    template <typename ArgTup>
+    Tile::Config MakeConfig(const Config& configBlock, ArgTup& argTuple)
+    {
+        Tile::Config configTile{12, 1, 2048};
     }
-    // 尾块的处理
-    for (int i = 0; i < configTile.tileBlockCount; ++i) {
-        CopyIn<InParams>(inParams, argTuple);
-        Tile::Evaluate<Expr>(combinedArgs, localVars);
-        CopyOut<OutParams>(outParams, argTuple);
+
+    template <typename ArgTup>
+    int64_t Run(const Config& configBlock, ArgTup& argTuple)
+    {
+        // 配置规划，特别是需要确定使用的 Local Memory 大小
+        Tile::Config configTile = MakeConfig(configBlock, argTuple);
+        auto expr = ExprMaker::template Get<AscendC::LocalTensor>();
+        using Expr = decltype(expr);
+        using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>;
+        using Params = ATVC::ExprTmpl::Params_t<Expr>;
+        using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
+        using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+
+        // 得到 tuple<LocalTensor, ...>，向量变成了 LocalTensor 类型
+        auto params = PrepareParams<Params>(configTile);
+        // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
+        auto inParams = PrepareInParams<InParams>(params);
+        auto outParams = PrepareOutParams<InParams>(params);
+        // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
+        auto localVars = PrepareLocalVars<LocalVars>(params);
+
+        // 把 argTuple 里的向量替换成 params 里的对应 Tensor
+        auto combinedArgs = CombineArgs(params, argTuple);
+
+        // 循环执行
+        for (int i = 0; i < configTile.wholeBlockCount; ++i) {
+            CopyIn<InParams>(inParams, argTuple);
+            Tile::Evaluate<Expr>(combinedArgs, localVars);
+            CopyOut<OutParams>(outParams, argTuple);
+        }
+        // 尾块的处理
+        for (int i = 0; i < configTile.tileBlockCount; ++i) {
+            CopyIn<InParams>(inParams, argTuple);
+            Tile::Evaluate<Expr>(combinedArgs, localVars);
+            CopyOut<OutParams>(outParams, argTuple);
+        }
     }
-}
+};
+// void DoElementwise(ExprMaker maker, const Config& configBlock, ArgTup& argTuple)
+// {
+//     // 配置规划，特别是需要确定使用的 Local Memory 大小
+//     Tile::Config configTile = MakeConfig<ExprMaker>(configBlock, argTuple);
+
+//     auto expr = maker.template Get<AscendC::LocalTensor<T>>();
+//     using Expr = decltype(expr);
+//     using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>;
+//     using Params = ATVC::ExprTmpl::Params_t<Expr>;
+//     using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
+//     using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+
+//     // 得到 tuple<LocalTensor, ...>，向量变成了 LocalTensor 类型
+//     auto params = PrepareParams<Params>(configTile);
+//     // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
+//     auto inParams = PrepareInParams<InParams>(params);
+//     auto outParams = PrepareOutParams<InParams>(params);
+//     // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
+//     auto localVars = PrepareLocalVars<LocalVars>(params);
+
+//     // 把 argTuple 里的向量替换成 params 里的对应 Tensor
+//     auto combinedArgs = CombineArgs(params, argTuple);
+
+//     // 循环执行
+//     for (int i = 0; i < configTile.wholeBlockCount; ++i) {
+//         CopyIn<InParams>(inParams, argTuple);
+//         Tile::Evaluate<Expr>(combinedArgs, localVars);
+//         CopyOut<OutParams>(outParams, argTuple);
+//     }
+//     // 尾块的处理
+//     for (int i = 0; i < configTile.tileBlockCount; ++i) {
+//         CopyIn<InParams>(inParams, argTuple);
+//         Tile::Evaluate<Expr>(combinedArgs, localVars);
+//         CopyOut<OutParams>(outParams, argTuple);
+//     }
+// }
 
 } // namespace ATVC::Block
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index efdf16513..459dfcb9b 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -24,6 +24,7 @@ void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
     CHECK_ACL(aclFinalize());
 }
 
+
 template<class KernelOp, class... Args>
 __global__ __aicore__ void MyKernel(GM_ADDR configDevice, Args... args)
 {
@@ -33,65 +34,110 @@ __global__ __aicore__ void MyKernel(GM_ADDR configDevice, Args... args)
 
 namespace ATVC::Device {
 
-template<class KernelOp, class... Args>
-void LaunchKernelWithDataTuple(uint32_t blockNum, uint8_t* configDevice, Args... args)
+template <typename T>
+struct Tensor {
+    T* ptr;
+    uint64_t len; // 元素个数
+};
+
+template <typename Params>
+std::vector<Tensor<float>> PrepareParams() {
+    std::vector<Tensor<float>> params{};
+    return params;
+}
+
+template <typename InParams>
+std::vector<Tensor<float>> PrepareInParams(std::vector<Tensor<float>>& params)
+{
+    std::vector<Tensor<float>> inParams{};
+    return inParams;
+}
+
+template <typename OutParams>
+std::vector<Tensor<float>> PrepareOutParams(std::vector<Tensor<float>>& params)
+{
+    std::vector<Tensor<float>> outParams{};
+    return outParams;
+}
+
+template<class KernelOp, typename ArgTup>
+void LaunchKernelWithDataTuple(uint32_t blockNum, uint8_t* configDevice, ArgTup& argTuple)
 {
     aclrtContext context;
     int32_t deviceId = 0;
     aclrtStream stream = nullptr;
     InitializeACL(context, stream, deviceId);
-    MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, args...);
+    MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, argTuple);
     CleanACL(stream, context, deviceId);
 }
+
+void ClearTensors(std::vector<Tensor<float>> params)
+{
+    return;
+}
+
+    
 /*
 ExprMaker maker: 描述计算表达信息
 Args&&... args： 输入输出信息
 */
-template <
-    typename T, typename ExprMaker, typename... Args,
-    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
-void DoElementwise(ExprMaker maker, Args&&... args)
+template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
+class DeviceEleWise
 {
-    // 配置规划
-    auto config = MakeConfig(maker, std::forward<Args>(args)...);
-
-    auto expr = maker.template Get<Tensor<T>>(); // Tensor 为表达 Device 层向量的类型
-    using Expr = decltype(expr);
-    static_assert(!Expr::hasData, "设备侧使用的表达式模板不应包含数据")
-    using Params = ExprTmpl::Params_t<Expr>;
-    using InParams = ExprTmpl::InParams_t<Expr>;
-    using OutParams = ExprTmpl::OutParams_t<Expr>;
-
-    // 得到 tuple<Tensor, ...>，向量变成了 Device 专用的 Tensor 类型
-    auto params = PrepareParams<Params>();
-    // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
-    auto inParams = PrepareInParams<InParams>(params);
-    auto outParams = PrepareOutParams<InParams>(params);
-
-    // 参数打包成 tuple
-    auto argTuple = std::forward_as_tuple(std::forward<Args>(args...));
-
-    // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
-    CopyIn<InParams>(inParams, argTuple);
-
-    // 把 config 复制到 GM
-    uint8_t* configDevice;
-    CopyConfig(config, configDevice);
-
-    // 把 argTuple 里的向量替换成 params 里的对应 Tensor
-    auto combinedArgs = CombineArgs(params, argTuple);
-    // 传递参数到设备侧执行
-    LaunchKernelWithDataTuple<Kernel::DoElementwise<T, ExprMaker>>(config.blockNum, configDevice, argTuple);
-
-    // 同步，等待执行结束
-    WaitForCompletion();
-
-    // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
-    CopyOut<OutParams>(outParams, argTuple);
-
-    // Tensor 和 configDevice 需手工清理
-    ClearConfig(configDevice);
-    ClearTensors(params);
-}
+public:
+    DeviceEleWise(){};
+
+    // 计算kernel切分策略
+    Kernel::Config MakeConfig() {
+        Kernel::Config configBlock{1, 1024*10};
+        return configBlock;
+    }
+
+    template <typename... Args>
+    int64_t Run(Args... args)
+    {
+        // 配置规划
+        auto config = MakeConfig();
+        auto expr = ExprMaker{}.template Get<Tensor>(); // Tensor 为表达 Device 层向量的类型
+        using Expr = decltype(expr);
+        // static_assert(!Expr::hasData, "设备侧使用的表达式模板不应包含数据");
+        using Params = ATVC::ExprTmpl::Params_t<Expr>;
+        using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
+        using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+
+        // 得到 tuple<Tensor, ...>，向量变成了 Device 专用的 Tensor 类型
+        auto params = PrepareParams<Params>();
+        // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
+        auto inParams = PrepareInParams<InParams>(params);
+        auto outParams = PrepareOutParams<OutParams>(params);
+
+        // 参数打包成 tuple
+        auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+
+        // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
+        CopyIn<InParams>(inParams, argTuple);
+
+        // 把 config 复制到 GM
+        uint8_t* configDevice;
+        // CopyConfig(config, configDevice);
+
+        // 把 argTuple 里的向量替换成 params 里的对应 Tensor
+        auto combinedArgs = CombineArgs(params, argTuple);
+        auto totalArgs = std::tuple_cat(std::tuple(config.blockNum, configDevice), argTuple);
+        // 传递参数到设备侧执行
+        // std::apply([](auto&&... tuple2args) {
+        //     LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(tuple2args...);
+        // }, totalArgs);
+        LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, configDevice, argTuple);
+
+        // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
+        CopyOut<OutParams>(outParams, argTuple);
+
+        // Tensor 和 configDevice 需手工清理
+        // ClearConfig(configDevice);
+        ClearTensors(params);
+        return 0;
+    }
+};
 
 } // namespace ATVC::Device
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_vector.h b/best_practices/atvos_demo/include/device/device_vector.h
deleted file mode 100644
index 7dbabaeda..000000000
--- a/best_practices/atvos_demo/include/device/device_vector.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef _DEVICE_VECTOR_H_
-#define _DEVICE_VECTOR_H_
-
-#include "../dfx/check.h"
-
-
-namespace ATVOS {
-
-
-using Stream = int*;
-
-/**
- * @brief 
- * 
- * @tparam OpTraits_    需要的Layout 信息
- * @tparam KernelOp     kernel 的入口
- * @tparam Policy       策略: 决策KernelOp的处理策略， 例如：Reduce 时分解为2个OpKernel， 前一个OpKernel 处理Reduce 到workspace,  后一个OpKernel 从workspace 到gm
- * @tparam Enable 
- */
-template<class KernelOp, class Policy_=void, class Schedule =void, class Enable=void>
-class DeviceAdapt {
-public: 
-    using OpTraits  = std::conditional_t<std::is_same_v<OpTraits_,void>, typename KernelOp::OpTraits, OpTraits_>;
-    using Arguments = std::conditional_t<std::is_same_v<OpTraits_,void>, typename KernelOp::Arguments, ArgumentsBase<OpTraits_>>;
-    using Policy    = std::conditional_t<std::is_same_v<Policy_, void>, typename KernelOp::Policy, Policy_>;
-public:   
-    static_assert( Dfx::IsTupleV<OpTraits>, "OpTraits_ is std::tuple");
-public:
-    DeviceAdapt(){};
-
-    bool CanImplement(Arguments& arg); //检查参数的合法性
-    int64_t GetWorkspaceSize(Arguments& arg); 
-    int64_t Run(Arguments& args, Policy* policy=nullptr, Stream stream = nullptr);
-
-}; 
-
-#include "device_vector_impl.h"
-
-
-
-
-} // ATVOS
-
-
-     
-#endif //_DEVICE_VECTOR_H_
- 
-
-
-
-
-
-
-
-
-
-
- 
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_vector_impl.h b/best_practices/atvos_demo/include/device/device_vector_impl.h
deleted file mode 100644
index 3b52be84e..000000000
--- a/best_practices/atvos_demo/include/device/device_vector_impl.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef __ATVOS_DEVECOR_VECTOR_IMPPL_H_
-#define __ATVOS_DEVECOR_VECTOR_IMPPL_H_
-
-
-
-template<class KernelOp, class OpTraits_,  class Policy_, class Schedule, class Enable>
-bool DeviceAdapt<KernelOp, OpTraits_,  Policy_, Schedule, Enable>::CanImplement(Arguments& arg){
-    //检查KernelOp 的In,out 是否进行了 gm 地址的赋值
-    return 0;
-};
-template<class KernelOp, class OpTraits_, class Policy_, class Schedule, class Enable>
-int64_t DeviceAdapt< KernelOp, OpTraits_, Policy_, Schedule, Enable>::GetWorkspaceSize(Arguments& arg)
-{
-    return 0;
-}; 
-
-template<class KernelOp, class OpTraits_, class Policy_, class Schedule, class Enable>
-int64_t DeviceAdapt<KernelOp, OpTraits_,  Policy_, Schedule, Enable>::Run(Arguments&  arg, Policy* policy, Stream stream){
-    //构建Kernel 对象，然后调用 
-    KernelOp op;
-     
-    op.Run(arg, nullptr);
-    return 0;
-};
-
-
-
-
-
-#endif //__ATVOS_DEVECOR_VECTOR_IMPPL_H_
-
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index bb90d658c..30c7110cc 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -1,28 +1,68 @@
 namespace ATVC::Kernel {
+struct Config{ // kernel 层的切分信息
+    uint32_t blockNum = 1;
+    uint32_t basicNum = 0;
+};
 
-template <
-    typename T, typename ExprMaker, typename... Args,
-    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
-void DoElementwise(uint8_t* configKernel, Args... args)
-{
-    // 配置规划
-    Block::Config configBlock = MakeConfig<ExprMaker>(configKernel, args...);
-
-    auto expr = maker.Get<GlobalTensor<T>>();
-    using Expr = decltype(expr);
-    using Params = ExprTmpl::Params_t<Expr>;
-    using InParams = ExprTmpl::InParams_t<Expr>;
-    using OutParams = ExprTmpl::OutParams_t<Expr>;
-
-    // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
-    // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
-    auto params = PrepareParams<Params>(args...);
-
-    // 执行计算
-    // 循环执行
-    for (int i = 0; i < configKernel.wholeBlockCount; ++i) {
-        Block::DoElementwise<T, Maker>(configBlock, params);
+template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
+class KernelEleWise{
+public:
+    KernelEleWise(){};
+    // 计算block切分策略
+    Block::Config MakeConfig(GM_ADDR configKernel) {
+        Block::Config configBlock{10, 1, 1024};
+        return configBlock;
     }
-}
+    // 运行接口
+    template <typename... Args>
+    int64_t Run(GM_ADDR configKernel, Args... args)
+    {
+        // 配置Block层切分策略
+        Block::Config configBlock = MakeConfig(configKernel);
+
+        auto expr = ExprMaker::template Get<AscendC::GlobalTensor>();
+        using Expr = decltype(expr);
+        using Params = ATVC::ExprTmpl::Params_t<Expr>;
+        using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
+        using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+
+        // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
+        // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
+        auto params = PrepareParams<Params>(args...);
+
+        // 执行计算
+        // 循环执行
+        Block::BlockEleWise<ExprMaker> blockOp;
+        for (int i = 0; i < configBlock.wholeBlockCount; ++i) {
+            blockOp.Run(configBlock, params);
+        }
+        // 尾块
+        for (int i = 0; i < configBlock.tileBlockCount; ++i) {
+            blockOp.Run(configBlock, params);
+        }
+    }
+};
+
+// void DoElementwise(ExprMaker maker, uint8_t* configKernel, Args... args)
+// {
+//     // 配置规划
+//     Block::Config configBlock = MakeConfig<ExprMaker>(configKernel, args...);
+
+//     auto expr = maker.Get<GlobalTensor<T>>();
+//     using Expr = decltype(expr);
+//     using Params = ATVC::ExprTmpl::Params_t<Expr>;
+//     using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
+//     using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+
+//     // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
+//     // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
+//     auto params = PrepareParams<Params>(args...);
+
+//     // 执行计算
+//     // 循环执行
+//     for (int i = 0; i < configKernel.wholeBlockCount; ++i) {
+//         Block::DoElementwise<T, Maker>(configBlock, params);
+//     }
+// }
 
 } // namespace ATVC::Kernel
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
index f3ae0eb98..4b59147c4 100644
--- a/best_practices/atvos_demo/include/tile/tile_elewise.h
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -1,9 +1,34 @@
+#include "tile_evaluator_common.h"
+
+
 namespace ATVC::Tile {
 
+struct Config {//tile层的切分信息
+    uint32_t wholeBlockCount = 0;
+    uint32_t tileBlockCount = 0;
+    uint32_t basicNum = 0;
+};
+
+template <typename T>
+void AddAssign(std::vector<T>& dst,
+               const std::vector<T>& src1,
+               const std::vector<T>& src2)
+{
+    if (src1.size() != src2.size()) {
+        throw std::logic_error("vector sizes do not match");
+    }
+    if (src1.size() != dst.size()) {
+        throw std::logic_error("Destination vector should be like source");
+    }
+    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
+        // dst[i] = src1[i] + src2[i];
+    }
+}
+
 template <typename Expr, typename ArgTup, typename LocalVarTup>
 void Evaluate(ArgTup& args, LocalVarTup& localVars)
 {
-    Evaluator<Expr::Type>{}(args, localVars);
+    DemoEval::Evaluator<typename Expr::Type>{}(args, localVars);
 }
 
 } // namespace ATVC::Tile
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/utils/expression/expression.h b/best_practices/atvos_demo/include/utils/expression/expression.h
index e9e65c7ba..8ecea0222 100644
--- a/best_practices/atvos_demo/include/utils/expression/expression.h
+++ b/best_practices/atvos_demo/include/utils/expression/expression.h
@@ -5,209 +5,7 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
-
-
-/* Utilities */
-
-namespace Util {
-
-template <typename T>
-struct AlwaysFalse : std::false_type {};
-
-template <typename T>
-inline constexpr bool AlwaysFalse_v = AlwaysFalse<T>::value;
-
-template <template <typename...> class T, typename U>
-struct IsSpecializationOf : std::false_type {};
-
-template <template <typename...> class T, typename... Us>
-struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
-
-template <template <typename...> class T, typename U>
-inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
-
-namespace TMP {
-
-template <typename... Ts>
-struct TypeList {};
-
-template <typename List>
-struct First;
-
-template <typename Head, typename... Tail>
-struct First<TypeList<Head, Tail...>> {
-    using Type = Head;
-};
-
-template <typename List>
-using First_t = typename First<List>::Type;
-
-template <typename List>
-struct Size;
-
-template <typename... Ts>
-struct Size<TypeList<Ts...>> {
-    static constexpr std::size_t value = sizeof...(Ts);
-};
-
-template <typename List>
-inline constexpr std::size_t Size_v = Size<List>::value;
-
-template <typename T, typename List>
-struct Prepend;
-
-template <typename T, typename... Ts>
-struct Prepend<T, TypeList<Ts...>> {
-    using Type = TypeList<T, Ts...>;
-};
-
-template <typename T, typename List>
-using Prepend_t = typename Prepend<T, List>::Type;
-
-template <typename... Lists>
-struct Concatenate;
-
-template <>
-struct Concatenate<> {
-    using Type = TypeList<>;
-};
-
-template <typename... Ts>
-struct Concatenate<TypeList<Ts...>> {
-    using Type = TypeList<Ts...>;
-};
-
-template <typename... Ts, typename... Us>
-struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
-    using Type = TypeList<Ts..., Us...>;
-};
-
-template <typename List1, typename List2, typename List3, typename... Lists>
-struct Concatenate<List1, List2, List3, Lists...> {
-    using Type =
-        typename Concatenate<typename Concatenate<List1, List2>::Type,
-                             List3, Lists...>::Type;
-};
-
-template <typename... Lists>
-using Concatenate_t = typename Concatenate<Lists...>::Type;
-
-template <template <typename> class Pred, typename List>
-struct Check;
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Check<Pred, TypeList<Head, Tail...>> {
-    static constexpr bool value =
-        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
-};
-
-template <template <typename> class Pred>
-struct Check<Pred, TypeList<>> {
-    static constexpr bool value = true;
-};
-
-template <template <typename> class Pred, typename List>
-inline constexpr bool Check_v = Check<Pred, List>::value;
-
-template <template <typename> class Pred, typename List, typename = void>
-struct Find;
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Find<Pred, TypeList<Head, Tail...>,
-            std::enable_if_t<Pred<Head>::value>> {
-    using Type = Head;
-};
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Find<Pred, TypeList<Head, Tail...>,
-            std::enable_if_t<!Pred<Head>::value>>
-    : Find<Pred, TypeList<Tail...>> {};
-
-template <template <typename> class Pred>
-struct Find<Pred, TypeList<>, void> {
-    static_assert(AlwaysFalse_v<Pred<void>>,
-                  "Cannot find the specified element");
-};
-
-template <template <typename> class Pred, typename List>
-using Find_t = typename Find<Pred, List>::Type;
-
-template <template <typename> class Pred, typename List>
-struct Filter;
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Filter<Pred, TypeList<Head, Tail...>> {
-    using Type = typename std::conditional_t<
-        Pred<Head>::value,
-        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
-        typename Filter<Pred, TypeList<Tail...>>::Type>;
-};
-
-template <template <typename> class Pred>
-struct Filter<Pred, TypeList<>> {
-    using Type = TypeList<>;
-};
-
-template <template <typename> class Pred, typename List>
-using Filter_t = typename Filter<Pred, List>::Type;
-
-template <typename List, std::size_t N>
-struct Get;
-
-template <typename Head, typename... Tail, std::size_t N>
-struct Get<TypeList<Head, Tail...>, N> {
-    using Type = typename Get<TypeList<Tail...>, N - 1>::Type;
-};
-
-template <typename Head, typename... Tail>
-struct Get<TypeList<Head, Tail...>, 0> {
-    using Type = Head;
-};
-
-template <std::size_t N>
-struct Get<TypeList<>, N> {
-    static_assert(N < 0, "Index out of bounds in Get");
-};
-
-template <typename List, std::size_t N>
-using Get_t = typename Get<List, N>::Type;
-
-template <typename List>
-struct Unique;
-
-template <typename Head, typename... Tail>
-struct Unique<TypeList<Head, Tail...>> {
-    template <typename T>
-    struct IsNotHead : std::bool_constant<!std::is_same_v<T, Head>> {};
-
-    using Type = Prepend_t<
-        Head,
-        typename Unique<Filter_t<IsNotHead, TypeList<Tail...>>>::Type>;
-};
-
-template <>
-struct Unique<TypeList<>> {
-    using Type = TypeList<>;
-};
-
-template <typename List>
-using Unique_t = typename Unique<List>::Type;
-
-template <template <typename> class Pred, typename List>
-struct FindUnique {
-    using ResultList = Filter_t<Pred, List>;
-    static_assert(Size_v<ResultList> != 0, "Cannot find the specified element");
-    static_assert(Size_v<ResultList> == 1, "A unique result is expected");
-    using Type = First_t<ResultList>;
-};
-
-template <template <typename> class Pred, typename List>
-using FindUnique_t = typename FindUnique<Pred, List>::Type;
-
-} // namespace TMP
-
-} // namespace Util
-
+#include "utility.h"
 
 /* Expression templates */
 
@@ -215,7 +13,7 @@ using FindUnique_t = typename FindUnique<Pred, List>::Type;
 // NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature)
 // NOLINTBEGIN(misc-unconventional-assign-operator)
 
-namespace ExprTmpl {
+namespace ATVC::ExprTmpl {
 
 using Util::TMP::TypeList;
 
@@ -488,258 +286,16 @@ template <typename T, typename U>
     return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
 }
 
-// Base class to express that a class is a maker of calculation expression template
-class Maker {};
-
-} // namespace ExprTmpl
-
-// NOLINTEND(misc-unconventional-assign-operator)
-// NOLINTEND(cppcoreguidelines-c-copy-assignment-signature)
-// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
-
-
-/* Evaluation */
-
-namespace DemoEval {
-
-using Util::TMP::FindUnique_t;
-using Util::TMP::Size_v;
-
-using namespace ExprTmpl;
-
-// Primary template
-template <typename T>
-struct Evaluator {
-    using Type = T;
-
-    template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(const T& value,
-                              ArgTup& args,
-                              LocalVarTup& localVars) const
-    {
-        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
-            return value(args, localVars);
-        } else {
-            return value;
-        }
-    }
-};
-
-template <std::size_t N, typename T>
-constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
-{
-    using ResultType = typename Evaluator<T>::Type;
-    return Expression<LocalVar<N, ResultType>>{};
-}
-
-namespace Detail {
-
-template <typename T, std::size_t... Ints>
-constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
-{
-    using LocalVars = typename LocalVars<T>::Type;
-    return std::make_tuple(
-        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
-                              LocalVars>::Type{}...);
-}
-
-template <typename T>
-void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
-{
-    dst.resize(src.size());
-}
-
-template <typename L, typename T, typename ArgTup>
-void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
-{
-    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
-    if constexpr (!std::is_same_v<typename L::Like, void>) {
-        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
-    }
-}
-
-template <typename LocalVars, typename LocalVarTup, typename ArgTup, std::size_t... Ints>
-void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
-                            std::index_sequence<Ints...>)
-{
-    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(std::get<Ints>(localVars), args), ...);
-}
-
-} // namespace Detail
-
-template <typename T>
-constexpr auto GetLocalVarTuple()
-{
-    using LocalVars = typename LocalVars<T>::Type;
-    constexpr auto localVarCount = Size_v<LocalVars>;
-    return Detail::GetLocalVarTupleImpl<T>(
-        std::make_index_sequence<localVarCount>{});
-};
-
-template <typename LocalVars, typename LocalVarTup, typename ArgTup>
-void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
-{
-    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
-        localVars, args,
-        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
-}
-
-template <typename T, typename... Args>
-auto Evaluate(const Expression<T>& expr, Args&&... args)
-{
-    // Declare local variables so that we can always use xTup& in
-    // Evaluator<>::operator()
-    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
-    using LocalVars = LocalVars_t<T>;
-    [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
-    auto localVars = GetLocalVarTuple<T>();
-    MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
-    return Evaluator<T>{}(expr.data, argTuple, localVars);
-}
-
-// Treat Evaluator<Expression<T>> as Evaluator<T>
-template <typename T>
-struct Evaluator<Expression<T>> : Evaluator<T> {};
-
-// Partial specialization for LocalVar
-template <std::size_t N, typename T, typename L>
-struct Evaluator<LocalVar<N, T, L>> {
-    using Type = T&;
-
-    template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
-                              ArgTup& /*args*/,
-                              LocalVarTup& localVars) const
-    {
-        static_assert(N > 0, "LocalVar number starts from 1");
-        return std::get<N - 1>(localVars);
-    }
-};
-
-// Partial specialization for Param
-template <std::size_t N, typename T, ParamUsage U>
-struct Evaluator<Param<N, T, U>> {
-    using Type = T;
-
-    template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(Param<N, T, U> /*unused*/,
-                              ArgTup& args,
-                              LocalVarTup& /*localVars*/) const
-    {
-        static_assert(N > 0, "Param number starts from 1");
-        static_assert(U == ParamUsage::in || std::is_reference_v<T>,
-                      "Only in-parameters can have value types");
-        constexpr auto index = N - 1;
-        using NthType =
-            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
-        if constexpr (std::is_same_v<T&, NthType> ||
-                      std::is_same_v<T&&, NthType>) {
-            return std::get<index>(args);
-        } else {
-            static_assert(
-                U == ParamUsage::in,
-                "Only in-parameters allow implicit type conversions");
-            return static_cast<T>(std::get<index>(args));
-        }
-    }
-};
-
-template <typename T, typename U>
-void Assign(T& dst, const U& src)
-{
-    dst = src;
-}
-
-// Partial specializtion for E_y = E_x
+// 
 template <typename T, typename U>
-struct Evaluator<OpAssign<T, U>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpAssign<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return Assign(Evaluator<T>{}(op.lhs, args, localVars),
-                      Evaluator<U>{}(op.rhs, args, localVars));
-    }
-};
-
-// Partial specializtion for E_x, E_y
-template <typename T, typename U>
-struct Evaluator<OpAndThen<T, U>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAndThen<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        // operator, evaluates sequentially
-        return Evaluator<T>{}(op.lhs, args, localVars),
-               Evaluator<U>{}(op.rhs, args, localVars);
-    }
-};
-
-template <typename T, typename U>
-auto Add(const T& src1, const U& src2)
-{
-    return src1 + src2;
-}
-
-template <typename T, typename U, typename V>
-void AddAssign(T& dst, const U& src1, const V& src2)
+[[nodiscard]] constexpr auto Relu(Expression<T> lhs, Expression<U> rhs)
 {
-    dst = src1 + src2;
-}
-
-template <typename T>
-void AddAssign(std::vector<T>& dst,
-               const std::vector<T>& src1,
-               const std::vector<T>& src2)
-{
-    if (src1.size() != src2.size()) {
-        throw std::logic_error("vector sizes do not match");
-    }
-    if (src1.size() != dst.size()) {
-        throw std::logic_error("Destination vector should be like source");
-    }
-    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
-        dst[i] = src1[i] + src2[i];
-    }
+    return Expression<OpRelu<T, U>>{{lhs.data, rhs.data}};
 }
 
-// Partial specializtion for E_x + E_y
-template <typename T, typename U>
-struct Evaluator<OpAdd<T, U>> {
-    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
-                              std::declval<typename Evaluator<U>::Type>()));
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAdd<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return Add(Evaluator<T>{}(op.lhs, args, localVars),
-                   Evaluator<U>{}(op.rhs, args, localVars));
-    }
-};
-
-// Partial specializtion for E_z = E_x + E_y
-template <typename T, typename U, typename V>
-struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
-    using Type = void;
 
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
-                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
-                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
-    }
-};
+// Base class to express that a class is a maker of calculation expression template
+class Maker {};
 
-} // namespace DemoEval
+} // namespace ATVC::ExprTmpl
 
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index ac90cdf7d..34eb2a432 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -7,38 +7,33 @@
 #include <vector>
 #include <kernel_operator.h>
 #include "../include/utils/expression/expression.h"
+#include "../include/tile/tile_elewise.h"
+#include "../include/block/block_elewise.h"
 #include "../include/kernel/kernel_elewise.h"
 #include "../include/device/device_elewise.h"
 
 
+// using namespace ATVC::ExprTmpl;
 
-using namespace ATVOS;
-using namespace ExprTmpl;
-
-描述计算逻辑
+// 描述计算逻辑
 struct MyAddOp : ATVC::ExprTmpl::Maker {
-template <typename <typename> class VectorType>
-constexpr auto Get() const
-{
-using namespace ATVC::ExprTmpl;
-auto _1 = DefinePlaceholder<1, VectorType<float>>();
-auto _2 = DefinePlaceholder<2, VectorType<float>>();
-auto _3 = DefinePlaceholder<3, VectorType<float>, VarUsage::out>();
-return (_3 = _1 + _2);
-}
+    template <template <typename> class VectorType>
+    constexpr auto Get() const
+    {
+        using namespace ATVC::ExprTmpl;
+        auto _1 = DefineParam<1, VectorType<float>>();
+        auto _2 = DefineParam<2, VectorType<float>>();
+        auto _3 = DefineParam<3, VectorType<float>, ParamUsage::out>();
+        return _3 = relu(_1, _2);
+        return (_3 = _1 + _2);
+    }
 };
 
-// template<class KernelOp>
-// __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
-// {
-//     KernelOp op;
-//     op.Run(configDevice, x, y, z);
-// }
-
 int main() {
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
     std::vector<float> v3(300);
-    ATVC::Device::DoElementwise<float>(MyAddOp{}, v1, v2, v3); // 完成 core num计算 kernel launch
+    ATVC::Device::DeviceEleWise<MyAddOp> deviceOp;
+    deviceOp.Run(v1, v2, v3); // 完成 core num计算 kernel launch
     return 0;
 }
\ No newline at end of file
-- 
Gitee


From f2362a16ec1ac019e9d06302cb2f03c33c755914 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 11 Sep 2025 14:54:41 +0800
Subject: [PATCH 014/116] Adjust format

---
 best_practices/expression_template/expr_template_demo.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 77ea53ccb..8cee067c3 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -570,11 +570,14 @@ void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
     }
 }
 
-template <typename LocalVars, typename LocalVarTup, typename ArgTup, std::size_t... Ints>
+template <typename LocalVars, typename LocalVarTup, typename ArgTup,
+          std::size_t... Ints>
 void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
                             std::index_sequence<Ints...>)
 {
-    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(std::get<Ints>(localVars), args), ...);
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
+         std::get<Ints>(localVars), args),
+     ...);
 }
 
 } // namespace Detail
-- 
Gitee


From f569cbbb4a2cb70bf4a93815d5f6fc148e40e0c0 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 11 Sep 2025 22:10:59 +0800
Subject: [PATCH 015/116] Add sample code for PrepareParams and ConvertArgs

---
 .../expr_template_demo.cpp                    | 266 +++++++++++++++---
 1 file changed, 224 insertions(+), 42 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 8cee067c3..51be88382 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1,4 +1,5 @@
 #include <cstddef>
+#include <functional>
 #include <iostream>
 #include <stdexcept>
 #include <tuple>
@@ -109,29 +110,6 @@ struct Check<Pred, TypeList<>> {
 template <template <typename> class Pred, typename List>
 inline constexpr bool Check_v = Check<Pred, List>::value;
 
-template <template <typename> class Pred, typename List, typename = void>
-struct Find;
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Find<Pred, TypeList<Head, Tail...>,
-            std::enable_if_t<Pred<Head>::value>> {
-    using Type = Head;
-};
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Find<Pred, TypeList<Head, Tail...>,
-            std::enable_if_t<!Pred<Head>::value>>
-    : Find<Pred, TypeList<Tail...>> {};
-
-template <template <typename> class Pred>
-struct Find<Pred, TypeList<>, void> {
-    static_assert(AlwaysFalse_v<Pred<void>>,
-                  "Cannot find the specified element");
-};
-
-template <template <typename> class Pred, typename List>
-using Find_t = typename Find<Pred, List>::Type;
-
 template <template <typename> class Pred, typename List>
 struct Filter;
 
@@ -151,6 +129,30 @@ struct Filter<Pred, TypeList<>> {
 template <template <typename> class Pred, typename List>
 using Filter_t = typename Filter<Pred, List>::Type;
 
+template <template <typename> class Pred, typename List, typename = void>
+struct Find;
+
+template <template <typename> class Pred>
+struct Find<Pred, TypeList<>> {
+    static constexpr std::size_t value = 0;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<Pred<Head>::value>> {
+    static constexpr std::size_t value = 0;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<!Pred<Head>::value>> {
+    static constexpr std::size_t value =
+        Find<Pred, TypeList<Tail...>>::value + 1;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr std::size_t Find_v = Find<Pred, List>::value;
+
 template <typename List, std::size_t N>
 struct Get;
 
@@ -519,6 +521,86 @@ using Util::TMP::Size_v;
 
 using namespace ExprTmpl;
 
+template <typename T>
+class MyTensor {
+public:
+    MyTensor() = default;
+    explicit MyTensor(std::vector<T>& src)
+        : ptr_(src.data()), len_(src.size())
+    {
+    }
+    MyTensor(const MyTensor& rhs) : ptr_(rhs.ptr_), len_(rhs.len_)
+    {
+        if (rhs.owned_) {
+            throw std::logic_error(
+                "Cannot copy-construct an owned MyTensor");
+        }
+    }
+    MyTensor& operator=(const MyTensor&) = delete;
+    MyTensor(MyTensor&& rhs) noexcept
+        : ptr_(rhs.ptr_), len_(rhs.len_), owned_(rhs.owned_)
+    {
+        rhs.owned_ = false;
+    }
+    MyTensor& operator=(MyTensor&& rhs) noexcept
+    {
+        if (this != &rhs) {
+            Release();
+            ptr_ = rhs.ptr_;
+            len_ = rhs.len_;
+            owned_ = rhs.owned_;
+            rhs.owned_ = false;
+        }
+    }
+    ~MyTensor()
+    {
+        Release();
+    }
+
+    T& operator[](std::size_t pos)
+    {
+        return ptr_[pos];
+    }
+    const T& operator[](std::size_t pos) const
+    {
+        return ptr_[pos];
+    }
+
+    void Clear()
+    {
+        Release();
+        ptr_ = nullptr;
+        len_ = 0;
+    }
+
+    void SetSize(std::size_t size)
+    {
+        if (ptr_ != nullptr) {
+            throw std::logic_error(
+                "MyTensor::SetSize can only be called on an empty object");
+        }
+        ptr_ = new T[size];
+        len_ = size;
+        owned_ = true;
+    }
+    std::size_t GetSize() const
+    {
+        return len_;
+    }
+
+private:
+    void Release()
+    {
+        if (owned_) {
+            delete[] ptr_;
+        }
+    }
+
+    T* ptr_{};
+    std::size_t len_{};
+    bool owned_{};
+};
+
 // Primary template
 template <typename T>
 struct Evaluator {
@@ -546,10 +628,17 @@ constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
 
 namespace Detail {
 
-template <typename T, std::size_t... Ints>
+template <typename Params, std::size_t... Ints>
+constexpr auto GetParamTupleImpl(std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              Params>::Type{}...);
+}
+
+template <typename LocalVars, std::size_t... Ints>
 constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
 {
-    using LocalVars = typename LocalVars<T>::Type;
     return std::make_tuple(
         typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
                               LocalVars>::Type{}...);
@@ -561,6 +650,12 @@ void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
     dst.resize(src.size());
 }
 
+template <typename T>
+void MakeAlikeDatum(MyTensor<T>& dst, const MyTensor<T>& src)
+{
+    dst.SetSize(src.GetSize());
+}
+
 template <typename L, typename T, typename ArgTup>
 void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
 {
@@ -582,12 +677,19 @@ void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
 
 } // namespace Detail
 
-template <typename T>
+template <typename Params>
+constexpr auto GetParamTuple()
+{
+    constexpr auto paramCount = Size_v<Params>;
+    return Detail::GetParamTupleImpl<Params>(
+        std::make_index_sequence<paramCount>{});
+};
+
+template <typename LocalVars>
 constexpr auto GetLocalVarTuple()
 {
-    using LocalVars = typename LocalVars<T>::Type;
     constexpr auto localVarCount = Size_v<LocalVars>;
-    return Detail::GetLocalVarTupleImpl<T>(
+    return Detail::GetLocalVarTupleImpl<LocalVars>(
         std::make_index_sequence<localVarCount>{});
 };
 
@@ -607,7 +709,7 @@ auto Evaluate(const Expression<T>& expr, Args&&... args)
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
     using LocalVars = LocalVars_t<T>;
     [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
-    auto localVars = GetLocalVarTuple<T>();
+    auto localVars = GetLocalVarTuple<LocalVars>();
     MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
     return Evaluator<T>{}(expr.data, argTuple, localVars);
 }
@@ -724,6 +826,22 @@ void AddAssign(std::vector<T>& dst,
     }
 }
 
+template <typename T>
+void AddAssign(MyTensor<T>& dst,
+               const MyTensor<T>& src1,
+               const MyTensor<T>& src2)
+{
+    if (src1.GetSize() != src2.GetSize()) {
+        throw std::logic_error("Tensor sizes do not match");
+    }
+    if (src1.GetSize() != dst.GetSize()) {
+        throw std::logic_error("Destination tensor should be like source");
+    }
+    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
 // Partial specializtion for E_x + E_y
 template <typename T, typename U>
 struct Evaluator<OpAdd<T, U>> {
@@ -758,18 +876,86 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
 
 } // namespace DemoEval
 
-template <typename T>
-using VectorType = std::vector<T>;
-
 namespace Emulation {
 
-template <
-    typename ExprMaker, typename... Args,
-    typename = std::enable_if_t<std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
-void DoElementwise(ExprMaker maker, Args&&... args)
+using namespace DemoEval;
+
+namespace Detail {
+
+template <typename ParamType, typename ArgTup>
+auto ConstructParam(ArgTup& args)
+{
+    return typename std::decay_t<typename ParamType::Type>(
+        std::get<ParamType::number - 1>(args));
+}
+
+template <typename Params, typename ArgTup, std::size_t... Ints>
+auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        ConstructParam<
+            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
+            args)...);
+}
+
+template <typename Params, std::size_t Index, typename ParamTup,
+          typename ArgTup>
+auto ConvertOneArg(ParamTup& params, ArgTup& args)
+{
+    constexpr auto pos =
+        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
+    if constexpr (pos < Util::TMP::Size_v<Params>) {
+        return std::ref(std::get<pos>(params));
+    } else {
+        return std::ref(std::get<Index>(args));
+    }
+}
+
+template <typename Params, typename ParamTup, typename ArgTup,
+          std::size_t... Ints>
+auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+                     std::index_sequence<Ints...>)
 {
-    return DemoEval::Evaluate(maker.template Get<VectorType>(),
-                              std::forward<Args>(args)...);
+    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
+}
+
+} // namespace Detail
+
+template <typename Params, typename ArgTup>
+auto PrepareParams(ArgTup& argTuple)
+{
+    return Detail::PrepareParamsImpl<Params>(
+        argTuple, std::make_index_sequence<Size_v<Params>>{});
+}
+
+template <typename Params, typename ParamTup, typename ArgTup>
+auto ConvertArgs(ParamTup& params, ArgTup& args)
+{
+    return Detail::ConvertArgsImpl<Params>(
+        params, args,
+        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
+}
+
+template <typename ExprMaker, typename... Args,
+          typename = std::enable_if_t<
+              std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(const ExprMaker& maker, Args&&... args)
+{
+    auto expr = maker.template Get<MyTensor>();
+    using Expr = typename decltype(expr)::Type;
+    static_assert(
+        !Expr::hasData,
+        "This expression template is not supposed to contain data");
+
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+
+    using Params = Params_t<Expr>;
+    auto params = PrepareParams<Params>(argTuple);
+    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
+    using LocalVars = LocalVars_t<Expr>;
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, convertedArgs);
+    Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
 }
 
 } // namespace Emulation
@@ -839,10 +1025,6 @@ int main() // NOLINT(bugprone-exception-escape)
     auto r = Evaluate(result6, 1, 2);
     std::cout << r << '\n';
 
-    [[maybe_unused]] auto result7 = MyAddOp{}.Get<VectorType>();
-    static_assert(!decltype(result7)::hasData);
-    //TYPE_DISPLAY(result7);
-    //TYPE_DISPLAY(InParams_t<decltype(result7)::Type>{});
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
     std::vector<float> v3(300, 3.0F);
-- 
Gitee


From 6458ec116c36a8202cc0afcbab3145269d570a64 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 12 Sep 2025 09:39:41 +0800
Subject: [PATCH 016/116] Add a comment

---
 best_practices/expression_template/expr_template_demo.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 51be88382..855ba5bf3 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -885,6 +885,9 @@ namespace Detail {
 template <typename ParamType, typename ArgTup>
 auto ConstructParam(ArgTup& args)
 {
+    // decay_t is very important here.  If ParamType::Type were a
+    // reference type and decaying did not happen, the expression below
+    // would become a reinterpret_cast: disasters would follow then.
     return typename std::decay_t<typename ParamType::Type>(
         std::get<ParamType::number - 1>(args));
 }
-- 
Gitee


From 3b14119d0af7660a7962e8ba3bb004231c6be491 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 12 Sep 2025 09:41:08 +0800
Subject: [PATCH 017/116] Make MyAddOp a template

---
 .../expression_template/expr_template_demo.cpp      | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 855ba5bf3..f609c696a 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -973,16 +973,17 @@ struct type_displayer;
 #define PASTE(x, y) CONCAT(x, y)
 #define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
 
+template <typename T>
 struct MyAddOp : ExprTmpl::Maker {
     template <template <typename> class VectorType>
     constexpr auto Get() const
     {
         using namespace ExprTmpl;
-        auto _1 = DefineParam<1, VectorType<float>>();
-        auto _2 = DefineParam<2, VectorType<float>>();
-        auto _3 = DefineParam<3, VectorType<float>>();
-        auto _4 = DefineParam<4, VectorType<float>>();
-        auto _5 = DefineParam<5, VectorType<float>&, ParamUsage::out>();
+        auto _1 = DefineParam<1, VectorType<T>>();
+        auto _2 = DefineParam<2, VectorType<T>>();
+        auto _3 = DefineParam<3, VectorType<T>>();
+        auto _4 = DefineParam<4, VectorType<T>>();
+        auto _5 = DefineParam<5, VectorType<T>&, ParamUsage::out>();
         auto tmp1 = DefineLocalVarLike<1>(_1);
         auto tmp2 = DefineLocalVarLike<2>(_3);
         return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2);
@@ -1033,7 +1034,7 @@ int main() // NOLINT(bugprone-exception-escape)
     std::vector<float> v3(300, 3.0F);
     std::vector<float> v4(300, 4.0F);
     std::vector<float> v5(300);
-    Emulation::DoElementwise(MyAddOp{}, v1, v2, v3, v4, v5);
+    Emulation::DoElementwise(MyAddOp<float>{}, v1, v2, v3, v4, v5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
 }
-- 
Gitee


From 3c30da117fc6e2b427d64a6c88a691ad25eb6022 Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Sat, 13 Sep 2025 09:01:56 +0800
Subject: [PATCH 018/116] fix compare err

---
 .../atvos_demo/include/block/block_elewise.h  |  70 ++---
 .../include/device/device_elewise.h           | 166 ++++++++----
 .../atvos_demo/include/device/device_tensor.h |  84 ++++++
 .../include/kernel/kernel_elewise.h           |  45 ++--
 .../atvos_demo/include/tile/tile_elewise.h    |  24 +-
 .../include/tile/tile_evaluator_common.h      | 250 ++++++++++++++++++
 .../atvos_demo/include/tile/tile_operator.h   |  17 ++
 .../include/utils/expression/expression.h     |  43 +--
 .../include/utils/expression/utility.h        | 205 ++++++++++++++
 best_practices/atvos_demo/test/main.cpp       |   1 -
 10 files changed, 751 insertions(+), 154 deletions(-)
 create mode 100644 best_practices/atvos_demo/include/device/device_tensor.h
 create mode 100644 best_practices/atvos_demo/include/tile/tile_evaluator_common.h
 create mode 100644 best_practices/atvos_demo/include/tile/tile_operator.h
 create mode 100644 best_practices/atvos_demo/include/utils/expression/utility.h

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index 4d135c3dd..dd727a3e3 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -1,3 +1,5 @@
+#ifndef _BLOCK_ELE_WISE_H
+#define _BLOCK_ELE_WISE_H
 namespace ATVC::Block {
 
 struct Config {// block层的切分信息
@@ -12,13 +14,14 @@ public:
     BlockEleWise(){}
 
     template <typename ArgTup>
-    Tile::Config MakeConfig(const Config& configBlock, ArgTup& argTuple)
+    __aicore__ inline Tile::Config MakeConfig(const Config& configBlock, ArgTup& argTuple)
     {
         Tile::Config configTile{12, 1, 2048};
+        return configTile;
     }
 
     template <typename ArgTup>
-    int64_t Run(const Config& configBlock, ArgTup& argTuple)
+    __aicore__ inline int64_t Run(const Config& configBlock, ArgTup& argTuple)
     {
         // 配置规划，特别是需要确定使用的 Local Memory 大小
         Tile::Config configTile = MakeConfig(configBlock, argTuple);
@@ -42,53 +45,34 @@ public:
 
         // 循环执行
         for (int i = 0; i < configTile.wholeBlockCount; ++i) {
-            CopyIn<InParams>(inParams, argTuple);
+            CopyIn<InParams>(inParams, argTuple, configTile);
             Tile::Evaluate<Expr>(combinedArgs, localVars);
-            CopyOut<OutParams>(outParams, argTuple);
+            CopyOut<OutParams>(outParams, argTuple, configTile);
         }
         // 尾块的处理
         for (int i = 0; i < configTile.tileBlockCount; ++i) {
-            CopyIn<InParams>(inParams, argTuple);
+            CopyIn<InParams>(inParams, argTuple, configTile);
             Tile::Evaluate<Expr>(combinedArgs, localVars);
-            CopyOut<OutParams>(outParams, argTuple);
+            CopyOut<OutParams>(outParams, argTuple, configTile);
+        }
+    }
+private:
+    template <typename InParams, typename ArgTup>
+    __aicore__ inline void CopyIn(InParams& inParams, ArgTup& argTuple, Tile::Config &configTile){
+        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
+        for(auto i = 0; i < tupeSize; i++) {
+            AscendC::DataCopy(AscendC::Std::get<i>(inParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
         }
     }
-};
-// void DoElementwise(ExprMaker maker, const Config& configBlock, ArgTup& argTuple)
-// {
-//     // 配置规划，特别是需要确定使用的 Local Memory 大小
-//     Tile::Config configTile = MakeConfig<ExprMaker>(configBlock, argTuple);
-
-//     auto expr = maker.template Get<AscendC::LocalTensor<T>>();
-//     using Expr = decltype(expr);
-//     using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>;
-//     using Params = ATVC::ExprTmpl::Params_t<Expr>;
-//     using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
-//     using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
-
-//     // 得到 tuple<LocalTensor, ...>，向量变成了 LocalTensor 类型
-//     auto params = PrepareParams<Params>(configTile);
-//     // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
-//     auto inParams = PrepareInParams<InParams>(params);
-//     auto outParams = PrepareOutParams<InParams>(params);
-//     // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
-//     auto localVars = PrepareLocalVars<LocalVars>(params);
-
-//     // 把 argTuple 里的向量替换成 params 里的对应 Tensor
-//     auto combinedArgs = CombineArgs(params, argTuple);
 
-//     // 循环执行
-//     for (int i = 0; i < configTile.wholeBlockCount; ++i) {
-//         CopyIn<InParams>(inParams, argTuple);
-//         Tile::Evaluate<Expr>(combinedArgs, localVars);
-//         CopyOut<OutParams>(outParams, argTuple);
-//     }
-//     // 尾块的处理
-//     for (int i = 0; i < configTile.tileBlockCount; ++i) {
-//         CopyIn<InParams>(inParams, argTuple);
-//         Tile::Evaluate<Expr>(combinedArgs, localVars);
-//         CopyOut<OutParams>(outParams, argTuple);
-//     }
-// }
+    template <typename OutParams, typename ArgTup>
+    __aicore__ inline void CopyOut(OutParams& outParams, ArgTup& argTuple, Tile::Config &configTile){
+        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
+        for(auto i = 0; i < tupeSize; i++) {
+            AscendC::DataCopy(AscendC::Std::get<i>(outParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
+        }
+    }
+};
+} // namespace ATVC::Block
 
-} // namespace ATVC::Block
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index 459dfcb9b..776aead24 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -1,5 +1,8 @@
+#ifndef _DEVICE_ELE_WISE_H
+#define _DEVICE_ELE_WISE_H
+#include <functional>
 #include "acl/acl.h"
-
+#include "device_tensor.h"
 #define CHECK_ACL(x)                                                                        \
     do {                                                                                    \
         aclError __ret = x;                                                                 \
@@ -25,40 +28,21 @@ void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
 }
 
 
-template<class KernelOp, class... Args>
-__global__ __aicore__ void MyKernel(GM_ADDR configDevice, Args... args)
+template<class KernelOp, typename ArgTup>
+__global__ __aicore__ void MyKernel(GM_ADDR configDevice, ArgTup argTuple)
 {
     KernelOp op;
-    op.Run(configDevice, args...);
+    // op.Run(configDevice, argTuple);
 }
 
 namespace ATVC::Device {
 
-template <typename T>
-struct Tensor {
-    T* ptr;
-    uint64_t len; // 元素个数
-};
-
-template <typename Params>
-std::vector<Tensor<float>> PrepareParams() {
-    std::vector<Tensor<float>> params{};
-    return params;
-}
-
-template <typename InParams>
-std::vector<Tensor<float>> PrepareInParams(std::vector<Tensor<float>>& params)
-{
-    std::vector<Tensor<float>> inParams{};
-    return inParams;
-}
+// template <typename T>
+// struct Tensor {
+//     T* ptr;
+//     uint64_t len; // 元素个数
+// };
 
-template <typename OutParams>
-std::vector<Tensor<float>> PrepareOutParams(std::vector<Tensor<float>>& params)
-{
-    std::vector<Tensor<float>> outParams{};
-    return outParams;
-}
 
 template<class KernelOp, typename ArgTup>
 void LaunchKernelWithDataTuple(uint32_t blockNum, uint8_t* configDevice, ArgTup& argTuple)
@@ -71,10 +55,10 @@ void LaunchKernelWithDataTuple(uint32_t blockNum, uint8_t* configDevice, ArgTup&
     CleanACL(stream, context, deviceId);
 }
 
-void ClearTensors(std::vector<Tensor<float>> params)
-{
-    return;
-}
+// void ClearTensors(std::vector<Tensor<float>> params)
+// {
+//     return;
+// }
 
     
 /*
@@ -86,7 +70,6 @@ class DeviceEleWise
 {
 public:
     DeviceEleWise(){};
-
     // 计算kernel切分策略
     Kernel::Config MakeConfig() {
         Kernel::Config configBlock{1, 1024*10};
@@ -94,50 +77,129 @@ public:
     }
 
     template <typename... Args>
-    int64_t Run(Args... args)
+    int64_t Run(Args&&... args)
     {
         // 配置规划
         auto config = MakeConfig();
         auto expr = ExprMaker{}.template Get<Tensor>(); // Tensor 为表达 Device 层向量的类型
-        using Expr = decltype(expr);
+        // using Expr = decltype(expr);
+        using Expr = typename decltype(expr)::Type;
         // static_assert(!Expr::hasData, "设备侧使用的表达式模板不应包含数据");
         using Params = ATVC::ExprTmpl::Params_t<Expr>;
         using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
         using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+        // 参数打包成 tuple
+        auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...); // 转发引用 需要用forward
 
         // 得到 tuple<Tensor, ...>，向量变成了 Device 专用的 Tensor 类型
-        auto params = PrepareParams<Params>();
+        auto params = PrepareParams<Params>(argTuple);
         // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
-        auto inParams = PrepareInParams<InParams>(params);
-        auto outParams = PrepareOutParams<OutParams>(params);
-
-        // 参数打包成 tuple
-        auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+        // auto inParams = PrepareInParams<InParams>(params);
+        // auto outParams = PrepareOutParams<OutParams>(params);
 
         // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
-        CopyIn<InParams>(inParams, argTuple);
+        CopyIn(params, argTuple);
 
         // 把 config 复制到 GM
         uint8_t* configDevice;
         // CopyConfig(config, configDevice);
-
-        // 把 argTuple 里的向量替换成 params 里的对应 Tensor
-        auto combinedArgs = CombineArgs(params, argTuple);
-        auto totalArgs = std::tuple_cat(std::tuple(config.blockNum, configDevice), argTuple);
+        auto totalArgs = std::tuple_cat(std::tuple(config.blockNum, configDevice), argTuple); // 普通变量 tuple
         // 传递参数到设备侧执行
-        // std::apply([](auto&&... tuple2args) {
-        //     LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(tuple2args...);
-        // }, totalArgs);
         LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, configDevice, argTuple);
 
         // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
-        CopyOut<OutParams>(outParams, argTuple);
+        CopyOut(params, argTuple);
 
         // Tensor 和 configDevice 需手工清理
         // ClearConfig(configDevice);
-        ClearTensors(params);
+        // ClearTensors(params);
         return 0;
     }
+
+private:
+    template <typename InParams, typename ArgTup>
+    void CopyIn(InParams& inParams, ArgTup& argTuple){
+        // uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
+        // for(auto i = 0; i < tupeSize; i++) {
+        //     // TODO： host to device
+        //     // AscendC::DataCopy(AscendC::Std::get<i>(inParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
+        // }
+    }
+
+    template <typename OutParams, typename ArgTup>
+    void CopyOut(OutParams& outParams, ArgTup& argTuple){
+        // uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
+        // for(auto i = 0; i < tupeSize; i++) {
+        //     // TODO： device to host
+        //     // AscendC::DataCopy(AscendC::Std::get<i>(outParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
+        // }
+    }
+
+    template <typename ParamType, typename ArgTup>
+    auto ConstructParam(ArgTup& args)
+    {   // TODO device内存分配？
+        // 从 args 元组中获取第 ParamType::number - 1 个元素
+        // 将 ParamType::Type 转换为非引用、非常量类型
+        return typename std::decay_t<typename ParamType::Type>(
+            std::get<ParamType::number - 1>(args));
+    }
+
+    template <typename Params, typename ArgTup, std::size_t... Ints>
+    auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
+    {
+        return std::make_tuple(
+            ConstructParam<
+                Util::TMP::FindUnique_t<ATVC::ExprTmpl::CheckVarNum<Ints + 1>::template Checker, Params>>(
+                args)...);
+    }
+
+    template <typename Params, typename ArgTup>
+    auto PrepareParams(ArgTup& argTuple)
+    {
+        return PrepareParamsImpl<Params>(
+            argTuple, std::make_index_sequence<Util::TMP::Size_v<Params>>{});
+    }
+
+    // template <typename InParams, typename Params>
+    // InParams PrepareInParams(Params &params)
+    // {
+        
+    //     return Params{};
+    // }
+
+    // template <typename OutParams, typename Params>
+    // OutParams PrepareOutParams(Params &params)
+    // {
+    //     return params;
+    // }
+
+    template <typename Params, std::size_t Index, typename ParamTup, typename ArgTup>
+    auto ConvertOneArg(ParamTup& params, ArgTup& args)
+    {
+        constexpr auto pos =
+            Util::TMP::Find_v<ATVC::ExprTmpl::CheckVarNum<Index + 1>::template Checker, Params>;
+        if constexpr (pos < Util::TMP::Size_v<Params>) {
+            return std::get<pos>(params);
+        } else {
+            return std::get<Index>(args);
+        }
+    }
+
+    template <typename Params, typename ParamTup, typename ArgTup, std::size_t... Ints>
+    auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+                        std::index_sequence<Ints...>)
+    {
+        return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
+    }
+
+    template <typename Params, typename ParamTup, typename ArgTup>
+    auto ConvertArgs(ParamTup& params, ArgTup& args)
+    {
+        return ConvertArgsImpl<Params>(
+            params, args,
+            std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
+    }
 };
 
-} // namespace ATVC::Device
\ No newline at end of file
+} // namespace ATVC::Device
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_tensor.h b/best_practices/atvos_demo/include/device/device_tensor.h
new file mode 100644
index 000000000..14d477470
--- /dev/null
+++ b/best_practices/atvos_demo/include/device/device_tensor.h
@@ -0,0 +1,84 @@
+
+
+namespace ATVC::Device {
+
+template <typename T>
+class Tensor {
+public:
+    Tensor() = default;
+    explicit Tensor(std::vector<T>& src)
+        : ptr_(src.data()), len_(src.size())
+    {
+    }
+    Tensor(const Tensor& rhs) : ptr_(rhs.ptr_), len_(rhs.len_)
+    {
+        if (rhs.owned_) {
+            throw std::logic_error(
+                "Cannot copy-construct an owned Tensor");
+        }
+    }
+    Tensor& operator=(const Tensor&) = delete;
+    Tensor(Tensor&& rhs) noexcept
+        : ptr_(rhs.ptr_), len_(rhs.len_), owned_(rhs.owned_)
+    {
+        rhs.owned_ = false;
+    }
+    Tensor& operator=(Tensor&& rhs) noexcept
+    {
+        if (this != &rhs) {
+            Release();
+            ptr_ = rhs.ptr_;
+            len_ = rhs.len_;
+            owned_ = rhs.owned_;
+            rhs.owned_ = false;
+        }
+    }
+    ~Tensor()
+    {
+        Release();
+    }
+
+    T& operator[](std::size_t pos)
+    {
+        return ptr_[pos];
+    }
+    const T& operator[](std::size_t pos) const
+    {
+        return ptr_[pos];
+    }
+
+    void Clear()
+    {
+        Release();
+        ptr_ = nullptr;
+        len_ = 0;
+    }
+
+    void SetSize(std::size_t size)
+    {
+        if (ptr_ != nullptr) {
+            throw std::logic_error(
+                "Tensor::SetSize can only be called on an empty object");
+        }
+        ptr_ = new T[size];
+        len_ = size;
+        owned_ = true;
+    }
+    std::size_t GetSize() const
+    {
+        return len_;
+    }
+
+private:
+    void Release()
+    {
+        // if (owned_) {
+        //     delete[] ptr_;
+        // }
+    }
+
+    T* ptr_{};
+    std::size_t len_{};
+    bool owned_{};
+};
+}
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index 30c7110cc..5cfde1ddd 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -1,3 +1,6 @@
+#ifndef KERNEL_ELE_WISE_H
+#define KERNEL_ELE_WISE_H
+
 namespace ATVC::Kernel {
 struct Config{ // kernel 层的切分信息
     uint32_t blockNum = 1;
@@ -7,15 +10,26 @@ struct Config{ // kernel 层的切分信息
 template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
 class KernelEleWise{
 public:
-    KernelEleWise(){};
+    __aicore__ inline KernelEleWise(){};
+
     // 计算block切分策略
-    Block::Config MakeConfig(GM_ADDR configKernel) {
+    __aicore__ inline Block::Config MakeConfig(GM_ADDR configKernel) {
         Block::Config configBlock{10, 1, 1024};
         return configBlock;
     }
+
+    // 需要从Params中萃取每个输入输出的Dtype 递归调用PrepareParams 生成每个输入输出的GlobalTensor
+    template <typename Params, typename... Args>
+    __aicore__ inline AscendC::Std::tuple<AscendC::GlobalTensor<float>> PrepareParams(Args... args) {
+        AscendC::Std::tuple<AscendC::GlobalTensor<float>> params{};
+        // AscendC::GlobalTensor<float> globalTensor;
+        // globalTensor.SetGlobalBuffer(reinterpret_cast<__gm__ DataType*>(src), srcDataSize);
+        return params;
+    }
+
     // 运行接口
     template <typename... Args>
-    int64_t Run(GM_ADDR configKernel, Args... args)
+    __aicore__ inline int64_t Run(GM_ADDR configKernel, Args... args)
     {
         // 配置Block层切分策略
         Block::Config configBlock = MakeConfig(configKernel);
@@ -43,26 +57,5 @@ public:
     }
 };
 
-// void DoElementwise(ExprMaker maker, uint8_t* configKernel, Args... args)
-// {
-//     // 配置规划
-//     Block::Config configBlock = MakeConfig<ExprMaker>(configKernel, args...);
-
-//     auto expr = maker.Get<GlobalTensor<T>>();
-//     using Expr = decltype(expr);
-//     using Params = ATVC::ExprTmpl::Params_t<Expr>;
-//     using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
-//     using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
-
-//     // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
-//     // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
-//     auto params = PrepareParams<Params>(args...);
-
-//     // 执行计算
-//     // 循环执行
-//     for (int i = 0; i < configKernel.wholeBlockCount; ++i) {
-//         Block::DoElementwise<T, Maker>(configBlock, params);
-//     }
-// }
-
-} // namespace ATVC::Kernel
\ No newline at end of file
+} // namespace ATVC::Kernel
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
index 4b59147c4..bbd5f43a7 100644
--- a/best_practices/atvos_demo/include/tile/tile_elewise.h
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -1,4 +1,7 @@
+#ifndef TILE_ELE_WISE_H
+#define TILE_ELE_WISE_H
 #include "tile_evaluator_common.h"
+// #include "tile_operator.h"
 
 
 namespace ATVC::Tile {
@@ -10,25 +13,18 @@ struct Config {//tile层的切分信息
 };
 
 template <typename T>
-void AddAssign(std::vector<T>& dst,
-               const std::vector<T>& src1,
-               const std::vector<T>& src2)
+__aicore__ inline void AddAssign(AscendC::LocalTensor<T>& dst,
+               const AscendC::LocalTensor<T>& src1,
+               const AscendC::LocalTensor<T>& src2)
 {
-    if (src1.size() != src2.size()) {
-        throw std::logic_error("vector sizes do not match");
-    }
-    if (src1.size() != dst.size()) {
-        throw std::logic_error("Destination vector should be like source");
-    }
-    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
-        // dst[i] = src1[i] + src2[i];
-    }
+    AscendC::Add(dst, src1, src2, src2.size());
 }
 
 template <typename Expr, typename ArgTup, typename LocalVarTup>
-void Evaluate(ArgTup& args, LocalVarTup& localVars)
+__aicore__ inline void Evaluate(ArgTup& args, LocalVarTup& localVars)
 {
     DemoEval::Evaluator<typename Expr::Type>{}(args, localVars);
 }
 
-} // namespace ATVC::Tile
\ No newline at end of file
+} // namespace ATVC::Tile
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/tile/tile_evaluator_common.h b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
new file mode 100644
index 000000000..1144cac09
--- /dev/null
+++ b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
@@ -0,0 +1,250 @@
+#ifndef TILE_EVAL_COMMON_H
+#define TILE_EVAL_COMMON_H
+
+#include "../utils/expression/expression.h"
+/* Evaluation */
+
+namespace DemoEval {
+
+using Util::TMP::FindUnique_t;
+using Util::TMP::Size_v;
+
+using namespace ATVC::ExprTmpl;
+
+// Primary template
+template <typename T>
+struct Evaluator {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(const T& value,
+                              ArgTup& args,
+                              LocalVarTup& localVars) const
+    {
+        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
+            return value(args, localVars);
+        } else {
+            return value;
+        }
+    }
+};
+
+template <std::size_t N, typename T>
+constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
+{
+    using ResultType = typename Evaluator<T>::Type;
+    return Expression<LocalVar<N, ResultType>>{};
+}
+
+namespace Detail {
+
+template <typename T, std::size_t... Ints>
+constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
+{
+    using LocalVars = typename LocalVars<T>::Type;
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              LocalVars>::Type{}...);
+}
+
+template <typename T>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename L, typename T, typename ArgTup>
+void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
+{
+    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
+    if constexpr (!std::is_same_v<typename L::Like, void>) {
+        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
+    }
+}
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup, std::size_t... Ints>
+void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
+                            std::index_sequence<Ints...>)
+{
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(std::get<Ints>(localVars), args), ...);
+}
+
+} // namespace Detail
+
+template <typename T>
+constexpr auto GetLocalVarTuple()
+{
+    using LocalVars = typename LocalVars<T>::Type;
+    constexpr auto localVarCount = Size_v<LocalVars>;
+    return Detail::GetLocalVarTupleImpl<T>(
+        std::make_index_sequence<localVarCount>{});
+};
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup>
+void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
+{
+    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
+        localVars, args,
+        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
+}
+
+template <typename T, typename... Args>
+auto Evaluate(const Expression<T>& expr, Args&&... args)
+{
+    // Declare local variables so that we can always use xTup& in
+    // Evaluator<>::operator()
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+    using LocalVars = LocalVars_t<T>;
+    [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
+    auto localVars = GetLocalVarTuple<T>();
+    MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
+    return Evaluator<T>{}(expr.data, argTuple, localVars);
+}
+
+// Treat Evaluator<Expression<T>> as Evaluator<T>
+template <typename T>
+struct Evaluator<Expression<T>> : Evaluator<T> {};
+
+// Partial specialization for LocalVar
+template <std::size_t N, typename T, typename L>
+struct Evaluator<LocalVar<N, T, L>> {
+    using Type = T&;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              ArgTup& /*args*/,
+                              LocalVarTup& localVars) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return std::get<N - 1>(localVars);
+    }
+};
+
+// Partial specialization for Param
+template <std::size_t N, typename T, ParamUsage U>
+struct Evaluator<Param<N, T, U>> {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+                              ArgTup& args,
+                              LocalVarTup& /*localVars*/) const
+    {
+        static_assert(N > 0, "Param number starts from 1");
+        static_assert(U == ParamUsage::in || std::is_reference_v<T>,
+                      "Only in-parameters can have value types");
+        constexpr auto index = N - 1;
+        using NthType =
+            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
+        if constexpr (std::is_same_v<T&, NthType> ||
+                      std::is_same_v<T&&, NthType>) {
+            return std::get<index>(args);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(std::get<index>(args));
+        }
+    }
+};
+
+template <typename T, typename U>
+void Assign(T& dst, const U& src)
+{
+    dst = src;
+}
+
+// Partial specializtion for E_y = E_x
+template <typename T, typename U>
+struct Evaluator<OpAssign<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Assign(Evaluator<T>{}(op.lhs, args, localVars),
+                      Evaluator<U>{}(op.rhs, args, localVars));
+    }
+};
+
+// Partial specializtion for E_x, E_y
+template <typename T, typename U>
+struct Evaluator<OpAndThen<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAndThen<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        // operator, evaluates sequentially
+        return Evaluator<T>{}(op.lhs, args, localVars),
+               Evaluator<U>{}(op.rhs, args, localVars);
+    }
+};
+
+template <typename T, typename U>
+auto Add(const T& src1, const U& src2)
+{
+    return src1 + src2;
+}
+
+template <typename T, typename U, typename V>
+void AddAssign(T& dst, const U& src1, const V& src2)
+{
+    dst = src1 + src2;
+}
+
+template <typename T>
+void AddAssign(std::vector<T>& dst,
+               const std::vector<T>& src1,
+               const std::vector<T>& src2)
+{
+    if (src1.size() != src2.size()) {
+        throw std::logic_error("vector sizes do not match");
+    }
+    if (src1.size() != dst.size()) {
+        throw std::logic_error("Destination vector should be like source");
+    }
+    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+// Partial specializtion for E_x + E_y
+template <typename T, typename U>
+struct Evaluator<OpAdd<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAdd<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Add(Evaluator<T>{}(op.lhs, args, localVars),
+                   Evaluator<U>{}(op.rhs, args, localVars));
+    }
+};
+
+// Partial specializtion for E_z = E_x + E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
+                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
+                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
+    }
+};
+
+} // namespace DemoEval
+
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/tile/tile_operator.h b/best_practices/atvos_demo/include/tile/tile_operator.h
new file mode 100644
index 000000000..6075c2ceb
--- /dev/null
+++ b/best_practices/atvos_demo/include/tile/tile_operator.h
@@ -0,0 +1,17 @@
+#include "tile_evaluator_common.h"
+
+// Partial specializtion for E_z = E_x + E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
+                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
+                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
+    }
+};
diff --git a/best_practices/atvos_demo/include/utils/expression/expression.h b/best_practices/atvos_demo/include/utils/expression/expression.h
index 8ecea0222..03b6fa855 100644
--- a/best_practices/atvos_demo/include/utils/expression/expression.h
+++ b/best_practices/atvos_demo/include/utils/expression/expression.h
@@ -1,3 +1,5 @@
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
 #include <cstddef>
 #include <iostream>
 #include <stdexcept>
@@ -17,25 +19,33 @@ namespace ATVC::ExprTmpl {
 
 using Util::TMP::TypeList;
 
+template <typename T, typename = void>
+struct HasDataTrait {
+    static constexpr bool value = true;
+};
+
+template <typename T>
+struct HasDataTrait<T, std::void_t<decltype(T::hasData)>> {
+    static constexpr bool value = T::hasData;
+};
+
+// Type for a basic "expression".  If T is trivial (as it should normally
+// be), Expression<T> is trivially copy-constructible and trivially move-
+// constructible, but is not trivially assignable.  Objects of the same
+// Expression type cannot be assigned, because the data member is const.
+// Objects of different Expression types can be assigned, but it will
+// result in a new Expression object (and is not a "normal" assignment).
 template <typename T>
 struct Expression {
     static_assert(!std::is_rvalue_reference_v<T>,
                   "Rvalue references cannot be stored");
     using Type = T;
-    T const data{};  // NOLINT(misc-non-private-member-variables-in-classes)
+    static constexpr bool hasData = HasDataTrait<T>::value;
 
-    explicit Expression(T&& t) : data(std::forward<T>(t)) {}
-    Expression() = default;
-    Expression(const Expression&) = default;
-    ~Expression() = default;
+    T const data{};
 
     template <typename U>
     [[nodiscard]] constexpr auto operator=(Expression<U> u);
-
-    [[nodiscard]] constexpr auto operator=(Expression rhs)
-    {
-        return operator=<T>(rhs);  // Invoke the templated version
-    }
 };
 
 // Let T deduce to value type or lvalue reference type
@@ -55,6 +65,7 @@ struct LocalVar {
     using Type = T;
     using Like = L;
     static constexpr std::size_t number = N;
+    static constexpr bool hasData = false;
 
     template <typename V>
     constexpr auto operator=(Expression<V>)
@@ -85,6 +96,7 @@ struct Param {
     using Type = T;
     static constexpr std::size_t number = N;
     static constexpr ParamUsage usage = U;
+    static constexpr bool hasData = false;
 
     template <typename V>
     constexpr auto operator=(Expression<V>)
@@ -135,6 +147,8 @@ struct BinaryOp {
     static_assert(!(std::is_rvalue_reference_v<T> ||
                     std::is_rvalue_reference_v<U>),
                   "Rvalue references cannot be stored");
+    static constexpr bool hasData =
+        HasDataTrait<T>::value || HasDataTrait<U>::value;
     using IsBinaryOp = void;
     using LhsType = T;
     using RhsType = U;
@@ -286,16 +300,9 @@ template <typename T, typename U>
     return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
 }
 
-// 
-template <typename T, typename U>
-[[nodiscard]] constexpr auto Relu(Expression<T> lhs, Expression<U> rhs)
-{
-    return Expression<OpRelu<T, U>>{{lhs.data, rhs.data}};
-}
-
-
 // Base class to express that a class is a maker of calculation expression template
 class Maker {};
 
 } // namespace ATVC::ExprTmpl
 
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/utils/expression/utility.h b/best_practices/atvos_demo/include/utils/expression/utility.h
new file mode 100644
index 000000000..824cb1a3e
--- /dev/null
+++ b/best_practices/atvos_demo/include/utils/expression/utility.h
@@ -0,0 +1,205 @@
+#ifndef UTILITY_H
+#define UTILITY_H
+/* Utilities */
+
+namespace Util {
+
+template <typename T>
+struct AlwaysFalse : std::false_type {};
+
+template <typename T>
+inline constexpr bool AlwaysFalse_v = AlwaysFalse<T>::value;
+
+template <template <typename...> class T, typename U>
+struct IsSpecializationOf : std::false_type {};
+
+template <template <typename...> class T, typename... Us>
+struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
+
+template <template <typename...> class T, typename U>
+inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
+
+namespace TMP {
+
+template <typename... Ts>
+struct TypeList {};
+
+template <typename List>
+struct First;
+
+template <typename Head, typename... Tail>
+struct First<TypeList<Head, Tail...>> {
+    using Type = Head;
+};
+
+template <typename List>
+using First_t = typename First<List>::Type;
+
+template <typename List>
+struct Size;
+
+template <typename... Ts>
+struct Size<TypeList<Ts...>> {
+    static constexpr std::size_t value = sizeof...(Ts);
+};
+
+template <typename List>
+inline constexpr std::size_t Size_v = Size<List>::value;
+
+template <typename T, typename List>
+struct Prepend;
+
+template <typename T, typename... Ts>
+struct Prepend<T, TypeList<Ts...>> {
+    using Type = TypeList<T, Ts...>;
+};
+
+template <typename T, typename List>
+using Prepend_t = typename Prepend<T, List>::Type;
+
+template <typename... Lists>
+struct Concatenate;
+
+template <>
+struct Concatenate<> {
+    using Type = TypeList<>;
+};
+
+template <typename... Ts>
+struct Concatenate<TypeList<Ts...>> {
+    using Type = TypeList<Ts...>;
+};
+
+template <typename... Ts, typename... Us>
+struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
+    using Type = TypeList<Ts..., Us...>;
+};
+
+template <typename List1, typename List2, typename List3, typename... Lists>
+struct Concatenate<List1, List2, List3, Lists...> {
+    using Type =
+        typename Concatenate<typename Concatenate<List1, List2>::Type,
+                             List3, Lists...>::Type;
+};
+
+template <typename... Lists>
+using Concatenate_t = typename Concatenate<Lists...>::Type;
+
+template <template <typename> class Pred, typename List>
+struct Check;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Check<Pred, TypeList<Head, Tail...>> {
+    static constexpr bool value =
+        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
+};
+
+template <template <typename> class Pred>
+struct Check<Pred, TypeList<>> {
+    static constexpr bool value = true;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr bool Check_v = Check<Pred, List>::value;
+
+template <template <typename> class Pred, typename List>
+struct Filter;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Filter<Pred, TypeList<Head, Tail...>> {
+    using Type = typename std::conditional_t<
+        Pred<Head>::value,
+        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
+        typename Filter<Pred, TypeList<Tail...>>::Type>;
+};
+
+template <template <typename> class Pred>
+struct Filter<Pred, TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <template <typename> class Pred, typename List>
+using Filter_t = typename Filter<Pred, List>::Type;
+
+template <template <typename> class Pred, typename List, typename = void>
+struct Find;
+
+template <template <typename> class Pred>
+struct Find<Pred, TypeList<>> {
+    static constexpr std::size_t value = 0;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<Pred<Head>::value>> {
+    static constexpr std::size_t value = 0;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<!Pred<Head>::value>> {
+    static constexpr std::size_t value =
+        Find<Pred, TypeList<Tail...>>::value + 1;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr std::size_t Find_v = Find<Pred, List>::value;
+
+template <typename List, std::size_t N>
+struct Get;
+
+template <typename Head, typename... Tail, std::size_t N>
+struct Get<TypeList<Head, Tail...>, N> {
+    using Type = typename Get<TypeList<Tail...>, N - 1>::Type;
+};
+
+template <typename Head, typename... Tail>
+struct Get<TypeList<Head, Tail...>, 0> {
+    using Type = Head;
+};
+
+template <std::size_t N>
+struct Get<TypeList<>, N> {
+    static_assert(N < 0, "Index out of bounds in Get");
+};
+
+template <typename List, std::size_t N>
+using Get_t = typename Get<List, N>::Type;
+
+template <typename List>
+struct Unique;
+
+template <typename Head, typename... Tail>
+struct Unique<TypeList<Head, Tail...>> {
+    template <typename T>
+    struct IsNotHead : std::bool_constant<!std::is_same_v<T, Head>> {};
+
+    using Type = Prepend_t<
+        Head,
+        typename Unique<Filter_t<IsNotHead, TypeList<Tail...>>>::Type>;
+};
+
+template <>
+struct Unique<TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <typename List>
+using Unique_t = typename Unique<List>::Type;
+
+template <template <typename> class Pred, typename List>
+struct FindUnique {
+    using ResultList = Filter_t<Pred, List>;
+    static_assert(Size_v<ResultList> != 0, "Cannot find the specified element");
+    static_assert(Size_v<ResultList> == 1, "A unique result is expected");
+    using Type = First_t<ResultList>;
+};
+
+template <template <typename> class Pred, typename List>
+using FindUnique_t = typename FindUnique<Pred, List>::Type;
+
+} // namespace TMP
+
+} // namespace Util
+
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index 34eb2a432..745432dad 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -24,7 +24,6 @@ struct MyAddOp : ATVC::ExprTmpl::Maker {
         auto _1 = DefineParam<1, VectorType<float>>();
         auto _2 = DefineParam<2, VectorType<float>>();
         auto _3 = DefineParam<3, VectorType<float>, ParamUsage::out>();
-        return _3 = relu(_1, _2);
         return (_3 = _1 + _2);
     }
 };
-- 
Gitee


From 3bd2f7880a5225a70bce9548a61d4916194c87c3 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Sat, 13 Sep 2025 10:40:55 +0800
Subject: [PATCH 019/116] Emulate CopyIn and CopyOut

---
 .../expr_template_demo.cpp                    | 192 +++++++++++++-----
 1 file changed, 138 insertions(+), 54 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index f609c696a..f884f0bd9 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1,5 +1,4 @@
 #include <cstddef>
-#include <functional>
 #include <iostream>
 #include <stdexcept>
 #include <tuple>
@@ -522,39 +521,12 @@ using Util::TMP::Size_v;
 using namespace ExprTmpl;
 
 template <typename T>
-class MyTensor {
+class Tensor {
 public:
-    MyTensor() = default;
-    explicit MyTensor(std::vector<T>& src)
-        : ptr_(src.data()), len_(src.size())
+    Tensor() = default;
+    explicit Tensor(std::vector<T>& src)
     {
-    }
-    MyTensor(const MyTensor& rhs) : ptr_(rhs.ptr_), len_(rhs.len_)
-    {
-        if (rhs.owned_) {
-            throw std::logic_error(
-                "Cannot copy-construct an owned MyTensor");
-        }
-    }
-    MyTensor& operator=(const MyTensor&) = delete;
-    MyTensor(MyTensor&& rhs) noexcept
-        : ptr_(rhs.ptr_), len_(rhs.len_), owned_(rhs.owned_)
-    {
-        rhs.owned_ = false;
-    }
-    MyTensor& operator=(MyTensor&& rhs) noexcept
-    {
-        if (this != &rhs) {
-            Release();
-            ptr_ = rhs.ptr_;
-            len_ = rhs.len_;
-            owned_ = rhs.owned_;
-            rhs.owned_ = false;
-        }
-    }
-    ~MyTensor()
-    {
-        Release();
+        SetSize(src.size());
     }
 
     T& operator[](std::size_t pos)
@@ -568,7 +540,7 @@ public:
 
     void Clear()
     {
-        Release();
+        delete[] ptr_;
         ptr_ = nullptr;
         len_ = 0;
     }
@@ -581,24 +553,30 @@ public:
         }
         ptr_ = new T[size];
         len_ = size;
-        owned_ = true;
     }
     std::size_t GetSize() const
     {
         return len_;
     }
 
-private:
-    void Release()
+    void CopyIn(const std::vector<T>& src)
+    {
+        if (src.size() > len_) {
+            throw std::logic_error("Source vector is too big");
+        }
+        std::copy(src.begin(), src.end(), ptr_);
+    }
+    void CopyOut(std::vector<T>& dst)
     {
-        if (owned_) {
-            delete[] ptr_;
+        if (dst.size() < len_) {
+            throw std::logic_error("Destination vector is too small");
         }
+        std::copy_n(ptr_, len_, dst.begin());
     }
 
+private:
     T* ptr_{};
     std::size_t len_{};
-    bool owned_{};
 };
 
 // Primary template
@@ -651,7 +629,7 @@ void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
 }
 
 template <typename T>
-void MakeAlikeDatum(MyTensor<T>& dst, const MyTensor<T>& src)
+void MakeAlikeDatum(Tensor<T>& dst, const Tensor<T>& src)
 {
     dst.SetSize(src.GetSize());
 }
@@ -744,12 +722,11 @@ struct Evaluator<Param<N, T, U>> {
                               LocalVarTup& /*localVars*/) const
     {
         static_assert(N > 0, "Param number starts from 1");
-        static_assert(U == ParamUsage::in || std::is_reference_v<T>,
-                      "Only in-parameters can have value types");
         constexpr auto index = N - 1;
         using NthType =
             std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
-        if constexpr (std::is_same_v<T&, NthType> ||
+        if constexpr (std::is_same_v<T, NthType> ||
+                      std::is_same_v<T&, NthType> ||
                       std::is_same_v<T&&, NthType>) {
             return std::get<index>(args);
         } else {
@@ -827,9 +804,9 @@ void AddAssign(std::vector<T>& dst,
 }
 
 template <typename T>
-void AddAssign(MyTensor<T>& dst,
-               const MyTensor<T>& src1,
-               const MyTensor<T>& src2)
+void AddAssign(Tensor<T>& dst,
+               const Tensor<T>& src1,
+               const Tensor<T>& src2)
 {
     if (src1.GetSize() != src2.GetSize()) {
         throw std::logic_error("Tensor sizes do not match");
@@ -883,7 +860,7 @@ using namespace DemoEval;
 namespace Detail {
 
 template <typename ParamType, typename ArgTup>
-auto ConstructParam(ArgTup& args)
+constexpr auto ConstructParam(ArgTup& args)
 {
     // decay_t is very important here.  If ParamType::Type were a
     // reference type and decaying did not happen, the expression below
@@ -893,7 +870,7 @@ auto ConstructParam(ArgTup& args)
 }
 
 template <typename Params, typename ArgTup, std::size_t... Ints>
-auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
+constexpr auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
 {
     return std::make_tuple(
         ConstructParam<
@@ -903,25 +880,85 @@ auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
 
 template <typename Params, std::size_t Index, typename ParamTup,
           typename ArgTup>
-auto ConvertOneArg(ParamTup& params, ArgTup& args)
+constexpr auto ConvertOneArg(ParamTup& params, ArgTup& args)
 {
     constexpr auto pos =
         Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
     if constexpr (pos < Util::TMP::Size_v<Params>) {
-        return std::ref(std::get<pos>(params));
+        return std::get<pos>(params);
     } else {
-        return std::ref(std::get<Index>(args));
+        return std::get<Index>(args);
     }
 }
 
 template <typename Params, typename ParamTup, typename ArgTup,
           std::size_t... Ints>
-auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
                      std::index_sequence<Ints...>)
 {
     return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
 }
 
+template <typename Params, std::size_t Index, ParamUsage... usages,
+          typename ParamTup>
+constexpr auto GetOneParam(ParamTup& params)
+{
+    using Param = Util::TMP::Get_t<Params, Index>;
+    if constexpr (((Param::usage == usages) || ...)) {
+        return std::forward_as_tuple(std::get<Index>(params));
+    } else {
+        return std::tuple<>{};
+    }
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetInParamsImpl(ParamTup& params,
+                               std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetOutParamsImpl(ParamTup& params,
+                                std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename InParams, std::size_t Index, typename T, typename ArgTup>
+void CopyInOneParam(T& param, ArgTup& args)
+{
+    using Param = Util::TMP::Get_t<InParams, Index>;
+    param.CopyIn(std::get<Param::number - 1>(args));
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyInImpl(InParamTup& inParams, ArgTup& args,
+                std::index_sequence<Ints...>)
+{
+    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args), ...);
+}
+
+template <typename OutParams, std::size_t Index, typename T, typename ArgTup>
+void CopyOutOneParam(T& param, ArgTup& args)
+{
+    using Param = Util::TMP::Get_t<OutParams, Index>;
+    param.CopyOut(std::get<Param::number - 1>(args));
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyOutImpl(OutParamTup& outParams, ArgTup& args,
+                 std::index_sequence<Ints...>)
+{
+    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args), ...);
+}
+
 } // namespace Detail
 
 template <typename Params, typename ArgTup>
@@ -939,12 +976,48 @@ auto ConvertArgs(ParamTup& params, ArgTup& args)
         std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
 }
 
+template <typename Params, typename ParamTup>
+auto GetInParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetInParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename Params, typename ParamTup>
+auto GetOutParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetOutParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup>
+void CopyIn(InParamTup& inParams, ArgTup& args)
+{
+    constexpr auto size = Size_v<InParams>;
+    static_assert(size == std::tuple_size_v<InParamTup>);
+    Detail::CopyInImpl<InParams>(inParams, args,
+                                 std::make_index_sequence<size>{});
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup>
+void CopyOut(OutParamTup& outParams, ArgTup& args)
+{
+    constexpr auto size = Size_v<OutParams>;
+    static_assert(size == std::tuple_size_v<OutParamTup>);
+    Detail::CopyOutImpl<OutParams>(outParams, args,
+                                   std::make_index_sequence<size>{});
+}
+
 template <typename ExprMaker, typename... Args,
           typename = std::enable_if_t<
               std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
 void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
-    auto expr = maker.template Get<MyTensor>();
+    auto expr = maker.template Get<Tensor>();
     using Expr = typename decltype(expr)::Type;
     static_assert(
         !Expr::hasData,
@@ -953,12 +1026,23 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
 
     using Params = Params_t<Expr>;
+    using InParams = InParams_t<Expr>;
+    using OutParams = OutParams_t<Expr>;
+
+    // tuple of values
     auto params = PrepareParams<Params>(argTuple);
     auto convertedArgs = ConvertArgs<Params>(params, argTuple);
     using LocalVars = LocalVars_t<Expr>;
     auto localVars = GetLocalVarTuple<LocalVars>();
     MakeAlikeLocalVars<LocalVars>(localVars, convertedArgs);
+
+    // tuple of references
+    auto inParams = GetInParams<Params>(params);
+    auto outParams = GetOutParams<Params>(params);
+
+    CopyIn<InParams>(inParams, argTuple);
     Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
+    CopyOut<OutParams>(outParams, argTuple);
 }
 
 } // namespace Emulation
@@ -983,7 +1067,7 @@ struct MyAddOp : ExprTmpl::Maker {
         auto _2 = DefineParam<2, VectorType<T>>();
         auto _3 = DefineParam<3, VectorType<T>>();
         auto _4 = DefineParam<4, VectorType<T>>();
-        auto _5 = DefineParam<5, VectorType<T>&, ParamUsage::out>();
+        auto _5 = DefineParam<5, VectorType<T>, ParamUsage::out>();
         auto tmp1 = DefineLocalVarLike<1>(_1);
         auto tmp2 = DefineLocalVarLike<2>(_3);
         return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2);
-- 
Gitee


From 6bff2f7a7f2a61edee4fb1f5139c7e7ef36c4e05 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Sat, 13 Sep 2025 11:04:45 +0800
Subject: [PATCH 020/116] Add code for resource clean-up

---
 .../expression_template/expr_template_demo.cpp  | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index f884f0bd9..b4500eb41 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -26,6 +26,20 @@ struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
 template <template <typename...> class T, typename U>
 inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
 
+template <
+    typename Tuple, typename Func,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
+                     int> = 0>
+void ForEach(Tuple&& tuple, Func&& func)
+{
+    std::apply(
+        [&func](auto&&... args) {
+            (std::forward<Func>(func)(std::forward<decltype(args)>(args)),
+             ...);
+        },
+        std::forward<Tuple>(tuple));
+}
+
 namespace TMP {
 
 template <typename... Ts>
@@ -1043,6 +1057,9 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     CopyIn<InParams>(inParams, argTuple);
     Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
     CopyOut<OutParams>(outParams, argTuple);
+
+    Util::ForEach(params, [](auto& arg) { arg.Clear(); });
+    Util::ForEach(localVars, [](auto& arg) { arg.Clear(); });
 }
 
 } // namespace Emulation
-- 
Gitee


From 7b6b0402c598b96e66b222a03106c95bd748572f Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Sat, 13 Sep 2025 14:08:03 +0800
Subject: [PATCH 021/116] add copyin

---
 .../include/device/device_elewise.h           |  45 ++++++++++++++----
 .../atvos_demo/include/device/device_tensor.h |   2 +-
 .../include/utils/expression/utility.h        |   1 +
 best_practices/atvos_demo/test/demo           | Bin 71816 -> 0 bytes
 best_practices/atvos_demo/test/main.cpp       |   2 +
 5 files changed, 40 insertions(+), 10 deletions(-)
 delete mode 100755 best_practices/atvos_demo/test/demo

diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index 776aead24..bcdd4dc30 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -98,14 +98,14 @@ public:
         // auto outParams = PrepareOutParams<OutParams>(params);
 
         // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
-        CopyIn(params, argTuple);
+        CopyIn<Params>(params, argTuple);
 
         // 把 config 复制到 GM
         uint8_t* configDevice;
         // CopyConfig(config, configDevice);
         auto totalArgs = std::tuple_cat(std::tuple(config.blockNum, configDevice), argTuple); // 普通变量 tuple
         // 传递参数到设备侧执行
-        LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, configDevice, argTuple);
+        // LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, configDevice, argTuple);
 
         // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
         CopyOut(params, argTuple);
@@ -117,13 +117,10 @@ public:
     }
 
 private:
-    template <typename InParams, typename ArgTup>
-    void CopyIn(InParams& inParams, ArgTup& argTuple){
-        // uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
-        // for(auto i = 0; i < tupeSize; i++) {
-        //     // TODO： host to device
-        //     // AscendC::DataCopy(AscendC::Std::get<i>(inParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
-        // }
+    template <typename Params, typename ParamTuple, typename ArgTup>
+    void CopyIn(ParamTuple& params, ArgTup& argTuple){
+        std::cout<<"test CopyIn"<<std::endl;
+        ForEachParamUsage<ParamTuple, Params>::check(params, 0);
     }
 
     template <typename OutParams, typename ArgTup>
@@ -135,6 +132,36 @@ private:
         // }
     }
 
+    // 基本情况：空列表
+    template <typename ParamTuple, typename...>
+    struct ForEachParamUsage {};
+
+    // 递归情况：非空类型列表
+    template <typename ParamTuple, typename Head, typename... Tail>
+    struct ForEachParamUsage<ParamTuple, Head, Tail...> {
+        static void check(const ParamTuple& paramTuple, std::size_t Index) {
+            std::size_t newIndex = Index;
+            std::cout<<"test ForEachParamUsage 2: "<< newIndex <<std::endl;
+            // if constexpr (std::is_base_of_v<ATVC::ExprTmpl::Param<0, void>, Head>) { // 检查 Head 是否是 Param 的派生类
+            // if constexpr (1) { 
+                newIndex = newIndex + 1;
+                if constexpr (Head::usage == ATVC::ExprTmpl::ParamUsage::in ||
+                              Head::usage == ATVC::ExprTmpl::ParamUsage::in_out) {
+                    uint8_t *xDevice;
+                    CHECK_ACL(aclrtMalloc((void **)&xDevice, sizeof(Head::Type) * 1024, ACL_MEM_MALLOC_HUGE_FIRST));
+                    std::cout << "ParamUsage::in found at index " << Head::number << std::get<Index>(paramTuple).GetSize()<< std::endl;
+                }
+            // }
+            ForEachParamUsage<ParamTuple, Tail...>::check(paramTuple, newIndex);
+        }
+    };
+
+    // 递归终止情况：空类型列表
+    template <typename ParamTuple>
+    struct ForEachParamUsage<ParamTuple> {
+        static void check(const ParamTuple& paramTuple, std::size_t Index) {std::cout<<"test ForEachParamUsage 3: " << std::endl;}
+    };
+
     template <typename ParamType, typename ArgTup>
     auto ConstructParam(ArgTup& args)
     {   // TODO device内存分配？
diff --git a/best_practices/atvos_demo/include/device/device_tensor.h b/best_practices/atvos_demo/include/device/device_tensor.h
index 14d477470..34e08538e 100644
--- a/best_practices/atvos_demo/include/device/device_tensor.h
+++ b/best_practices/atvos_demo/include/device/device_tensor.h
@@ -78,7 +78,7 @@ private:
     }
 
     T* ptr_{};
-    std::size_t len_{};
+    std::size_t len_{12};
     bool owned_{};
 };
 }
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/utils/expression/utility.h b/best_practices/atvos_demo/include/utils/expression/utility.h
index 824cb1a3e..7e56558ca 100644
--- a/best_practices/atvos_demo/include/utils/expression/utility.h
+++ b/best_practices/atvos_demo/include/utils/expression/utility.h
@@ -21,6 +21,7 @@ inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
 
 namespace TMP {
 
+// 定义类型列表
 template <typename... Ts>
 struct TypeList {};
 
diff --git a/best_practices/atvos_demo/test/demo b/best_practices/atvos_demo/test/demo
deleted file mode 100755
index a5c0c3ee00f3768202cdb86ab15faf0e45e2f720..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 71816
zcmeI1eQZ=$cEHcfGsa)Q7z{Y!!$X2r?6OS87!oICmGK7{s|H-+q+VL><$2~|&t|?f
z^9)0%6sL;XZM&*WNwa8olSNV00&Tj|D&1_QY->`fN>#N&OA_(N1`)JbMct@kHy^?(
zj(g61_t<aV%tZMk{iD*k=)QB$x#!%E-@Erd&*ka;BL~8v5O4~^tDv>!gf@9kfHxw`
zJ_+cBW=KF6Y=uVjYQW5X2~%Qu$AqzLLSIT2W{T?#lSVQ@Vo7e&8URb~o#YBr=ZS>T
zJb8VUr?LcZHu_0py>r*AzjL=w7g!c(K$yN|B*)S4C@!)<wIsbbmUCwOEO~x3H_BtC
zek`0ojr0Tw7}U>YNxqau-*Zz`j<;zQWkMHNj(BEZ$#K7faWu})n<B>XsOhgBmnOr5
zCBKIUGU<s2GO1mebZ)x5%eITjsR#GOO8Ho~H}4K?pF)QYKMrr@+Wz{xPw$+$vdP-_
zO8ZxT+Wf;OHqy9h4AdU^P$K`8x&%Pj=v7iZ&nt?mdA)FY_{kq*Ro(QjShKc9?KkS!
z&)2bk741>X!Spw1sMY>cb?h{cDCS_=f`(|&i28qEuGRj5I`)68W1p#GcZ~gbQvyrA
zq=v^1sgzT6CetO?DUKZ)$mDa*m_3nkK&i=WKBr2qU38TK?ONOM*x|?A-gLgCChU^4
zXE>L32fO#51a&Nx8AYKc%Vkw?iluzc&ZOPb>SP@2a;LKRtco1ak&ow2rE@8D)G1A8
zX(YJ*l4c}XJDo#IvTQ5cb;@ZMvQD<-xL{A@i!Pw&WYI26>9ODvB|{-&yC?F+tWoV!
z(#fTg8KV}bb8b58ux3yg)hQP9MU}O4_M}rZwn8y~!Y-tZHtDEjK1-x%_QvRSVQ2D_
z#*obx?20;-n$8xC1*hgDO}XTzk~?>z5_^z_PGj~;lSy<Vt()xRj`pE}0o4<W!@&4>
zU;nV`j`hIM$Z$WZXx`(M)$Ul&a<Tg%eEnhEeGRzVR-g>wKhi1l-Xq&3T*S0zqnJm(
zbh?#x`W3WMqKH{jA4mP#51+(ix)J`(*xWDw1s;tSyy^3Q)zne^D`%g_u2#TJWBZQQ
z!|*HPe|@o!+#rMp2cNN|-}KpA$gq_9bt#PgrU|V#!Lr>P&DtLE*_S>6SkvjV`@cI;
zpPd;|LpywS|2X45JD*|X-|MqClfk5f&yJv%(m|iyd?IvRSJZlI;mki@TCm{k?*lxy
zaOTRzIZM5L8*R4%Znu9rG#|P3=-Ftv>uvJojGy({_Hbf85(ZtT^+we1^XV<9_xtqK
zs89IxwW$B0Pv3z0OFsQx)L-}MTT#E|)9*t)99r)GOQ_%H=}Qx@Q&>3jPnSMyg?XCy
zI-E=C_0ZXy*1F68y}0<Dn>g<<+WL=&&cf}X`FGL&VQXT3;mqq7Z!IovWCmMc=4V?m
zzh}Yacdf+yt^48ZFR?xBau%*`KWkxK1LiB(=2grT*8|W&k{DAz@WIf00+;a|wo5i{
z8yDX!TnL@TKe1-Fp?nnJS9ADh0Itc|ZIJ`>HpbkxLYD#G3&jQfw*mb7eRrR}*4OsT
zpKZI_ckT-M<GP*g?>I0&p<}~KvD7E=AQr@gcpQJJ@8KDMy*F^&QJ6V;{H4&t%z*m)
z1&(*&%ug?UjQ$@T3F}yRe&*<(qCb3M9r+NMyuYdWM@^&Qc>s7BcN69?W(#uz<`tM5
zF|Wkjgt-}W3+7hLZJ1YKUX6JT<_P9?%xf{P!`y*+J?0IVH)8I@d=KV(F>k`W8S@s*
zTQPTGe&%b?fVl~C8|Db+4$PgHH)D=s-u}$jn#ORfIESy(98%#UAJH7F@Q?oAj2~I^
z9CqLw-nF{E62|#_jPvL~{ie14@&+wCjK1#jTCI0|<)b70_%3OU|BK%L6m!$+xZHyE
zxNbT;eck0o(@qmgZ{2uj2cH{sp4UpDP1bMG-=1`~&E8#HY`}$l6=e$b$im`c8D$*h
zEXw03{|e;=ls`dv73I%SzKL=K<0wTu0imakLPL3LXj5C4wsoRCh3)R6`o5K0>F-JU
zTTJ&!Hj^lR5c7HTjr(llSbl}$u^h#m!F-eb`c_9@Xn4`;KNmiD<DF}(u}b$#<Ng4B
z@Ux+le|(`o@W!_tYiNAW{*M{o;OgkXwk^?f4KFsn(3EQHiXL1I*KWMC*=qvlHac<?
zFuL{ozy6Ik@69yNUaY6KX0SiP-SmJ77+f76Y1<M%7k;kcFPmO$d7-VvdM(t}6(7N7
z-+b%FJA>XAVR13EL4Q!+3^jdV!Fj9c=N4SBj+<6Q2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf
z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwWK
z7eSyUp<9`2^5oTKPlmJ=;F^)F|01A&7|_GUk^Lh9y(^&i1oXau{zO2Z4Cuvx{%k;>
z4d_1z=$8Wet441#^Lk@tLYGz<y`jz1?=kwFyM4N}$><Ry?=`Y%!K>fQx{)7$x|pZp
z`EY^+tk6$@NJB!G8jU^|PUupLegb@A#@A}}P9xVF$-**)_ZPkX!$!YtWQUO}jofJD
z^~QuQvHhaan@oM&$YvwC|4$da`Rp+Mi$>>h+%|fnsW;*OXCh*_f8Gvmn)m!g$zZ?7
z&Hfr17<eSQW9abXUygRiV?D8M*d5=!cUQc3*Y4i2?mdshAAY2#cW1o!k$60s%-Fff
z=t-woO6POY?!B>iY%jG-??SILTnj^e+e1BeH-Oo<`;4sRGid6@Kf{OD`*p*kRy({0
zB4#gqmJj>Z^5H(1c`YCAqto;i<m%Tg2tjW+;Wz2B1z{MgX}6$U)84SOFa3>KxJ&11
z`Zq4^+e-hHP;0$g_y&2ORQfjq@3%^O3-G?Iw6_AkuS$CxFw;u=D&TXz(!Lt_JyqJ*
zKrQYTuD*DU_hCUh%+$26h1XUk{7vh!1?zy%Pk*Ha9l+;irF}ir+Se9rfUD-5tMuOp
zeEwD1J7E<1{U%+u;2xN&Y3I|tGQ@&SFca{n<GBHTy;$k#?OA~8_121xA)h^J0=@Gb
zzdB~Ga(mu+y9)LM?6h|P`9Bxn@7b&0Be$QZ)6T^}JKM4KTJz#|_-xU`z{gI^VORxh
z=kJZ@U%hTUd-Xc({mgz_fzJ@`m)qfUgYDm})6S#XVHGsAB-mBULH(>=w@=iu{~p?D
zzP!KoX+MCHmdkcyhB6jHxZVn8{g}@>{IPaewzL1YbzvPq;JbEK+dJWSU>!cM?f2q}
zs7&9}YCA*&`|$$WKkNM-53G~FMSq%a(EhTq&j$Rxb=V2xfpN|mfBw4@Rh{0(C-LF^
z$b7tZs?Ud8+P~V~jDa*x2)tjfo$B*vJ^F`goJ*en8i)q=g=cSvxtjLn@q4oZxPXOP
zoVlH!1m4RYJ)U+5+Nr%-?euH^>ho}1+pEt{8}0PhMDRTK_EGhB#6|yY;pO$_jT@i~
zTUm>om-dnQgY(-c$<F5(?+g07d~LXTzduiQ8d4x#M0*6+L-4$PxsLyw@#po!&HZN`
z|8L<qqfq@_cn|&CalXNI`x~@Jxlx~N!**(ovjgqzuzU_Tn3(%DA72Ben5fgv2(^Rb
z3C?T0PCMU3d$hWF_#@qZ^?c81d-b~gL7jH~-n0`O&p)7@-Xs6r%R_j}*jZ=!%R2TJ
z`~lI9@4al!4PI{>(7rZY{T<m%c5c)s_h|oBz~4LOKT^lPPtU7*y+N|*cE|FtJq1eH
z6KUnzld!#v%BiAVP+2>jBbPL~B<)N_opS6a)d_9OQCK+^2mB47oO04BxEMW=apKq-
z{t!?@BS-rCMwBW|PpDztR4iF2P|R*n#~yP>dX-A&)48-u0X_8CLyx`mc#s|sQQswZ
z`oxJ?5>iglnM{{lr>NYlN@nsor-b87<<(>+KVfH7%FP!`%APJmGM_DE9M?(V=xTbX
z6WFb?i$(jia&m6*G@K~fSx2R&v)R)a;?ooju)<ZT14sJ~?N|E`4=S}Z%_9d6Jhp#K
zjrH}9>__Y1*AMp{8Xmy5@W+wbf6&An96SnxzZ)w$Ct^xXmdmPuKZo);JCk-#tCKid
z8W?1qY{_vGLnFie18R4y`ys$l;u|`a%8Z`$%;V##2XQGiQ7WmDYZqM_%j3CI>0C-3
zbxPA&CqXZ!$3sxct0_B|$~d5g#||kbId*7(IF8Y4!?v&!YGwEcwwOxi)O5+Ab&*L=
zBuyW*AeP3}!~L5$h0QUQW4Tk=%8^pP%kMDIbINvYuM7W_usoT~=a%Q^kRMsA$R!5G
z$NTz+RW~jqdm>+~q<8G_V{UIcUs4lx$=NfEZ*;JGe<jID<)$;~+~jXNxB%##V>ijN
zt!&pRrz=}aWe{K{pTsH}nww6lLK^v1_c9Rd1!ASsS==Qk-J&O_xRlP}+AcsWmv^1m
zWNtb(F`dq&cBNCsgwxwa+f&y~*`+CnrB3ItJx{ttug3hqu22-#;gD?#Fr`Aqg_xda
z3}=XCz4Btkyha>zrpzXoN?|N(*l03YvDv*gy#3*|!DZ~q&Zd(XlE>EZ5z}3I&Eu+t
z7;e)n?mlm%da^Owb&KhVX&1Nl7n0~63qNi6H<Ooo!wFsJH3q)t@@hR_E|a_;Gu<6=
zJpb+<GluQt<V$=Gv*|%B_~Xmrgsv)^_^8&FAHn!Rtoj7+nz;Y-;e>WRALyU&+xUB;
zo$zrOb1P<!p9?2Y1N_~u1&k6LOmsg-MUL+zBPRNNfS;75c)rhzn1S;B9r;o+&3Otw
zzk!+V&bWWRKWH=;f_#t2<7YpXPhvdX#j(!!3_DEx4AxU3mBz{ACmW@wFw;;up6??r
zns~nd<Ni6G=l`sU??*|A?=7yIc)ow6c)D{8#{W6mh>3Auy5D%iTu5?1=%SOs$}0Q`
zmi+O24|3DQ&n<a+1$~d^vpt7pe?0%5n==C)Bxt^r@Rh0fUCjP?zE^257s~uQn8SkO
zzhL5-Ki|J}n)u-SnIE@zF%Zvx*T+r#2s;`X?ElAsc)rh>G4cCoa=sMoe-7)&g~!kL
zKCj_V07|@mJ<VHdTqgN5%&RdoX1*V~bC+t(y{A{yPwt=P4YaPo%<+7W)U@CQv7e_c
zuRpf`7gq4zARoSOikNsl2Y7vQ9Iqq#{}7r#_s{oISIv!3z4yoM+zG_<{nh&>ehTaT
ziQ`y?uycR^e9twit$@F9Dig=CbtMLqjmOV_*H3-U_%_o&pA+0J$M><pNE$08mh}7E
zY*lUN-+O;&Jj^oCb@T|XUuuWf-jWj*E)p0_Gv+^1wqSV_GtZy7(En@j+_AWncF@Ey
b6#|u>b;(WNw**{t<@q(9=gvStK!yJWYx{<@

diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index 745432dad..23307a3e0 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -29,10 +29,12 @@ struct MyAddOp : ATVC::ExprTmpl::Maker {
 };
 
 int main() {
+    std::cout<<"test in"<<std::endl;
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
     std::vector<float> v3(300);
     ATVC::Device::DeviceEleWise<MyAddOp> deviceOp;
     deviceOp.Run(v1, v2, v3); // 完成 core num计算 kernel launch
+    std::cout<<"test out"<<std::endl;
     return 0;
 }
\ No newline at end of file
-- 
Gitee


From a6886c941ad5cbbd4975557812bb8248ffb36889 Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Sat, 13 Sep 2025 15:40:39 +0800
Subject: [PATCH 022/116] add device copy in copy out

---
 .../include/device/device_elewise.h           | 196 ++++++++++--------
 .../atvos_demo/include/device/device_tensor.h |  65 +++---
 .../include/tile/tile_evaluator_common.h      |  60 +++++-
 3 files changed, 181 insertions(+), 140 deletions(-)

diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index bcdd4dc30..219bb16b4 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -37,30 +37,12 @@ __global__ __aicore__ void MyKernel(GM_ADDR configDevice, ArgTup argTuple)
 
 namespace ATVC::Device {
 
-// template <typename T>
-// struct Tensor {
-//     T* ptr;
-//     uint64_t len; // 元素个数
-// };
-
-
 template<class KernelOp, typename ArgTup>
-void LaunchKernelWithDataTuple(uint32_t blockNum, uint8_t* configDevice, ArgTup& argTuple)
+void LaunchKernelWithDataTuple(uint32_t blockNum, aclrtStream& stream, uint8_t* configDevice, ArgTup& argTuple)
 {
-    aclrtContext context;
-    int32_t deviceId = 0;
-    aclrtStream stream = nullptr;
-    InitializeACL(context, stream, deviceId);
-    MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, argTuple);
-    CleanACL(stream, context, deviceId);
+    // MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, argTuple);
 }
 
-// void ClearTensors(std::vector<Tensor<float>> params)
-// {
-//     return;
-// }
-
-    
 /*
 ExprMaker maker: 描述计算表达信息
 Args&&... args： 输入输出信息
@@ -90,25 +72,29 @@ public:
         using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
         // 参数打包成 tuple
         auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...); // 转发引用 需要用forward
-
+        aclrtContext context;
+        int32_t deviceId = 0;
+        aclrtStream stream = nullptr;
+        InitializeACL(context, stream, deviceId);
         // 得到 tuple<Tensor, ...>，向量变成了 Device 专用的 Tensor 类型
         auto params = PrepareParams<Params>(argTuple);
         // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
-        // auto inParams = PrepareInParams<InParams>(params);
-        // auto outParams = PrepareOutParams<OutParams>(params);
+        // tuple of references
+        auto inParams = GetInParams<Params>(params);
+        auto outParams = GetOutParams<Params>(params);
 
         // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
-        CopyIn<Params>(params, argTuple);
+        CopyIn<InParams>(inParams, argTuple);
 
         // 把 config 复制到 GM
         uint8_t* configDevice;
         // CopyConfig(config, configDevice);
         auto totalArgs = std::tuple_cat(std::tuple(config.blockNum, configDevice), argTuple); // 普通变量 tuple
         // 传递参数到设备侧执行
-        // LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, configDevice, argTuple);
-
+        LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, stream, configDevice, argTuple);
+        CleanACL(stream, context, deviceId);
         // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
-        CopyOut(params, argTuple);
+        CopyOut<OutParams>(outParams, argTuple);
 
         // Tensor 和 configDevice 需手工清理
         // ClearConfig(configDevice);
@@ -117,53 +103,44 @@ public:
     }
 
 private:
-    template <typename Params, typename ParamTuple, typename ArgTup>
-    void CopyIn(ParamTuple& params, ArgTup& argTuple){
-        std::cout<<"test CopyIn"<<std::endl;
-        ForEachParamUsage<ParamTuple, Params>::check(params, 0);
-    }
-
-    template <typename OutParams, typename ArgTup>
-    void CopyOut(OutParams& outParams, ArgTup& argTuple){
-        // uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
-        // for(auto i = 0; i < tupeSize; i++) {
-        //     // TODO： device to host
-        //     // AscendC::DataCopy(AscendC::Std::get<i>(outParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
-        // }
-    }
-
-    // 基本情况：空列表
-    template <typename ParamTuple, typename...>
-    struct ForEachParamUsage {};
-
-    // 递归情况：非空类型列表
-    template <typename ParamTuple, typename Head, typename... Tail>
-    struct ForEachParamUsage<ParamTuple, Head, Tail...> {
-        static void check(const ParamTuple& paramTuple, std::size_t Index) {
-            std::size_t newIndex = Index;
-            std::cout<<"test ForEachParamUsage 2: "<< newIndex <<std::endl;
-            // if constexpr (std::is_base_of_v<ATVC::ExprTmpl::Param<0, void>, Head>) { // 检查 Head 是否是 Param 的派生类
-            // if constexpr (1) { 
-                newIndex = newIndex + 1;
-                if constexpr (Head::usage == ATVC::ExprTmpl::ParamUsage::in ||
-                              Head::usage == ATVC::ExprTmpl::ParamUsage::in_out) {
-                    uint8_t *xDevice;
-                    CHECK_ACL(aclrtMalloc((void **)&xDevice, sizeof(Head::Type) * 1024, ACL_MEM_MALLOC_HUGE_FIRST));
-                    std::cout << "ParamUsage::in found at index " << Head::number << std::get<Index>(paramTuple).GetSize()<< std::endl;
-                }
-            // }
-            ForEachParamUsage<ParamTuple, Tail...>::check(paramTuple, newIndex);
-        }
-    };
+    template <typename Params, typename ParamTup>
+    auto GetInParams(ParamTup& params)
+    {
+        constexpr auto size = Util::TMP::Size_v<Params>;
+        static_assert(size == std::tuple_size_v<ParamTup>);
+        return GetInParamsImpl<Params>(
+            params, std::make_index_sequence<size>{});
+    }
 
-    // 递归终止情况：空类型列表
-    template <typename ParamTuple>
-    struct ForEachParamUsage<ParamTuple> {
-        static void check(const ParamTuple& paramTuple, std::size_t Index) {std::cout<<"test ForEachParamUsage 3: " << std::endl;}
-    };
+    template <typename Params, typename ParamTup>
+    auto GetOutParams(ParamTup& params)
+    {
+        constexpr auto size = Util::TMP::Size_v<Params>;
+        static_assert(size == std::tuple_size_v<ParamTup>);
+        return GetOutParamsImpl<Params>(
+            params, std::make_index_sequence<size>{});
+    }
+
+    template <typename InParams, typename InParamTup, typename ArgTup>
+    void CopyIn(InParamTup& inParams, ArgTup& args)
+    {
+        constexpr auto size = Util::TMP::Size_v<InParams>;
+        static_assert(size == std::tuple_size_v<InParamTup>);
+        CopyInImpl<InParams>(inParams, args,
+                                    std::make_index_sequence<size>{});
+    }
+
+    template <typename OutParams, typename OutParamTup, typename ArgTup>
+    void CopyOut(OutParamTup& outParams, ArgTup& args)
+    {
+        constexpr auto size = Util::TMP::Size_v<OutParams>;
+        static_assert(size == std::tuple_size_v<OutParamTup>);
+        CopyOutImpl<OutParams>(outParams, args,
+                                    std::make_index_sequence<size>{});
+    }
 
     template <typename ParamType, typename ArgTup>
-    auto ConstructParam(ArgTup& args)
+    constexpr auto ConstructParam(ArgTup& args)
     {   // TODO device内存分配？
         // 从 args 元组中获取第 ParamType::number - 1 个元素
         // 将 ParamType::Type 转换为非引用、非常量类型
@@ -172,7 +149,7 @@ private:
     }
 
     template <typename Params, typename ArgTup, std::size_t... Ints>
-    auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
+    constexpr auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
     {
         return std::make_tuple(
             ConstructParam<
@@ -181,27 +158,14 @@ private:
     }
 
     template <typename Params, typename ArgTup>
-    auto PrepareParams(ArgTup& argTuple)
+    constexpr auto PrepareParams(ArgTup& argTuple)
     {
         return PrepareParamsImpl<Params>(
             argTuple, std::make_index_sequence<Util::TMP::Size_v<Params>>{});
     }
 
-    // template <typename InParams, typename Params>
-    // InParams PrepareInParams(Params &params)
-    // {
-        
-    //     return Params{};
-    // }
-
-    // template <typename OutParams, typename Params>
-    // OutParams PrepareOutParams(Params &params)
-    // {
-    //     return params;
-    // }
-
     template <typename Params, std::size_t Index, typename ParamTup, typename ArgTup>
-    auto ConvertOneArg(ParamTup& params, ArgTup& args)
+    constexpr auto ConvertOneArg(ParamTup& params, ArgTup& args)
     {
         constexpr auto pos =
             Util::TMP::Find_v<ATVC::ExprTmpl::CheckVarNum<Index + 1>::template Checker, Params>;
@@ -213,7 +177,7 @@ private:
     }
 
     template <typename Params, typename ParamTup, typename ArgTup, std::size_t... Ints>
-    auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+    constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
                         std::index_sequence<Ints...>)
     {
         return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
@@ -226,6 +190,62 @@ private:
             params, args,
             std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
     }
+
+    template <typename Params, std::size_t Index, ATVC::ExprTmpl::ParamUsage... usages,
+          typename ParamTup>
+    constexpr auto GetOneParam(ParamTup& params)
+    {
+        using Param = Util::TMP::Get_t<Params, Index>;
+        if constexpr (((Param::usage == usages) || ...)) {
+            return std::forward_as_tuple(std::get<Index>(params));
+        } else {
+            return std::tuple<>{};
+        }
+    }
+
+    template <typename Params, typename ParamTup, std::size_t... Ints>
+    constexpr auto GetInParamsImpl(ParamTup& params, std::index_sequence<Ints...>)
+    {
+        return std::tuple_cat(
+            GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::in, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
+    }
+
+    template <typename Params, typename ParamTup, std::size_t... Ints>
+    constexpr auto GetOutParamsImpl(ParamTup& params, std::index_sequence<Ints...>)
+    {
+        return std::tuple_cat(
+            GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::out, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
+    }
+
+    template <typename InParams, std::size_t Index, typename T, typename ArgTup>
+    void CopyInOneParam(T& param, ArgTup& args)
+    {
+        using Param = Util::TMP::Get_t<InParams, Index>;
+        param.CopyIn(std::get<Param::number - 1>(args));
+    }
+
+    template <typename InParams, typename InParamTup, typename ArgTup,
+            std::size_t... Ints>
+    void CopyInImpl(InParamTup& inParams, ArgTup& args,
+                    std::index_sequence<Ints...>)
+    {
+        (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args), ...);
+    }
+
+    template <typename OutParams, std::size_t Index, typename T, typename ArgTup>
+    void CopyOutOneParam(T& param, ArgTup& args)
+    {
+        using Param = Util::TMP::Get_t<OutParams, Index>;
+        param.CopyOut(std::get<Param::number - 1>(args));
+    }
+
+    template <typename OutParams, typename OutParamTup, typename ArgTup,
+            std::size_t... Ints>
+    void CopyOutImpl(OutParamTup& outParams, ArgTup& args,
+                    std::index_sequence<Ints...>)
+    {
+        (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args), ...);
+    }
 };
 
 } // namespace ATVC::Device
diff --git a/best_practices/atvos_demo/include/device/device_tensor.h b/best_practices/atvos_demo/include/device/device_tensor.h
index 34e08538e..c7921d049 100644
--- a/best_practices/atvos_demo/include/device/device_tensor.h
+++ b/best_practices/atvos_demo/include/device/device_tensor.h
@@ -1,5 +1,5 @@
-
-
+#include <algorithm>
+#include "acl/acl.h"
 namespace ATVC::Device {
 
 template <typename T>
@@ -7,35 +7,8 @@ class Tensor {
 public:
     Tensor() = default;
     explicit Tensor(std::vector<T>& src)
-        : ptr_(src.data()), len_(src.size())
-    {
-    }
-    Tensor(const Tensor& rhs) : ptr_(rhs.ptr_), len_(rhs.len_)
-    {
-        if (rhs.owned_) {
-            throw std::logic_error(
-                "Cannot copy-construct an owned Tensor");
-        }
-    }
-    Tensor& operator=(const Tensor&) = delete;
-    Tensor(Tensor&& rhs) noexcept
-        : ptr_(rhs.ptr_), len_(rhs.len_), owned_(rhs.owned_)
-    {
-        rhs.owned_ = false;
-    }
-    Tensor& operator=(Tensor&& rhs) noexcept
     {
-        if (this != &rhs) {
-            Release();
-            ptr_ = rhs.ptr_;
-            len_ = rhs.len_;
-            owned_ = rhs.owned_;
-            rhs.owned_ = false;
-        }
-    }
-    ~Tensor()
-    {
-        Release();
+        SetSize(src.size());
     }
 
     T& operator[](std::size_t pos)
@@ -49,7 +22,7 @@ public:
 
     void Clear()
     {
-        Release();
+        delete[] ptr_;
         ptr_ = nullptr;
         len_ = 0;
     }
@@ -58,27 +31,37 @@ public:
     {
         if (ptr_ != nullptr) {
             throw std::logic_error(
-                "Tensor::SetSize can only be called on an empty object");
+                "MyTensor::SetSize can only be called on an empty object");
         }
-        ptr_ = new T[size];
+        aclrtMalloc((void **)&ptr_, size * sizeof(T), ACL_MEM_MALLOC_HUGE_FIRST);
+        std::cout<<"Malloc Tensor: "<<ptr_<< "   size: "<<size<<std::endl;
         len_ = size;
-        owned_ = true;
     }
     std::size_t GetSize() const
     {
         return len_;
     }
 
-private:
-    void Release()
+    void CopyIn(const std::vector<T>& src)
+    {
+        if (src.size() > len_) {
+            throw std::logic_error("Source vector is too big");
+        }
+        std::cout<<"CopyIn Tensor: "<<ptr_<< "   size: "<<src.size()<<std::endl;
+        aclrtMemcpy(ptr_, len_ * sizeof(T), src.data(), src.size() * sizeof(T), ACL_MEMCPY_HOST_TO_DEVICE);
+    }
+
+    void CopyOut(std::vector<T>& dst)
     {
-        // if (owned_) {
-        //     delete[] ptr_;
-        // }
+        if (dst.size() < len_) {
+            throw std::logic_error("Destination vector is too small");
+        }
+        std::cout<<"CopyOut Tensor: "<<ptr_<< "   size: "<<dst.size()<<std::endl;
+        aclrtMemcpy(dst.data(), dst.size() * sizeof(T), ptr_, len_ * sizeof(T), ACL_MEMCPY_DEVICE_TO_HOST);
     }
 
+private:
     T* ptr_{};
-    std::size_t len_{12};
-    bool owned_{};
+    std::size_t len_{};
 };
 }
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/tile/tile_evaluator_common.h b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
index 1144cac09..30dead9e5 100644
--- a/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
+++ b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
@@ -38,10 +38,17 @@ constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
 
 namespace Detail {
 
-template <typename T, std::size_t... Ints>
+template <typename Params, std::size_t... Ints>
+constexpr auto GetParamTupleImpl(std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              Params>::Type{}...);
+}
+
+template <typename LocalVars, std::size_t... Ints>
 constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
 {
-    using LocalVars = typename LocalVars<T>::Type;
     return std::make_tuple(
         typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
                               LocalVars>::Type{}...);
@@ -53,6 +60,12 @@ void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
     dst.resize(src.size());
 }
 
+// template <typename T>
+// void MakeAlikeDatum(Tensor<T>& dst, const Tensor<T>& src)
+// {
+//     dst.SetSize(src.GetSize());
+// }
+
 template <typename L, typename T, typename ArgTup>
 void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
 {
@@ -62,21 +75,31 @@ void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
     }
 }
 
-template <typename LocalVars, typename LocalVarTup, typename ArgTup, std::size_t... Ints>
+template <typename LocalVars, typename LocalVarTup, typename ArgTup,
+          std::size_t... Ints>
 void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
                             std::index_sequence<Ints...>)
 {
-    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(std::get<Ints>(localVars), args), ...);
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
+         std::get<Ints>(localVars), args),
+     ...);
 }
 
 } // namespace Detail
 
-template <typename T>
+template <typename Params>
+constexpr auto GetParamTuple()
+{
+    constexpr auto paramCount = Size_v<Params>;
+    return Detail::GetParamTupleImpl<Params>(
+        std::make_index_sequence<paramCount>{});
+};
+
+template <typename LocalVars>
 constexpr auto GetLocalVarTuple()
 {
-    using LocalVars = typename LocalVars<T>::Type;
     constexpr auto localVarCount = Size_v<LocalVars>;
-    return Detail::GetLocalVarTupleImpl<T>(
+    return Detail::GetLocalVarTupleImpl<LocalVars>(
         std::make_index_sequence<localVarCount>{});
 };
 
@@ -96,7 +119,7 @@ auto Evaluate(const Expression<T>& expr, Args&&... args)
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
     using LocalVars = LocalVars_t<T>;
     [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
-    auto localVars = GetLocalVarTuple<T>();
+    auto localVars = GetLocalVarTuple<LocalVars>();
     MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
     return Evaluator<T>{}(expr.data, argTuple, localVars);
 }
@@ -131,12 +154,11 @@ struct Evaluator<Param<N, T, U>> {
                               LocalVarTup& /*localVars*/) const
     {
         static_assert(N > 0, "Param number starts from 1");
-        static_assert(U == ParamUsage::in || std::is_reference_v<T>,
-                      "Only in-parameters can have value types");
         constexpr auto index = N - 1;
         using NthType =
             std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
-        if constexpr (std::is_same_v<T&, NthType> ||
+        if constexpr (std::is_same_v<T, NthType> ||
+                      std::is_same_v<T&, NthType> ||
                       std::is_same_v<T&&, NthType>) {
             return std::get<index>(args);
         } else {
@@ -213,6 +235,22 @@ void AddAssign(std::vector<T>& dst,
     }
 }
 
+// template <typename T>
+// void AddAssign(Tensor<T>& dst,
+//                const Tensor<T>& src1,
+//                const Tensor<T>& src2)
+// {
+//     if (src1.GetSize() != src2.GetSize()) {
+//         throw std::logic_error("Tensor sizes do not match");
+//     }
+//     if (src1.GetSize() != dst.GetSize()) {
+//         throw std::logic_error("Destination tensor should be like source");
+//     }
+//     for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+//         dst[i] = src1[i] + src2[i];
+//     }
+// }
+
 // Partial specializtion for E_x + E_y
 template <typename T, typename U>
 struct Evaluator<OpAdd<T, U>> {
-- 
Gitee


From 73b1535759d668010c120fc700dfba92e3fdf5bc Mon Sep 17 00:00:00 2001
From: wly451717 <wulinyu4@huawei.com>
Date: Sat, 13 Sep 2025 16:36:20 +0800
Subject: [PATCH 023/116] =?UTF-8?q?=E8=B0=83=E9=80=9Adevice=20->=20kernel?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../atvos_demo/include/block/block_elewise.h    |  2 ++
 .../atvos_demo/include/device/device_elewise.h  | 17 +++++++++++------
 .../atvos_demo/include/device/device_tensor.h   |  4 ++++
 .../atvos_demo/include/kernel/kernel_elewise.h  |  6 ++++--
 4 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index dd727a3e3..067a7447b 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -1,5 +1,7 @@
 #ifndef _BLOCK_ELE_WISE_H
 #define _BLOCK_ELE_WISE_H
+#include <functional>
+
 namespace ATVC::Block {
 
 struct Config {// block层的切分信息
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index 219bb16b4..725268698 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -28,11 +28,14 @@ void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
 }
 
 
-template<class KernelOp, typename ArgTup>
-__global__ __aicore__ void MyKernel(GM_ADDR configDevice, ArgTup argTuple)
+template<class KernelOp>
+__global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
 {
     KernelOp op;
-    // op.Run(configDevice, argTuple);
+    AscendC::printf("x: %p\n", x);
+    AscendC::printf("y: %p\n", y);
+    AscendC::printf("z: %p\n", z);
+    op.Run(configDevice, x, y, z);
 }
 
 namespace ATVC::Device {
@@ -40,7 +43,10 @@ namespace ATVC::Device {
 template<class KernelOp, typename ArgTup>
 void LaunchKernelWithDataTuple(uint32_t blockNum, aclrtStream& stream, uint8_t* configDevice, ArgTup& argTuple)
 {
-    // MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, argTuple);
+    uint8_t* z = std::get<0>(argTuple).GetPtr();
+    uint8_t* x = std::get<1>(argTuple).GetPtr();
+    uint8_t* y = std::get<2>(argTuple).GetPtr();
+    MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, x, y, z);
 }
 
 /*
@@ -89,9 +95,8 @@ public:
         // 把 config 复制到 GM
         uint8_t* configDevice;
         // CopyConfig(config, configDevice);
-        auto totalArgs = std::tuple_cat(std::tuple(config.blockNum, configDevice), argTuple); // 普通变量 tuple
         // 传递参数到设备侧执行
-        LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, stream, configDevice, argTuple);
+        LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, stream, configDevice, params);
         CleanACL(stream, context, deviceId);
         // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
         CopyOut<OutParams>(outParams, argTuple);
diff --git a/best_practices/atvos_demo/include/device/device_tensor.h b/best_practices/atvos_demo/include/device/device_tensor.h
index c7921d049..6e015fd11 100644
--- a/best_practices/atvos_demo/include/device/device_tensor.h
+++ b/best_practices/atvos_demo/include/device/device_tensor.h
@@ -41,6 +41,10 @@ public:
     {
         return len_;
     }
+    uint8_t* GetPtr() const
+    {
+        return (uint8_t* )ptr_;
+    }
 
     void CopyIn(const std::vector<T>& src)
     {
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index 5cfde1ddd..058ed4c0d 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -1,5 +1,6 @@
 #ifndef KERNEL_ELE_WISE_H
 #define KERNEL_ELE_WISE_H
+#include <functional>
 
 namespace ATVC::Kernel {
 struct Config{ // kernel 层的切分信息
@@ -34,8 +35,9 @@ public:
         // 配置Block层切分策略
         Block::Config configBlock = MakeConfig(configKernel);
 
-        auto expr = ExprMaker::template Get<AscendC::GlobalTensor>();
-        using Expr = decltype(expr);
+        auto expr = ExprMaker{}.template Get<AscendC::GlobalTensor>(); 
+        using Expr = typename decltype(expr)::Type;
+        // static_assert(!Expr::hasData, "设备侧使用的表达式模板不应包含数据");
         using Params = ATVC::ExprTmpl::Params_t<Expr>;
         using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
         using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
-- 
Gitee


From 3d9f3751ac1582b259506ae138248d36bdef52ef Mon Sep 17 00:00:00 2001
From: wulinyu <wulinyu4@huawei.com>
Date: Sat, 13 Sep 2025 17:03:53 +0800
Subject: [PATCH 024/116] add printf

---
 best_practices/atvos_demo/test/main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index 23307a3e0..bc81e4ecb 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -35,6 +35,6 @@ int main() {
     std::vector<float> v3(300);
     ATVC::Device::DeviceEleWise<MyAddOp> deviceOp;
     deviceOp.Run(v1, v2, v3); // 完成 core num计算 kernel launch
-    std::cout<<"test out"<<std::endl;
+    std::cout<<"test out !"<<std::endl;
     return 0;
 }
\ No newline at end of file
-- 
Gitee


From a7d678f15aa9a5456ffc20b2ff18ad0ac73ca0f7 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Sun, 14 Sep 2025 22:56:55 +0800
Subject: [PATCH 025/116] Optimize memory occupation of BinaryOp

---
 .../expr_template_demo.cpp                    | 222 ++++++++++++++++--
 1 file changed, 207 insertions(+), 15 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index b4500eb41..dcb6f962e 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -40,6 +40,173 @@ void ForEach(Tuple&& tuple, Func&& func)
         std::forward<Tuple>(tuple));
 }
 
+namespace Detail {
+
+// Storage implementations for different compression scenarios
+template <typename T1, typename T2, bool CompressFirst, bool CompressSecond>
+struct CompressedPairStorage;
+
+// Case 1: Neither can be compressed
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, false, false> {
+    T1 first;
+    T2 second;
+
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : first(std::forward<U1>(f)), second(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return first; }
+    const T1& First() const { return first; }
+    T2& Second() { return second; }
+    const T2& Second() const { return second; }
+};
+
+// Case 2: Only first can be compressed
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, true, false> : private T1 {
+    T2 second;
+
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : T1(std::forward<U1>(f)), second(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return static_cast<T1&>(*this); }
+    const T1& First() const { return static_cast<const T1&>(*this); }
+    T2& Second() { return second; }
+    const T2& Second() const { return second; }
+};
+
+// Case 3: Only second can be compressed
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, false, true> : private T2 {
+    T1 first;
+
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : T2(std::forward<U2>(s)), first(std::forward<U1>(f))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return first; }
+    const T1& First() const { return first; }
+    T2& Second() { return static_cast<T2&>(*this); }
+    const T2& Second() const { return static_cast<const T2&>(*this); }
+};
+
+// Case 4: Both can be compressed, different types
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, true, true> : private T1, private T2 {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : T1(std::forward<U1>(f)), T2(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return static_cast<T1&>(*this); }
+    const T1& First() const { return static_cast<const T1&>(*this); }
+    T2& Second() { return static_cast<T2&>(*this); }
+    const T2& Second() const { return static_cast<const T2&>(*this); }
+};
+
+// Case 5: Both can be compressed, same type
+template <typename T>
+struct CompressedPairStorage<T, T, true, true> : private T {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&&) : T(std::forward<U1>(f))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T& First() { return static_cast<T&>(*this); }
+    const T& First() const { return static_cast<const T&>(*this); }
+    T& Second() { return static_cast<T&>(*this); }
+    const T& Second() const { return static_cast<const T&>(*this); }
+};
+
+} // namespace Detail
+
+template <typename T1, typename T2>
+class CompressedPair
+    : private Detail::CompressedPairStorage<
+          T1, T2,
+          std::is_empty_v<T1> && !std::is_final_v<T1>,
+          std::is_empty_v<T2> && !std::is_final_v<T2>> {
+private:
+    using Storage = Detail::CompressedPairStorage<
+        T1, T2,
+        std::is_empty_v<T1> && !std::is_final_v<T1>,
+        std::is_empty_v<T2> && !std::is_final_v<T2>>;
+
+public:
+    using FirstType = T1;
+    using SecondType = T2;
+
+    // Default constructor
+    CompressedPair() = default;
+
+    // Perfect forwarding constructor
+    template<typename U1, typename U2>
+    CompressedPair(U1&& f, U2&& s)
+        : Storage(std::forward<U1>(f), std::forward<U2>(s)) {}
+
+    // Accessors for first element
+    T1& First() { return Storage::First(); }
+    const T1& First() const { return Storage::First(); }
+
+    // Accessors for second element
+    T2& Second() { return Storage::Second(); }
+    const T2& Second() const { return Storage::Second(); }
+
+    // Swap
+    void swap(CompressedPair& other) noexcept
+    {
+        using std::swap;
+        swap(First(), other.First());
+        swap(Second(), other.Second());
+    }
+};
+
+// Deduction guide
+template <typename T1, typename T2>
+CompressedPair(T1&& f, T2&& s)
+    -> CompressedPair<std::decay_t<T1>, std::decay_t<T2>>;
+
+// Swap function
+template <typename T1, typename T2>
+void swap(CompressedPair<T1, T2>& lhs, CompressedPair<T1, T2>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+// Equality comparison operators
+template <typename T1, typename T2>
+bool operator==(const CompressedPair<T1, T2>& lhs,
+                const CompressedPair<T1, T2>& rhs)
+{
+    return lhs.First() == rhs.First() && lhs.Second() == rhs.Second();
+}
+
+template <typename T1, typename T2>
+bool operator!=(const CompressedPair<T1, T2>& lhs,
+                const CompressedPair<T1, T2>& rhs)
+{
+    return !(lhs == rhs);
+}
+
 namespace TMP {
 
 template <typename... Ts>
@@ -358,7 +525,11 @@ struct CheckVarNum {
 };
 
 template <typename T, typename U>
-struct BinaryOp {
+struct BinaryOp : private Util::CompressedPair<T, U> {
+private:
+    using Storage = Util::CompressedPair<T, U>;
+
+public:
     static_assert(!(std::is_rvalue_reference_v<T> ||
                     std::is_rvalue_reference_v<U>),
                   "Rvalue references cannot be stored");
@@ -367,8 +538,12 @@ struct BinaryOp {
     using IsBinaryOp = void;
     using LhsType = T;
     using RhsType = U;
-    T lhs;
-    U rhs;
+
+    BinaryOp() = default;
+    constexpr BinaryOp(T t, U u) : Storage(t, u) {}
+
+    constexpr const T& GetLhs() const { return Storage::First(); }
+    constexpr const U& GetRhs() const { return Storage::Second(); }
 };
 
 namespace Detail {
@@ -468,7 +643,10 @@ template <typename T>
 using OutParams_t = typename OutParams<T>::Type;
 
 template <typename T, typename U>
-struct OpAssign : BinaryOp<T, U> {};
+struct OpAssign : BinaryOp<T, U> {
+    OpAssign() = default;
+    constexpr OpAssign(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
 
 template <typename T>
 template <typename U>
@@ -482,7 +660,10 @@ template <typename U>
 }
 
 template <typename T, typename U>
-struct OpAndThen : BinaryOp<T, U> {};
+struct OpAndThen : BinaryOp<T, U> {
+    OpAndThen() = default;
+    constexpr OpAndThen(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
 
 template <typename T, typename U>
 [[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
@@ -495,7 +676,10 @@ template <typename T, typename U>
 constexpr auto operator,(Expression<T>t, U&& u) = delete;
 
 template <typename T, typename U>
-struct OpAdd : BinaryOp<T, U> {};
+struct OpAdd : BinaryOp<T, U> {
+    OpAdd() = default;
+    constexpr OpAdd(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
 
 template <typename T, typename U>
 [[nodiscard]] constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
@@ -768,8 +952,8 @@ struct Evaluator<OpAssign<T, U>> {
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
-        return Assign(Evaluator<T>{}(op.lhs, args, localVars),
-                      Evaluator<U>{}(op.rhs, args, localVars));
+        return Assign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                      Evaluator<U>{}(op.GetRhs(), args, localVars));
     }
 };
 
@@ -784,8 +968,8 @@ struct Evaluator<OpAndThen<T, U>> {
                     LocalVarTup& localVars) const
     {
         // operator, evaluates sequentially
-        return Evaluator<T>{}(op.lhs, args, localVars),
-               Evaluator<U>{}(op.rhs, args, localVars);
+        return Evaluator<T>{}(op.GetLhs(), args, localVars),
+               Evaluator<U>{}(op.GetRhs(), args, localVars);
     }
 };
 
@@ -844,8 +1028,8 @@ struct Evaluator<OpAdd<T, U>> {
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
-        return Add(Evaluator<T>{}(op.lhs, args, localVars),
-                   Evaluator<U>{}(op.rhs, args, localVars));
+        return Add(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                   Evaluator<U>{}(op.GetRhs(), args, localVars));
     }
 };
 
@@ -859,9 +1043,9 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
-        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
-                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
-                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
+        return AddAssign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                         Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
+                         Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
     }
 };
 
@@ -1102,6 +1286,10 @@ int main() // NOLINT(bugprone-exception-escape)
     [[maybe_unused]] auto result2 = _1 + Expression{3};
     [[maybe_unused]] auto result3 = 42 + _1;
     auto result4 = (Expression<Param<2, int&, ParamUsage::out>>{} = result3);
+    std::cout << "sizeof result1 is " << sizeof result1 << '\n';
+    std::cout << "sizeof result2 is " << sizeof result2 << '\n';
+    std::cout << "sizeof result3 is " << sizeof result3 << '\n';
+    std::cout << "sizeof result4 is " << sizeof result4 << '\n';
     //TYPE_DISPLAY(OutParams_t<decltype(result4)::Type>{});
     int out{};
     Evaluate(result4, 1, out);
@@ -1115,6 +1303,7 @@ int main() // NOLINT(bugprone-exception-escape)
                     tmp2 = tmp1 + tmp1,
                     outVar = tmp2,
                     tmp2);
+    std::cout << "sizeof result5 is " << sizeof result5 << '\n';
     std::cout << Evaluate(result5, 1, 2) << '\n';
     //TYPE_DISPLAY(LocalVars_t<decltype(result5)::Type>{});
     std::cout << out << '\n';
@@ -1135,6 +1324,9 @@ int main() // NOLINT(bugprone-exception-escape)
     std::vector<float> v3(300, 3.0F);
     std::vector<float> v4(300, 4.0F);
     std::vector<float> v5(300);
+    std::cout
+        << "sizeof(decltype(MyAddOp<float>{}.Get<Tensor>())) is "
+        << sizeof(decltype(MyAddOp<float>{}.Get<Tensor>())) << '\n';
     Emulation::DoElementwise(MyAddOp<float>{}, v1, v2, v3, v4, v5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
-- 
Gitee


From 243cc537e408daa5c7e2e6e6662fd92aacf6de29 Mon Sep 17 00:00:00 2001
From: wulinyu <wulinyu4@huawei.com>
Date: Thu, 18 Sep 2025 10:35:30 +0800
Subject: [PATCH 026/116] block add tensor to manage ub and gm

---
 .../atvos_demo/include/block/block_elewise.h  | 143 ++++++++++++++----
 .../atvos_demo/include/block/block_tensor.h   |  68 +++++++++
 .../include/device/device_elewise.h           |   3 +-
 .../include/kernel/kernel_elewise.h           |   2 +-
 .../atvos_demo/include/tile/tile_elewise.h    |   1 +
 .../atvos_demo/include/tile/tile_operator.h   |  25 ++-
 .../include/utils/buf_pool/ele_buf_pool.h     |  38 +++++
 best_practices/atvos_demo/test/main.cpp       |   4 +-
 8 files changed, 241 insertions(+), 43 deletions(-)
 create mode 100644 best_practices/atvos_demo/include/block/block_tensor.h
 create mode 100644 best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index 067a7447b..03a7c5c1c 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -1,6 +1,8 @@
 #ifndef _BLOCK_ELE_WISE_H
 #define _BLOCK_ELE_WISE_H
 #include <functional>
+#include "block_tensor.h"
+#include "../utils/buf_pool/ele_buf_pool.h"
 
 namespace ATVC::Block {
 
@@ -13,7 +15,7 @@ struct Config {// block层的切分信息
 template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
 class BlockEleWise{
 public: 
-    BlockEleWise(){}
+    __aicore__ inline BlockEleWise(){}
 
     template <typename ArgTup>
     __aicore__ inline Tile::Config MakeConfig(const Config& configBlock, ArgTup& argTuple)
@@ -23,57 +25,146 @@ public:
     }
 
     template <typename ArgTup>
-    __aicore__ inline int64_t Run(const Config& configBlock, ArgTup& argTuple)
+    __aicore__ inline void Run(const Config& configBlock, ArgTup& argTuple)
     {
         // 配置规划，特别是需要确定使用的 Local Memory 大小
         Tile::Config configTile = MakeConfig(configBlock, argTuple);
-        auto expr = ExprMaker::template Get<AscendC::LocalTensor>();
+        auto expr = ExprMaker{}.template Get<ATVC::Block::Tensor>();
         using Expr = decltype(expr);
-        using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>;
+        using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>; // TODO: 这里 临时buffer不应该由Expr生成， 应该在host 切分信息计算获得。存放在configBlock中？
         using Params = ATVC::ExprTmpl::Params_t<Expr>;
         using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
         using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
 
-        // 得到 tuple<LocalTensor, ...>，向量变成了 LocalTensor 类型
-        auto params = PrepareParams<Params>(configTile);
-        // 下面得到 tuple<Tensor&, ...>，即对 Tensor 的访问都成了引用
-        auto inParams = PrepareInParams<InParams>(params);
-        auto outParams = PrepareOutParams<InParams>(params);
+        // 得到 tuple<Block::Tensor, ...>，向量变成了 Block::Tensor 类型
+        auto params = PrepareParams<Params>(argTuple);
+        // 下面得到 tuple<LocalTensor&, ...>，即对 LocalTensor 的访问都成了引用, 完成LocalTensor的资源初始化
+        auto inParams = GetInParams<Params>(params);
+        auto outParams = GetOutParams<Params>(params);
         // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
-        auto localVars = PrepareLocalVars<LocalVars>(params);
+        // auto localVars = PrepareLocalVars<LocalVars>(params);
 
-        // 把 argTuple 里的向量替换成 params 里的对应 Tensor
-        auto combinedArgs = CombineArgs(params, argTuple);
+        // 把 argTuple 里的向量替换成 params 里的对应 Local Tensor引用
+        auto combinedArgs = CombineArgs(params);
 
         // 循环执行
         for (int i = 0; i < configTile.wholeBlockCount; ++i) {
-            CopyIn<InParams>(inParams, argTuple, configTile);
-            Tile::Evaluate<Expr>(combinedArgs, localVars);
-            CopyOut<OutParams>(outParams, argTuple, configTile);
+            CopyIn(inParams, configTile);
+            Tile::Evaluate<Expr>(combinedArgs);
+            CopyOut(outParams, configTile);
         }
         // 尾块的处理
         for (int i = 0; i < configTile.tileBlockCount; ++i) {
-            CopyIn<InParams>(inParams, argTuple, configTile);
-            Tile::Evaluate<Expr>(combinedArgs, localVars);
-            CopyOut<OutParams>(outParams, argTuple, configTile);
+            CopyIn(inParams, configTile);
+            Tile::Evaluate<Expr>(combinedArgs);
+            CopyOut(outParams, configTile);
         }
     }
 private:
-    template <typename InParams, typename ArgTup>
-    __aicore__ inline void CopyIn(InParams& inParams, ArgTup& argTuple, Tile::Config &configTile){
-        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
+template <typename... Ts>
+auto CombineArgs(const AscendC::Std::tuple<Ts...>& params)
+{
+    return AscendC::Std::apply([](const auto&... tensors) {
+        return AscendC::Std::make_tuple(*(tensors.GetUbTensor())...);
+    }, params);
+
+}
+
+    template <typename ParamType, typename ArgTup>
+    constexpr auto ConstructParam(ArgTup& args)
+    {   // 构建 tensor 关联gmTensor信息
+        return typename AscendC::Std::decay_t<typename ParamType::Type>(
+            AscendC::Std::get<ParamType::number - 1>(args));
+    }
+
+    template <typename Params, typename ArgTup, size_t... Ints>
+    constexpr auto PrepareParamsImpl(ArgTup& args, AscendC::Std::index_sequence<Ints...>)
+    {
+        return AscendC::Std::make_tuple(
+            ConstructParam<
+                Util::TMP::FindUnique_t<ATVC::ExprTmpl::CheckVarNum<Ints + 1>::template Checker, Params>>(
+                args)...);
+    }
+
+    template <typename Params, typename ArgTup>
+    constexpr auto PrepareParams(ArgTup& argTuple)
+    {
+        return PrepareParamsImpl<Params>(
+            argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
+    }
+    template <typename Params, typename ArgTup>
+    constexpr auto PrepareLocalVars(ArgTup& argTuple)
+    {
+        return PrepareParamsImpl<Params>(
+            argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
+    }
+
+    template <typename Params, size_t Index, ATVC::ExprTmpl::ParamUsage... usages, typename ParamTup>
+    constexpr auto GetOneParam(ParamTup& params)
+    {
+        using Param = Util::TMP::Get_t<Params, Index>;
+        if constexpr (((Param::usage == usages) || ...)) {
+            auto tensor = AscendC::Std::forward_as_tuple(AscendC::Std::get<Index>(params));
+            //todo: 分配 UB tesnor给当前输入输出
+            if constexpr (Param::usage == ATVC::ExprTmpl::ParamUsage::in || Param::usage == ATVC::ExprTmpl::ParamUsage::in_out) {
+                tensor.AssignUbTensor(bufPool_);
+            } else if constexpr (Param::usage == ATVC::ExprTmpl::ParamUsage::out) {
+
+            }
+            return AscendC::Std::forward_as_tuple(AscendC::Std::get<Index>(params));
+        } else {
+            return AscendC::Std::tuple<>{};
+        }
+    }
+
+    template <typename Params, typename ParamTup, size_t... Ints>
+    constexpr auto GetInParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
+    {
+        return AscendC::Std::tuple_cat(
+            GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::in, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
+    }
+
+    template <typename Params, typename ParamTup, size_t... Ints>
+    constexpr auto GetOutParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
+    {
+        return AscendC::Std::tuple_cat(
+            GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::out, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
+    }
+    template <typename Params, typename ParamTup>
+    auto GetInParams(ParamTup& params)
+    {
+        constexpr auto size = Util::TMP::Size_v<Params>;
+        static_assert(size == AscendC::Std::tuple_size_v<ParamTup>);
+        return GetInParamsImpl<Params>(
+            params, AscendC::Std::make_index_sequence<size>{});
+    }
+
+    template <typename Params, typename ParamTup>
+    auto GetOutParams(ParamTup& params)
+    {
+        constexpr auto size = Util::TMP::Size_v<Params>;
+        static_assert(size == AscendC::Std::tuple_size_v<ParamTup>);
+        return GetOutParamsImpl<Params>(
+            params, AscendC::Std::make_index_sequence<size>{});
+    }
+
+    template <typename InParams>
+    __aicore__ inline void CopyIn(InParams& inParams, Tile::Config &configTile){
+        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(InParams)>::value;
         for(auto i = 0; i < tupeSize; i++) {
-            AscendC::DataCopy(AscendC::Std::get<i>(inParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
+            AscendC::Std::get<i>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
         }
     }
 
-    template <typename OutParams, typename ArgTup>
-    __aicore__ inline void CopyOut(OutParams& outParams, ArgTup& argTuple, Tile::Config &configTile){
-        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(argTuple)>::value;
+    template <typename OutParams>
+    __aicore__ inline void CopyOut(OutParams& outParams, Tile::Config &configTile){
+        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(OutParams)>::value;
         for(auto i = 0; i < tupeSize; i++) {
-            AscendC::DataCopy(AscendC::Std::get<i>(outParams), AscendC::Std::get<i>(argTuple), configTile.basicNum);
+            AscendC::Std::get<i>(outParams).CopyOut(configTile.gmOffset, configTile.basicNum);
         }
     }
+private:
+    ATVC::UTILS::EleBufPool bufPool_; // kernel调用block的时候 传入bufPool(kernel层实例化bufPool_，多次调用kernel的时候可以复用)
 };
 } // namespace ATVC::Block
 
diff --git a/best_practices/atvos_demo/include/block/block_tensor.h b/best_practices/atvos_demo/include/block/block_tensor.h
new file mode 100644
index 000000000..a6f9ff264
--- /dev/null
+++ b/best_practices/atvos_demo/include/block/block_tensor.h
@@ -0,0 +1,68 @@
+#ifndef _ATVC_BLOCK_TENSOR_H
+#define _ATVC_BLOCK_TENSOR_H
+#include "../utils/buf_pool/ele_buf_pool.h"
+#include "../tile/tile_operator.h"
+
+
+namespace ATVC::Block {
+
+template <typename T>
+class Tensor {
+public:
+    __aicore__ inline Tensor() = default;
+
+    __aicore__ inline Tensor(AscendC::GlobalTensor<T>& gmTensor, bool isIn)
+    {
+        SetGmTensor(gmTensor);
+        isInTensor = isIn;
+    }
+
+    __aicore__ inline void SetSize(std::size_t size)
+    {
+        size_ = size;
+    }
+    __aicore__ inline uint64_t GetSize() const
+    {
+        return size_;
+    }
+    __aicore__ inline uint64_t GetCurGmOffset() const
+    {
+        return curGmOffset_;
+    }
+
+    __aicore__ inline AscendC::LocalTensor<T>* GetUbTensor() const
+    {
+        return ubTensor_;
+    }
+    __aicore__ inline AscendC::GlobalTensor<T>* GetGmTensor() const
+    {
+        return gmTensor_;
+    }
+    __aicore__ inline void AssignUbTensor(ATVC::UTILS::EleBufPool &bufPool)
+    {
+        AscendC::LocalTensor<T>* ubTensor = &(bufPool.inQueue.template AllocTensor<T>());
+        ubTensor_ = ubTensor;
+    }
+    __aicore__ inline void SetGmTensor(AscendC::GlobalTensor<T>* gmTensor) const
+    {
+        gmTensor_ = gmTensor;
+    }
+
+    __aicore__ inline void CopyIn(uint64_t offset, uint32_t copyCnt)
+    {
+        ATVC::Tile::CopyIn(ubTensor_, gmTensor_[offset], copyCnt);
+    }
+
+    __aicore__ inline void CopyOut(uint64_t offset, uint32_t copyCnt)
+    {
+        ATVC::Tile::CopyIn(gmTensor_[offset], ubTensor_, copyCnt);
+    }
+
+    AscendC::LocalTensor<T>* ubTensor_;
+    AscendC::GlobalTensor<T>* gmTensor_;
+    uint64_t size_;
+    uint64_t curGmOffset_;
+    bool isInTensor;
+};
+}
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index 725268698..b794745d4 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -32,6 +32,7 @@ template<class KernelOp>
 __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
 {
     KernelOp op;
+    AscendC::TPipe myPipe;
     AscendC::printf("x: %p\n", x);
     AscendC::printf("y: %p\n", y);
     AscendC::printf("z: %p\n", z);
@@ -146,7 +147,7 @@ private:
 
     template <typename ParamType, typename ArgTup>
     constexpr auto ConstructParam(ArgTup& args)
-    {   // TODO device内存分配？
+    {   // device内存分配
         // 从 args 元组中获取第 ParamType::number - 1 个元素
         // 将 ParamType::Type 转换为非引用、非常量类型
         return typename std::decay_t<typename ParamType::Type>(
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index 058ed4c0d..4e90c3df1 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -30,7 +30,7 @@ public:
 
     // 运行接口
     template <typename... Args>
-    __aicore__ inline int64_t Run(GM_ADDR configKernel, Args... args)
+    __aicore__ inline void Run(GM_ADDR configKernel, Args... args)
     {
         // 配置Block层切分策略
         Block::Config configBlock = MakeConfig(configKernel);
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
index bbd5f43a7..90481c07a 100644
--- a/best_practices/atvos_demo/include/tile/tile_elewise.h
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -10,6 +10,7 @@ struct Config {//tile层的切分信息
     uint32_t wholeBlockCount = 0;
     uint32_t tileBlockCount = 0;
     uint32_t basicNum = 0;
+    uint64_t gmOffset= 0;
 };
 
 template <typename T>
diff --git a/best_practices/atvos_demo/include/tile/tile_operator.h b/best_practices/atvos_demo/include/tile/tile_operator.h
index 6075c2ceb..49c0a3507 100644
--- a/best_practices/atvos_demo/include/tile/tile_operator.h
+++ b/best_practices/atvos_demo/include/tile/tile_operator.h
@@ -1,17 +1,16 @@
+#ifndef __ATVC_TILE_OPERATOR_H__
+#define __ATVC_TILE_OPERATOR_H__
 #include "tile_evaluator_common.h"
 
-// Partial specializtion for E_z = E_x + E_y
-template <typename T, typename U, typename V>
-struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
-    using Type = void;
+namespace ATVC::Tile {
+    template <typename T>
+    __aicore__ inline void CopyIn(AscendC::LocalTensor<T> dst, AscendC::GlobalTensor<T> src, uint32_t copyCnt){
+        AscendC::DataCopy(dst, src, copyCnt);
+    }
 
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return AddAssign(Evaluator<T>{}(op.lhs, args, localVars),
-                         Evaluator<U>{}(op.rhs.lhs, args, localVars),
-                         Evaluator<V>{}(op.rhs.rhs, args, localVars));
+    template <typename T>
+    __aicore__ inline void CopyIn(AscendC::GlobalTensor<T> dst, AscendC::LocalTensor<T> src, uint32_t copyCnt){
+        AscendC::DataCopy(dst, src, copyCnt);
     }
-};
+}
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h b/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h
new file mode 100644
index 000000000..fe113d76d
--- /dev/null
+++ b/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h
@@ -0,0 +1,38 @@
+#ifndef __ATVC_UTILS_ELE_BUF_POOL_H__
+#define __ATVC_UTILS_ELE_BUF_POOL_H__
+namespace ATVC::UTILS {
+
+class EleBufPool {
+public:
+    __aicore__ inline EleBufPool(uint32_t inBufNum, uint64_t inBytes, uint32_t outBufNum, uint64_t outBytes){
+        GetTPipePtr()->InitBuffer(inQueue, inBufNum, inBytes);
+        GetTPipePtr()->InitBuffer(outQueue, outBufNum, outBytes);
+    }
+
+    // __aicore__ inline AscendC::LocalTensor<uint8_t>& GetInTnesor(){
+    //     AscendC::LocalTensor<uint8_t> inTensor = inQueue.template AllocTensor<uint8_t>();
+    //     return inTensor;
+    // }
+    // __aicore__ inline void GetOutTnesor(AscendC::LocalTensor<uint8_t> &outTensor){
+    //     outTensor = outQueue.template AllocTensor<uint8_t>();
+    // }
+
+    __aicore__ inline void EnqueInTnesor(AscendC::LocalTensor<uint8_t>* inTensor){
+        inQueue.EnQue(*inTensor);
+    }
+    __aicore__ inline void EnqueOutTnesor(AscendC::LocalTensor<uint8_t>* outTensor){
+        outQueue.EnQue(*outTensor);
+    }
+    __aicore__ inline void DequeInTnesor(){
+        inQueue.template DeQue<uint8_t>();
+    }
+    __aicore__ inline void  DequeOutTnesor(AscendC::LocalTensor<uint8_t>* outTensor){
+        outQueue.template DeQue<uint8_t>();
+    }
+
+    AscendC::TQue<AscendC::QuePosition::VECIN, 1> inQueue;
+    AscendC::TQue<AscendC::QuePosition::VECOUT, 1> outQueue;
+    AscendC::TBuf<AscendC::QuePosition::VECCALC> tempQueue;
+};
+}
+#endif
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index bc81e4ecb..78f0c3655 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -5,7 +5,7 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
-#include <kernel_operator.h>
+#include "kernel_operator.h"
 #include "../include/utils/expression/expression.h"
 #include "../include/tile/tile_elewise.h"
 #include "../include/block/block_elewise.h"
@@ -18,7 +18,7 @@
 // 描述计算逻辑
 struct MyAddOp : ATVC::ExprTmpl::Maker {
     template <template <typename> class VectorType>
-    constexpr auto Get() const
+    __host_aicore__ constexpr auto Get() const
     {
         using namespace ATVC::ExprTmpl;
         auto _1 = DefineParam<1, VectorType<float>>();
-- 
Gitee


From 15e418f5f2c6f14fe95934d7a2edae549a80ed4d Mon Sep 17 00:00:00 2001
From: wulinyu <wulinyu4@huawei.com>
Date: Thu, 18 Sep 2025 20:10:01 +0800
Subject: [PATCH 027/116] fix compile err

---
 .../atvos_demo/include/block/block_elewise.h  | 124 +++++++++---------
 .../include/kernel/kernel_elewise.h           |   1 +
 .../atvos_demo/include/tile/tile_elewise.h    |   6 +-
 .../include/utils/buf_pool/ele_buf_pool.h     |   4 +-
 best_practices/atvos_demo/test/main.cpp       |   2 -
 5 files changed, 69 insertions(+), 68 deletions(-)

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index 03a7c5c1c..ca47c76e0 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -15,7 +15,9 @@ struct Config {// block层的切分信息
 template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
 class BlockEleWise{
 public: 
-    __aicore__ inline BlockEleWise(){}
+    __aicore__ inline BlockEleWise(){
+        bufPool_.InitBufPool(2, 1024, 1, 2048); // Todo: 需要通过tile layout配置
+    }
 
     template <typename ArgTup>
     __aicore__ inline Tile::Config MakeConfig(const Config& configBlock, ArgTup& argTuple)
@@ -27,58 +29,57 @@ public:
     template <typename ArgTup>
     __aicore__ inline void Run(const Config& configBlock, ArgTup& argTuple)
     {
-        // 配置规划，特别是需要确定使用的 Local Memory 大小
-        Tile::Config configTile = MakeConfig(configBlock, argTuple);
-        auto expr = ExprMaker{}.template Get<ATVC::Block::Tensor>();
-        using Expr = decltype(expr);
-        using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>; // TODO: 这里 临时buffer不应该由Expr生成， 应该在host 切分信息计算获得。存放在configBlock中？
-        using Params = ATVC::ExprTmpl::Params_t<Expr>;
-        using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
-        using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
-
-        // 得到 tuple<Block::Tensor, ...>，向量变成了 Block::Tensor 类型
-        auto params = PrepareParams<Params>(argTuple);
-        // 下面得到 tuple<LocalTensor&, ...>，即对 LocalTensor 的访问都成了引用, 完成LocalTensor的资源初始化
-        auto inParams = GetInParams<Params>(params);
-        auto outParams = GetOutParams<Params>(params);
-        // 初始化局部变量及其需要的空间，结果是 tuple<LocalTensor, ...>
-        // auto localVars = PrepareLocalVars<LocalVars>(params);
-
-        // 把 argTuple 里的向量替换成 params 里的对应 Local Tensor引用
-        auto combinedArgs = CombineArgs(params);
-
-        // 循环执行
-        for (int i = 0; i < configTile.wholeBlockCount; ++i) {
-            CopyIn(inParams, configTile);
-            Tile::Evaluate<Expr>(combinedArgs);
-            CopyOut(outParams, configTile);
-        }
-        // 尾块的处理
-        for (int i = 0; i < configTile.tileBlockCount; ++i) {
-            CopyIn(inParams, configTile);
-            Tile::Evaluate<Expr>(combinedArgs);
-            CopyOut(outParams, configTile);
-        }
+        // // 配置规划，特别是需要确定使用的 Local Memory 大小
+        // Tile::Config configTile = MakeConfig(configBlock, argTuple);
+        // auto expr = ExprMaker{}.template Get<ATVC::Block::Tensor>();
+        // using Expr = decltype(expr);
+        // using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>; // TODO: 这里 临时buffer不应该由Expr生成， 应该在host 切分信息计算获得。存放在configBlock中？
+        // using Params = ATVC::ExprTmpl::Params_t<Expr>;
+        // using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
+        // using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
+
+        // // 得到 tuple<Block::Tensor, ...>，向量变成了 Block::Tensor 类型
+        // auto params = PrepareParams<Params>(argTuple);
+        // // 下面得到 tuple<Block::Tensor&, ...>，即对 Tensor 的访问都成了引用
+        // auto inParams = GetInParams<Params>(params);
+        // auto outParams = GetOutParams<Params>(params);
+        // // 初始化局部变量及其需要的空间，
+        // // auto localVars = PrepareLocalVars<LocalVars>(params);
+
+        // // 循环执行
+        // for (int i = 0; i < configTile.wholeBlockCount; ++i) {
+        //     // 把 argTuple 里的向量替换成 params 里的对应 Local Tensor引用
+        //     auto combinedArgs = CombineArgs(inParams, outParams); // 这里 in/out的类型不一样，去申请ub tensor 的操作不一样 输入输出单独传递
+        //     CopyIn(inParams, configTile);
+        //     Tile::Evaluate<Expr>(combinedArgs);
+        //     CopyOut(outParams, configTile);
+        // }
+        // // 尾块的处理
+        // for (int i = 0; i < configTile.tileBlockCount; ++i) {
+
+        // }
     }
 private:
-template <typename... Ts>
-auto CombineArgs(const AscendC::Std::tuple<Ts...>& params)
+template <typename ArgIn, typename ArgOut>
+__aicore__ inline auto CombineArgs(ArgIn& inParams, ArgOut& outParams)
 {
-    return AscendC::Std::apply([](const auto&... tensors) {
-        return AscendC::Std::make_tuple(*(tensors.GetUbTensor())...);
-    }, params);
-
+    auto sizeIn = AscendC::Std::tuple_size<ArgIn>::value;
+    auto sizeOut = AscendC::Std::tuple_size<ArgOut>::value;
+    AscendC::LocalTensor<float> in1 = bufPool_.inQueue.template AllocTensor<float>();
+    AscendC::LocalTensor<float> in2 = bufPool_.inQueue.template AllocTensor<float>();
+    AscendC::LocalTensor<float> out1 = bufPool_.outQueue.template AllocTensor<float>();
+    return AscendC::Std::make_tuple(in1, in2, out1);
 }
 
     template <typename ParamType, typename ArgTup>
-    constexpr auto ConstructParam(ArgTup& args)
+    __aicore__ inline constexpr auto ConstructParam(ArgTup& args)
     {   // 构建 tensor 关联gmTensor信息
         return typename AscendC::Std::decay_t<typename ParamType::Type>(
             AscendC::Std::get<ParamType::number - 1>(args));
     }
 
     template <typename Params, typename ArgTup, size_t... Ints>
-    constexpr auto PrepareParamsImpl(ArgTup& args, AscendC::Std::index_sequence<Ints...>)
+    __aicore__ inline constexpr auto PrepareParamsImpl(ArgTup& args, AscendC::Std::index_sequence<Ints...>)
     {
         return AscendC::Std::make_tuple(
             ConstructParam<
@@ -87,20 +88,20 @@ auto CombineArgs(const AscendC::Std::tuple<Ts...>& params)
     }
 
     template <typename Params, typename ArgTup>
-    constexpr auto PrepareParams(ArgTup& argTuple)
+    __aicore__ inline constexpr auto PrepareParams(ArgTup& argTuple)
     {
         return PrepareParamsImpl<Params>(
             argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
     }
     template <typename Params, typename ArgTup>
-    constexpr auto PrepareLocalVars(ArgTup& argTuple)
+    __aicore__ inline constexpr auto PrepareLocalVars(ArgTup& argTuple)
     {
         return PrepareParamsImpl<Params>(
             argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
     }
 
     template <typename Params, size_t Index, ATVC::ExprTmpl::ParamUsage... usages, typename ParamTup>
-    constexpr auto GetOneParam(ParamTup& params)
+    __aicore__ inline constexpr auto GetOneParam(ParamTup& params)
     {
         using Param = Util::TMP::Get_t<Params, Index>;
         if constexpr (((Param::usage == usages) || ...)) {
@@ -118,50 +119,49 @@ auto CombineArgs(const AscendC::Std::tuple<Ts...>& params)
     }
 
     template <typename Params, typename ParamTup, size_t... Ints>
-    constexpr auto GetInParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
+    __aicore__ inline constexpr auto GetInParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
     {
-        return AscendC::Std::tuple_cat(
+        return AscendC::Std::make_tuple(
             GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::in, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
     }
 
     template <typename Params, typename ParamTup, size_t... Ints>
-    constexpr auto GetOutParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
+    __aicore__ inline constexpr auto GetOutParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
     {
-        return AscendC::Std::tuple_cat(
+        return AscendC::Std::make_tuple(
             GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::out, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
     }
     template <typename Params, typename ParamTup>
-    auto GetInParams(ParamTup& params)
+    __aicore__ inline auto GetInParams(ParamTup& params)
     {
         constexpr auto size = Util::TMP::Size_v<Params>;
-        static_assert(size == AscendC::Std::tuple_size_v<ParamTup>);
+        static_assert(size == AscendC::Std::tuple_size<ParamTup>::value);
         return GetInParamsImpl<Params>(
             params, AscendC::Std::make_index_sequence<size>{});
     }
 
     template <typename Params, typename ParamTup>
-    auto GetOutParams(ParamTup& params)
+    __aicore__ inline auto GetOutParams(ParamTup& params)
     {
         constexpr auto size = Util::TMP::Size_v<Params>;
-        static_assert(size == AscendC::Std::tuple_size_v<ParamTup>);
+        static_assert(size == AscendC::Std::tuple_size<ParamTup>::value);
         return GetOutParamsImpl<Params>(
             params, AscendC::Std::make_index_sequence<size>{});
     }
 
     template <typename InParams>
-    __aicore__ inline void CopyIn(InParams& inParams, Tile::Config &configTile){
-        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(InParams)>::value;
-        for(auto i = 0; i < tupeSize; i++) {
-            AscendC::Std::get<i>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
-        }
+    __aicore__ inline void CopyIn(InParams& inParams, Tile::Config &configTile)
+    {
+        uint32_t tupeSize = AscendC::Std::tuple_size<InParams>::value;
+        AscendC::Std::get<0>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
+        AscendC::Std::get<1>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
     }
 
     template <typename OutParams>
-    __aicore__ inline void CopyOut(OutParams& outParams, Tile::Config &configTile){
-        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(OutParams)>::value;
-        for(auto i = 0; i < tupeSize; i++) {
-            AscendC::Std::get<i>(outParams).CopyOut(configTile.gmOffset, configTile.basicNum);
-        }
+    __aicore__ inline void CopyOut(OutParams& outParams, Tile::Config &configTile)
+    {
+        uint32_t tupeSize = AscendC::Std::tuple_size<OutParams>::value;
+        AscendC::Std::get<0>(outParams).CopyOut(configTile.gmOffset, configTile.basicNum);
     }
 private:
     ATVC::UTILS::EleBufPool bufPool_; // kernel调用block的时候 传入bufPool(kernel层实例化bufPool_，多次调用kernel的时候可以复用)
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index 4e90c3df1..a01381195 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -48,6 +48,7 @@ public:
 
         // 执行计算
         // 循环执行
+
         Block::BlockEleWise<ExprMaker> blockOp;
         for (int i = 0; i < configBlock.wholeBlockCount; ++i) {
             blockOp.Run(configBlock, params);
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
index 90481c07a..e2eeeaeb0 100644
--- a/best_practices/atvos_demo/include/tile/tile_elewise.h
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -21,10 +21,10 @@ __aicore__ inline void AddAssign(AscendC::LocalTensor<T>& dst,
     AscendC::Add(dst, src1, src2, src2.size());
 }
 
-template <typename Expr, typename ArgTup, typename LocalVarTup>
-__aicore__ inline void Evaluate(ArgTup& args, LocalVarTup& localVars)
+template <typename Expr, typename ArgTup>
+__aicore__ inline void Evaluate(ArgTup& args)
 {
-    DemoEval::Evaluator<typename Expr::Type>{}(args, localVars);
+    DemoEval::Evaluator<typename Expr::Type>{}(args);
 }
 
 } // namespace ATVC::Tile
diff --git a/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h b/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h
index fe113d76d..35a63dfd9 100644
--- a/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h
+++ b/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h
@@ -4,7 +4,9 @@ namespace ATVC::UTILS {
 
 class EleBufPool {
 public:
-    __aicore__ inline EleBufPool(uint32_t inBufNum, uint64_t inBytes, uint32_t outBufNum, uint64_t outBytes){
+    __aicore__ inline EleBufPool(){}
+
+    __aicore__ inline void InitBufPool(uint32_t inBufNum, uint64_t inBytes, uint32_t outBufNum, uint64_t outBytes){
         GetTPipePtr()->InitBuffer(inQueue, inBufNum, inBytes);
         GetTPipePtr()->InitBuffer(outQueue, outBufNum, outBytes);
     }
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index 78f0c3655..dbfad5dcf 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -13,8 +13,6 @@
 #include "../include/device/device_elewise.h"
 
 
-// using namespace ATVC::ExprTmpl;
-
 // 描述计算逻辑
 struct MyAddOp : ATVC::ExprTmpl::Maker {
     template <template <typename> class VectorType>
-- 
Gitee


From bc3c3827baa79d0e8cd3c1b68480cda36ced5eb8 Mon Sep 17 00:00:00 2001
From: wulinyu <wulinyu4@huawei.com>
Date: Fri, 19 Sep 2025 16:50:37 +0800
Subject: [PATCH 028/116] =?UTF-8?q?=E8=A7=A3=E5=86=B3=E9=93=BE=E6=8E=A5?=
 =?UTF-8?q?=E6=89=BE=E4=B8=8D=E5=88=B0kernel=E5=85=A5=E5=8F=A3=E5=87=BD?=
 =?UTF-8?q?=E6=95=B0=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../atvos_demo/include/block/block_elewise.h  |  3 ++-
 .../include/device/device_elewise.h           | 25 ++++++++++---------
 .../include/kernel/kernel_elewise.h           |  5 ++--
 .../include/utils/expression/expression.h     | 14 +++++------
 best_practices/atvos_demo/test/main.cpp       | 18 ++++++++++++-
 5 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index ca47c76e0..58e83f50a 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -14,7 +14,8 @@ struct Config {// block层的切分信息
 
 template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
 class BlockEleWise{
-public: 
+public:
+    using ExpressMaker = ExprMaker;
     __aicore__ inline BlockEleWise(){
         bufPool_.InitBufPool(2, 1024, 1, 2048); // Todo: 需要通过tile layout配置
     }
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index b794745d4..11a110d67 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -28,16 +28,16 @@ void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
 }
 
 
-template<class KernelOp>
-__global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
-{
-    KernelOp op;
-    AscendC::TPipe myPipe;
-    AscendC::printf("x: %p\n", x);
-    AscendC::printf("y: %p\n", y);
-    AscendC::printf("z: %p\n", z);
-    op.Run(configDevice, x, y, z);
-}
+// template<class KernelOp>
+// __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
+// {
+//     KernelOp op;
+//     AscendC::TPipe myPipe;
+//     AscendC::printf("x: %p\n", x);
+//     AscendC::printf("y: %p\n", y);
+//     AscendC::printf("z: %p\n", z);
+//     op.Run(configDevice, x, y, z);
+// }
 
 namespace ATVC::Device {
 
@@ -54,10 +54,11 @@ void LaunchKernelWithDataTuple(uint32_t blockNum, aclrtStream& stream, uint8_t*
 ExprMaker maker: 描述计算表达信息
 Args&&... args： 输入输出信息
 */
-template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
+template <typename KernelOp>
 class DeviceEleWise
 {
 public:
+    using ExprMaker = typename KernelOp::ExprMaker;
     DeviceEleWise(){};
     // 计算kernel切分策略
     Kernel::Config MakeConfig() {
@@ -97,7 +98,7 @@ public:
         uint8_t* configDevice;
         // CopyConfig(config, configDevice);
         // 传递参数到设备侧执行
-        LaunchKernelWithDataTuple<Kernel::KernelEleWise<ExprMaker>>(config.blockNum, stream, configDevice, params);
+        LaunchKernelWithDataTuple<KernelOp>(config.blockNum, stream, configDevice, params);
         CleanACL(stream, context, deviceId);
         // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
         CopyOut<OutParams>(outParams, argTuple);
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index a01381195..69d9a19bf 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -8,9 +8,10 @@ struct Config{ // kernel 层的切分信息
     uint32_t basicNum = 0;
 };
 
-template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
+template <typename BlockOp>
 class KernelEleWise{
 public:
+    using ExprMaker = typename BlockOp::ExpressMaker;
     __aicore__ inline KernelEleWise(){};
 
     // 计算block切分策略
@@ -49,7 +50,7 @@ public:
         // 执行计算
         // 循环执行
 
-        Block::BlockEleWise<ExprMaker> blockOp;
+        BlockOp blockOp;
         for (int i = 0; i < configBlock.wholeBlockCount; ++i) {
             blockOp.Run(configBlock, params);
         }
diff --git a/best_practices/atvos_demo/include/utils/expression/expression.h b/best_practices/atvos_demo/include/utils/expression/expression.h
index 03b6fa855..5e6cac33a 100644
--- a/best_practices/atvos_demo/include/utils/expression/expression.h
+++ b/best_practices/atvos_demo/include/utils/expression/expression.h
@@ -129,7 +129,7 @@ constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
 }
 
 template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
-constexpr auto DefineParam()
+__host_aicore__ constexpr auto DefineParam()
 {
     return Expression<Param<N, T, U>>{};
 }
@@ -257,7 +257,7 @@ struct OpAssign : BinaryOp<T, U> {};
 
 template <typename T>
 template <typename U>
-[[nodiscard]] constexpr auto Expression<T>::operator=(Expression<U> u)
+__host_aicore__ constexpr auto Expression<T>::operator=(Expression<U> u)
 {
     static_assert(
         (IsParam_v<T> || IsLocalVar_v<T> || std::is_lvalue_reference_v<T>),
@@ -270,32 +270,32 @@ template <typename T, typename U>
 struct OpAndThen : BinaryOp<T, U> {};
 
 template <typename T, typename U>
-[[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
+__host_aicore__ constexpr auto operator,(Expression<T> t, Expression<U> u)
 {
     return Expression<OpAndThen<T, U>>{{t.data, u.data}};
 }
 
 // Disallow dangerous expressions like (Expression{2}, 3)
 template <typename T, typename U>
-constexpr auto operator,(Expression<T>t, U&& u) = delete;
+__host_aicore__ constexpr auto operator,(Expression<T>t, U&& u) = delete;
 
 template <typename T, typename U>
 struct OpAdd : BinaryOp<T, U> {};
 
 template <typename T, typename U>
-[[nodiscard]] constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
+__host_aicore__ constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
 {
     return Expression<OpAdd<T, U>>{{lhs.data, rhs.data}};
 }
 
 template <typename T, typename U>
-[[nodiscard]] constexpr auto operator+(Expression<T> lhs, U&& rhs)
+__host_aicore__ constexpr auto operator+(Expression<T> lhs, U&& rhs)
 {
     return Expression<OpAdd<T, U>>{{lhs.data, std::forward<U>(rhs)}};
 }
 
 template <typename T, typename U>
-[[nodiscard]] constexpr auto operator+(T&& lhs, Expression<U> rhs)
+__host_aicore__ constexpr auto operator+(T&& lhs, Expression<U> rhs)
 {
     return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
 }
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index dbfad5dcf..0a82a8e62 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -6,6 +6,18 @@
 #include <utility>
 #include <vector>
 #include "kernel_operator.h"
+
+template<class KernelOp>
+__global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
+{
+    KernelOp op;
+    AscendC::TPipe myPipe;
+    AscendC::printf("x: %p\n", x);
+    AscendC::printf("y: %p\n", y);
+    AscendC::printf("z: %p\n", z);
+    op.Run(configDevice, x, y, z);
+}
+
 #include "../include/utils/expression/expression.h"
 #include "../include/tile/tile_elewise.h"
 #include "../include/block/block_elewise.h"
@@ -26,12 +38,16 @@ struct MyAddOp : ATVC::ExprTmpl::Maker {
     }
 };
 
+using BlockOp = ATVC::Block::BlockEleWise<MyAddOp>;
+using KernelOp = ATVC::Kernel::KernelEleWise<BlockOp>;
+using DeviceOp = ATVC::Device::DeviceEleWise<KernelOp>;
+
 int main() {
     std::cout<<"test in"<<std::endl;
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
     std::vector<float> v3(300);
-    ATVC::Device::DeviceEleWise<MyAddOp> deviceOp;
+    DeviceOp deviceOp;
     deviceOp.Run(v1, v2, v3); // 完成 core num计算 kernel launch
     std::cout<<"test out !"<<std::endl;
     return 0;
-- 
Gitee


From 2906991383ef1e9b1035387562aca7c2c597f974 Mon Sep 17 00:00:00 2001
From: wulinyu <wulinyu4@huawei.com>
Date: Sat, 20 Sep 2025 17:30:17 +0800
Subject: [PATCH 029/116] fix Expr tile func

---
 .../atvos_demo/include/block/block_elewise.h  | 97 ++++++++++++-------
 .../atvos_demo/include/block/block_tensor.h   |  7 +-
 .../include/kernel/kernel_elewise.h           | 21 ++--
 .../atvos_demo/include/tile/tile_elewise.h    | 11 +--
 .../include/tile/tile_evaluator_common.h      | 71 +++++---------
 5 files changed, 101 insertions(+), 106 deletions(-)

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index 58e83f50a..6a9210cdc 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -17,7 +17,7 @@ class BlockEleWise{
 public:
     using ExpressMaker = ExprMaker;
     __aicore__ inline BlockEleWise(){
-        bufPool_.InitBufPool(2, 1024, 1, 2048); // Todo: 需要通过tile layout配置
+        bufPool_.InitBufPool(6, 1024, 4, 2048); // Todo: 需要通过tile layout配置
     }
 
     template <typename ArgTup>
@@ -30,35 +30,61 @@ public:
     template <typename ArgTup>
     __aicore__ inline void Run(const Config& configBlock, ArgTup& argTuple)
     {
-        // // 配置规划，特别是需要确定使用的 Local Memory 大小
-        // Tile::Config configTile = MakeConfig(configBlock, argTuple);
-        // auto expr = ExprMaker{}.template Get<ATVC::Block::Tensor>();
-        // using Expr = decltype(expr);
+        // 配置规划，特别是需要确定使用的 Local Memory 大小
+        Tile::Config configTile = MakeConfig(configBlock, argTuple);
+        auto expr = ExprMaker{}.template Get<AscendC::LocalTensor>();
+        using Expr = typename decltype(expr)::Type;
         // using LocalVars = ATVC::ExprTmpl::LocalVars_t<Expr>; // TODO: 这里 临时buffer不应该由Expr生成， 应该在host 切分信息计算获得。存放在configBlock中？
         // using Params = ATVC::ExprTmpl::Params_t<Expr>;
         // using InParams = ATVC::ExprTmpl::InParams_t<Expr>;
         // using OutParams = ATVC::ExprTmpl::OutParams_t<Expr>;
 
+
+        // /**------------test-----*/
+        AscendC::LocalTensor<float> in1 = bufPool_.inQueue.template AllocTensor<float>();
+        bufPool_.inQueue.EnQue(in1);
+        
+        AscendC::LocalTensor<float> in2 = bufPool_.inQueue.template AllocTensor<float>();
+        bufPool_.inQueue.EnQue(in2);
+        AscendC::LocalTensor<float> out = bufPool_.outQueue.template AllocTensor<float>();
+        bufPool_.outQueue.EnQue(out);
+        AscendC::LocalTensor<float> in1_1 = bufPool_.inQueue.template DeQue<float>();
+        AscendC::LocalTensor<float> in2_1 = bufPool_.inQueue.template DeQue<float>();
+        AscendC::LocalTensor<float> out_1 = bufPool_.outQueue.template DeQue<float>();
+        auto ins = AscendC::Std::make_tuple(in1_1, in2_1, out_1);
+        // // CopyIn(inParams, ins, configTile);
+        Tile::Evaluate<Expr>(ins);
+        AscendC::DumpTensor(out, 222, 64);
+        // // CopyOut(outParams, configTile);
+        
+        bufPool_.inQueue.FreeTensor(in1_1);
+        bufPool_.inQueue.template FreeTensor(in2_1);
+        bufPool_.outQueue.template FreeTensor(out_1);
+
         // // 得到 tuple<Block::Tensor, ...>，向量变成了 Block::Tensor 类型
         // auto params = PrepareParams<Params>(argTuple);
-        // // 下面得到 tuple<Block::Tensor&, ...>，即对 Tensor 的访问都成了引用
+        // // // 下面得到 tuple<Block::Tensor&, ...>，即对 Tensor 的访问都成了引用
         // auto inParams = GetInParams<Params>(params);
         // auto outParams = GetOutParams<Params>(params);
-        // // 初始化局部变量及其需要的空间，
-        // // auto localVars = PrepareLocalVars<LocalVars>(params);
-
+        // // // 初始化局部变量及其需要的空间，
+        // // // auto localVars = PrepareLocalVars<LocalVars>(params);
+        // uint32_t tupeSize = AscendC::Std::tuple_size<decltype(params)>::value;
+        // AscendC::printf("copy in tupeSize:%u \n", tupeSize);
         // // 循环执行
-        // for (int i = 0; i < configTile.wholeBlockCount; ++i) {
+        // for (int i = 0; i < 1; ++i) {
         //     // 把 argTuple 里的向量替换成 params 里的对应 Local Tensor引用
-        //     auto combinedArgs = CombineArgs(inParams, outParams); // 这里 in/out的类型不一样，去申请ub tensor 的操作不一样 输入输出单独传递
-        //     CopyIn(inParams, configTile);
-        //     Tile::Evaluate<Expr>(combinedArgs);
-        //     CopyOut(outParams, configTile);
+        //     // AscendC::LocalTensor<float> in1 = bufPool_.inQueue.template AllocTensor<float>();
+        //     // AscendC::LocalTensor<float> in2 = bufPool_.inQueue.template AllocTensor<float>();
+        //     // auto ins = AscendC::Std::make_tuple(in1, in2);
+        //     // auto combinedArgs = CombineArgs(inParams, outParams); // 这里 in/out的类型不一样，去申请ub tensor 的操作不一样 输入输出单独传递
+        //     // CopyIn(inParams, ins, configTile);
+        //     // Tile::Evaluate<Expr>(combinedArgs);
+        //     // CopyOut(outParams, configTile);
         // }
-        // // 尾块的处理
-        // for (int i = 0; i < configTile.tileBlockCount; ++i) {
+        // // // 尾块的处理
+        // // for (int i = 0; i < configTile.tileBlockCount; ++i) {
 
-        // }
+        // // }
     }
 private:
 template <typename ArgIn, typename ArgOut>
@@ -94,12 +120,12 @@ __aicore__ inline auto CombineArgs(ArgIn& inParams, ArgOut& outParams)
         return PrepareParamsImpl<Params>(
             argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
     }
-    template <typename Params, typename ArgTup>
-    __aicore__ inline constexpr auto PrepareLocalVars(ArgTup& argTuple)
-    {
-        return PrepareParamsImpl<Params>(
-            argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
-    }
+//     template <typename Params, typename ArgTup>
+//     __aicore__ inline constexpr auto PrepareLocalVars(ArgTup& argTuple)
+//     {
+//         return PrepareParamsImpl<Params>(
+//             argTuple, AscendC::Std::make_index_sequence<Util::TMP::Size_v<Params>>{});
+//     }
 
     template <typename Params, size_t Index, ATVC::ExprTmpl::ParamUsage... usages, typename ParamTup>
     __aicore__ inline constexpr auto GetOneParam(ParamTup& params)
@@ -109,9 +135,9 @@ __aicore__ inline auto CombineArgs(ArgIn& inParams, ArgOut& outParams)
             auto tensor = AscendC::Std::forward_as_tuple(AscendC::Std::get<Index>(params));
             //todo: 分配 UB tesnor给当前输入输出
             if constexpr (Param::usage == ATVC::ExprTmpl::ParamUsage::in || Param::usage == ATVC::ExprTmpl::ParamUsage::in_out) {
-                tensor.AssignUbTensor(bufPool_);
+                tensor.isInTensor = true;
             } else if constexpr (Param::usage == ATVC::ExprTmpl::ParamUsage::out) {
-
+                tensor.isInTensor = false;
             }
             return AscendC::Std::forward_as_tuple(AscendC::Std::get<Index>(params));
         } else {
@@ -150,20 +176,21 @@ __aicore__ inline auto CombineArgs(ArgIn& inParams, ArgOut& outParams)
             params, AscendC::Std::make_index_sequence<size>{});
     }
 
-    template <typename InParams>
-    __aicore__ inline void CopyIn(InParams& inParams, Tile::Config &configTile)
+    template <typename InParams, typename InUbs>
+    __aicore__ inline void CopyIn(InParams& inParams, InUbs& inUns, Tile::Config &configTile)
     {
         uint32_t tupeSize = AscendC::Std::tuple_size<InParams>::value;
-        AscendC::Std::get<0>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
-        AscendC::Std::get<1>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
+        AscendC::printf("copy in tupeSize:%u \n", tupeSize);
+        // AscendC::Std::get<0>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
+        // AscendC::Std::get<1>(inParams).CopyIn(configTile.gmOffset, configTile.basicNum);
     }
 
-    template <typename OutParams>
-    __aicore__ inline void CopyOut(OutParams& outParams, Tile::Config &configTile)
-    {
-        uint32_t tupeSize = AscendC::Std::tuple_size<OutParams>::value;
-        AscendC::Std::get<0>(outParams).CopyOut(configTile.gmOffset, configTile.basicNum);
-    }
+    // template <typename OutParams>
+    // __aicore__ inline void CopyOut(OutParams& outParams, Tile::Config &configTile)
+    // {
+    //     uint32_t tupeSize = AscendC::Std::tuple_size<OutParams>::value;
+    //     AscendC::Std::get<0>(outParams).CopyOut(configTile.gmOffset, configTile.basicNum);
+    // }
 private:
     ATVC::UTILS::EleBufPool bufPool_; // kernel调用block的时候 传入bufPool(kernel层实例化bufPool_，多次调用kernel的时候可以复用)
 };
diff --git a/best_practices/atvos_demo/include/block/block_tensor.h b/best_practices/atvos_demo/include/block/block_tensor.h
index a6f9ff264..9700c7dfc 100644
--- a/best_practices/atvos_demo/include/block/block_tensor.h
+++ b/best_practices/atvos_demo/include/block/block_tensor.h
@@ -11,12 +11,11 @@ class Tensor {
 public:
     __aicore__ inline Tensor() = default;
 
-    __aicore__ inline Tensor(AscendC::GlobalTensor<T>& gmTensor, bool isIn)
+    __aicore__ inline Tensor(AscendC::GlobalTensor<T>& gmTensor)
     {
         SetGmTensor(gmTensor);
-        isInTensor = isIn;
     }
-
+    
     __aicore__ inline void SetSize(std::size_t size)
     {
         size_ = size;
@@ -62,7 +61,7 @@ public:
     AscendC::GlobalTensor<T>* gmTensor_;
     uint64_t size_;
     uint64_t curGmOffset_;
-    bool isInTensor;
+    bool isInTensor = false;
 };
 }
 #endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index 69d9a19bf..2abc2c4e0 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -22,8 +22,8 @@ public:
 
     // 需要从Params中萃取每个输入输出的Dtype 递归调用PrepareParams 生成每个输入输出的GlobalTensor
     template <typename Params, typename... Args>
-    __aicore__ inline AscendC::Std::tuple<AscendC::GlobalTensor<float>> PrepareParams(Args... args) {
-        AscendC::Std::tuple<AscendC::GlobalTensor<float>> params{};
+    __aicore__ inline AscendC::Std::tuple<AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>,AscendC::GlobalTensor<float>> PrepareParams(Args... args) {
+        AscendC::Std::tuple<AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>> params{};
         // AscendC::GlobalTensor<float> globalTensor;
         // globalTensor.SetGlobalBuffer(reinterpret_cast<__gm__ DataType*>(src), srcDataSize);
         return params;
@@ -45,19 +45,22 @@ public:
 
         // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
         // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
-        auto params = PrepareParams<Params>(args...);
-
+        // auto params = PrepareParams<Params>(args...);
+        AscendC::GlobalTensor<float> t1, t2, t3;
+        auto params = AscendC::Std::tuple<AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>>(t1, t2, t3);
+        uint32_t tupeSize = AscendC::Std::tuple_size<decltype(params)>::value;
+        AscendC::printf("[kernel] copy in tupeSize:%u \n", tupeSize);
         // 执行计算
         // 循环执行
 
         BlockOp blockOp;
-        for (int i = 0; i < configBlock.wholeBlockCount; ++i) {
-            blockOp.Run(configBlock, params);
-        }
-        // 尾块
-        for (int i = 0; i < configBlock.tileBlockCount; ++i) {
+        for (int i = 0; i < 1; ++i) {
             blockOp.Run(configBlock, params);
         }
+        // // 尾块
+        // for (int i = 0; i < configBlock.tileBlockCount; ++i) {
+        //     blockOp.Run(configBlock, params);
+        // }
     }
 };
 
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
index e2eeeaeb0..eeeecf335 100644
--- a/best_practices/atvos_demo/include/tile/tile_elewise.h
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -13,18 +13,11 @@ struct Config {//tile层的切分信息
     uint64_t gmOffset= 0;
 };
 
-template <typename T>
-__aicore__ inline void AddAssign(AscendC::LocalTensor<T>& dst,
-               const AscendC::LocalTensor<T>& src1,
-               const AscendC::LocalTensor<T>& src2)
-{
-    AscendC::Add(dst, src1, src2, src2.size());
-}
-
 template <typename Expr, typename ArgTup>
 __aicore__ inline void Evaluate(ArgTup& args)
 {
-    DemoEval::Evaluator<typename Expr::Type>{}(args);
+    auto localVar = AscendC::Std::tuple<>{};
+    DemoEval::Evaluator<Expr>{}(Expr{}, args, localVar);
 }
 
 } // namespace ATVC::Tile
diff --git a/best_practices/atvos_demo/include/tile/tile_evaluator_common.h b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
index 30dead9e5..5c431e38d 100644
--- a/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
+++ b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
@@ -17,7 +17,7 @@ struct Evaluator {
     using Type = T;
 
     template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(const T& value,
+    __aicore__ decltype(auto) operator()(const T& value,
                               ArgTup& args,
                               LocalVarTup& localVars) const
     {
@@ -71,7 +71,7 @@ void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
 {
     static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
     if constexpr (!std::is_same_v<typename L::Like, void>) {
-        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
+        MakeAlikeDatum(localVar, AscendC::Std::get<L::Like::number>(args));
     }
 }
 
@@ -81,7 +81,7 @@ void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
                             std::index_sequence<Ints...>)
 {
     (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
-         std::get<Ints>(localVars), args),
+         AscendC::Std::get<Ints>(localVars), args),
      ...);
 }
 
@@ -134,12 +134,12 @@ struct Evaluator<LocalVar<N, T, L>> {
     using Type = T&;
 
     template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+    __aicore__ decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
                               ArgTup& /*args*/,
                               LocalVarTup& localVars) const
     {
         static_assert(N > 0, "LocalVar number starts from 1");
-        return std::get<N - 1>(localVars);
+        return AscendC::Std::get<N - 1>(localVars);
     }
 };
 
@@ -149,29 +149,29 @@ struct Evaluator<Param<N, T, U>> {
     using Type = T;
 
     template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+    __aicore__  decltype(auto) operator()(Param<N, T, U> /*unused*/,
                               ArgTup& args,
                               LocalVarTup& /*localVars*/) const
     {
         static_assert(N > 0, "Param number starts from 1");
         constexpr auto index = N - 1;
         using NthType =
-            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
+            typename AscendC::Std::tuple_element<index, std::remove_reference_t<ArgTup>>::type;
         if constexpr (std::is_same_v<T, NthType> ||
                       std::is_same_v<T&, NthType> ||
                       std::is_same_v<T&&, NthType>) {
-            return std::get<index>(args);
+            return AscendC::Std::get<index>(args);
         } else {
             static_assert(
                 U == ParamUsage::in,
                 "Only in-parameters allow implicit type conversions");
-            return static_cast<T>(std::get<index>(args));
+            return static_cast<T>(AscendC::Std::get<index>(args));
         }
     }
 };
 
 template <typename T, typename U>
-void Assign(T& dst, const U& src)
+__aicore__ void Assign(T& dst, const U& src)
 {
     dst = src;
 }
@@ -182,7 +182,7 @@ struct Evaluator<OpAssign<T, U>> {
     using Type = void;
 
     template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpAssign<T, U>& op,
+    __aicore__  void operator()(const OpAssign<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -197,7 +197,7 @@ struct Evaluator<OpAndThen<T, U>> {
     using Type = void;
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAndThen<T, U>& op,
+    __aicore__ auto operator()(const OpAndThen<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -208,49 +208,22 @@ struct Evaluator<OpAndThen<T, U>> {
 };
 
 template <typename T, typename U>
-auto Add(const T& src1, const U& src2)
+__aicore__ auto Add(const T& src1, const U& src2)
 {
     return src1 + src2;
 }
 
-template <typename T, typename U, typename V>
-void AddAssign(T& dst, const U& src1, const V& src2)
-{
-    dst = src1 + src2;
-}
-
 template <typename T>
-void AddAssign(std::vector<T>& dst,
-               const std::vector<T>& src1,
-               const std::vector<T>& src2)
+__aicore__ inline void AddAssign(AscendC::LocalTensor<T>& dst,
+               const AscendC::LocalTensor<T>& src1,
+               const AscendC::LocalTensor<T>& src2)
 {
-    if (src1.size() != src2.size()) {
-        throw std::logic_error("vector sizes do not match");
-    }
-    if (src1.size() != dst.size()) {
-        throw std::logic_error("Destination vector should be like source");
-    }
-    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
-        dst[i] = src1[i] + src2[i];
-    }
+    AscendC::printf("AddAssign 1");
+    AscendC::Add(dst, src1, src2, src2.GetSize());
+    AscendC::Adds(dst, dst, (T)3, 32);
+    AscendC::DumpTensor(dst, 111, 64);
 }
 
-// template <typename T>
-// void AddAssign(Tensor<T>& dst,
-//                const Tensor<T>& src1,
-//                const Tensor<T>& src2)
-// {
-//     if (src1.GetSize() != src2.GetSize()) {
-//         throw std::logic_error("Tensor sizes do not match");
-//     }
-//     if (src1.GetSize() != dst.GetSize()) {
-//         throw std::logic_error("Destination tensor should be like source");
-//     }
-//     for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
-//         dst[i] = src1[i] + src2[i];
-//     }
-// }
-
 // Partial specializtion for E_x + E_y
 template <typename T, typename U>
 struct Evaluator<OpAdd<T, U>> {
@@ -258,7 +231,7 @@ struct Evaluator<OpAdd<T, U>> {
                               std::declval<typename Evaluator<U>::Type>()));
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAdd<T, U>& op,
+    __aicore__ auto operator()(const OpAdd<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -273,7 +246,7 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     using Type = void;
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+    __aicore__ auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
-- 
Gitee


From b19f20b463e6bd35ef1747ab2acb423ee5afdf51 Mon Sep 17 00:00:00 2001
From: wulinyu <wulinyu4@huawei.com>
Date: Mon, 22 Sep 2025 21:43:35 +0800
Subject: [PATCH 030/116] add attr

---
 .../atvos_demo/include/block/block_elewise.h  | 11 ++---
 best_practices/atvos_demo/include/common.h    | 46 +++++++++++++++++++
 .../include/device/device_elewise.h           | 22 +++++++--
 .../include/kernel/kernel_elewise.h           | 15 +++---
 .../atvos_demo/include/tile/tile_elewise.h    |  7 ---
 best_practices/atvos_demo/test/main.cpp       | 10 +++-
 6 files changed, 82 insertions(+), 29 deletions(-)
 create mode 100644 best_practices/atvos_demo/include/common.h

diff --git a/best_practices/atvos_demo/include/block/block_elewise.h b/best_practices/atvos_demo/include/block/block_elewise.h
index 6a9210cdc..8f842a6c1 100644
--- a/best_practices/atvos_demo/include/block/block_elewise.h
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -6,14 +6,11 @@
 
 namespace ATVC::Block {
 
-struct Config {// block层的切分信息
-    uint32_t wholeBlockCount = 0;
-    uint32_t tileBlockCount = 0;
-    uint32_t basicNum = 0;
-};
-
 template <typename ExprMaker, typename = std::enable_if_t<std::is_base_of_v<ATVC::ExprTmpl::Maker, ExprMaker>>>
 class BlockEleWise{
+    //TODO: block层的切分策略 融合到当前demo中： MakeConfig
+    //        PrepareParams: 输入输出gm指针 转换为tuple<LocalTensor> 包含 LocalTensor资源分配
+    //     CopyIn CopyOut  GlobalTensor -> LocalTensor
 public:
     using ExpressMaker = ExprMaker;
     __aicore__ inline BlockEleWise(){
@@ -48,9 +45,11 @@ public:
         bufPool_.inQueue.EnQue(in2);
         AscendC::LocalTensor<float> out = bufPool_.outQueue.template AllocTensor<float>();
         bufPool_.outQueue.EnQue(out);
+
         AscendC::LocalTensor<float> in1_1 = bufPool_.inQueue.template DeQue<float>();
         AscendC::LocalTensor<float> in2_1 = bufPool_.inQueue.template DeQue<float>();
         AscendC::LocalTensor<float> out_1 = bufPool_.outQueue.template DeQue<float>();
+
         auto ins = AscendC::Std::make_tuple(in1_1, in2_1, out_1);
         // // CopyIn(inParams, ins, configTile);
         Tile::Evaluate<Expr>(ins);
diff --git a/best_practices/atvos_demo/include/common.h b/best_practices/atvos_demo/include/common.h
new file mode 100644
index 000000000..64d2503a8
--- /dev/null
+++ b/best_practices/atvos_demo/include/common.h
@@ -0,0 +1,46 @@
+#ifndef _ATVC_COMMON_H
+#define _ATVC_COMMON_H
+namespace ATVC {
+
+namespace Tile {
+struct Config {//tile层的切分信息
+    uint32_t wholeBlockCount = 0;
+    uint32_t tileBlockCount = 0;
+    uint32_t basicNum = 0;
+    uint64_t gmOffset= 0;
+};
+}
+
+
+namespace Block {
+struct Config {// block层的切分信息
+    uint32_t wholeBlockCount = 0; // 一个block中
+    uint32_t tileBlockCount = 0;
+    uint32_t basicNum = 0;
+};
+}
+
+namespace Kernel {
+    struct UbAssign {
+    uint32_t ubInNum = 1; // 输入需要占用的UB tensor 个数
+    uint32_t ubOutCnt = 1; // 输出需要占用的UB tensor 个数
+    uint32_t ubTmpCnt = 0; // tmp需要占用的UB tensor 个数
+    uint32_t eleNumInTensor = 1024; // 一个in tensor的元素个数
+    uint32_t eleNumOutTensor = 1024; // 一个out tensor的元素个数
+    uint32_t eleNumTmpTensor = 1024; // 一个tmp tensor的元素个数
+};
+struct Config{ // kernel 层的切分信息
+    uint32_t blockNum = 1;
+    uint32_t basicNum = 0;
+    UbAssign ubAssign;
+};
+}
+
+struct AttrStruct {
+    ATVC::Kernel::Config configKernel{1, 1024*10};
+    ATVC::Block::Config configBlock{1, 1, 1024*10};
+    ATVC::Tile::Config configTile{10, 0, 1024*10, 0};
+};
+}
+
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index 11a110d67..6dfee67d8 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -39,6 +39,12 @@ void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
 //     op.Run(configDevice, x, y, z);
 // }
 
+
+// struct AttrStruct {
+//     ATVC::Kernel::Config configKernel{1, 1024*10};
+//     ATVC::Block::Config configBlock{1, 1, 1024*10};
+//     ATVC::Tile::Config configTile{10, 0, 1024*10, 0};
+// };
 namespace ATVC::Device {
 
 template<class KernelOp, typename ArgTup>
@@ -48,6 +54,9 @@ void LaunchKernelWithDataTuple(uint32_t blockNum, aclrtStream& stream, uint8_t*
     uint8_t* x = std::get<1>(argTuple).GetPtr();
     uint8_t* y = std::get<2>(argTuple).GetPtr();
     MyKernel<KernelOp><<<blockNum, nullptr, stream>>>(configDevice, x, y, z);
+    // template<class KernelOp, typename ArgTuple typename AttrStruct>
+    // __global__ __aicore__ void MyKernel(GM_ADDR configDevice, ArgTuple inputOutputs, AttrStruct attr)
+    // MyKernel<KernelOp, ArgTup, AttrStruct><<<blockNum, nullptr, stream>>>(configDevice, argTuple, attr);
 }
 
 /*
@@ -56,20 +65,23 @@ Args&&... args： 输入输出信息
 */
 template <typename KernelOp>
 class DeviceEleWise
+// TODO: MakeConfig 总的切分策略计算 UB空间分配策略
 {
 public:
     using ExprMaker = typename KernelOp::ExprMaker;
     DeviceEleWise(){};
     // 计算kernel切分策略
-    Kernel::Config MakeConfig() {
-        Kernel::Config configBlock{1, 1024*10};
-        return configBlock;
+    ATVC::AttrStruct MakeConfig() {
+        Kernel::Config configKernel{1, 1024*10};
+        Block::Config configBlock{1, 1, 1024*10};
+        Tile::Config configTile{10, 0, 1024*10, 0};
+        return ATVC::AttrStruct{configKernel, configBlock, configTile};
     }
 
     template <typename... Args>
     int64_t Run(Args&&... args)
     {
-        // 配置规划
+        // 配置规划: host tiling计算 ub空间分配
         auto config = MakeConfig();
         auto expr = ExprMaker{}.template Get<Tensor>(); // Tensor 为表达 Device 层向量的类型
         // using Expr = decltype(expr);
@@ -98,7 +110,7 @@ public:
         uint8_t* configDevice;
         // CopyConfig(config, configDevice);
         // 传递参数到设备侧执行
-        LaunchKernelWithDataTuple<KernelOp>(config.blockNum, stream, configDevice, params);
+        LaunchKernelWithDataTuple<KernelOp>(config.configKernel.blockNum, stream, configDevice, params);
         CleanACL(stream, context, deviceId);
         // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
         CopyOut<OutParams>(outParams, argTuple);
diff --git a/best_practices/atvos_demo/include/kernel/kernel_elewise.h b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
index 2abc2c4e0..0c83579d4 100644
--- a/best_practices/atvos_demo/include/kernel/kernel_elewise.h
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -3,13 +3,11 @@
 #include <functional>
 
 namespace ATVC::Kernel {
-struct Config{ // kernel 层的切分信息
-    uint32_t blockNum = 1;
-    uint32_t basicNum = 0;
-};
 
 template <typename BlockOp>
 class KernelEleWise{
+    //TODO: kenel层的切分策略 融合到当前demo中： MakeConfig
+    //        PrepareParams: 输入输出gm指针 转换为tuple<GlobalTensor> 包含 GlobalTensor资源分配
 public:
     using ExprMaker = typename BlockOp::ExpressMaker;
     __aicore__ inline KernelEleWise(){};
@@ -20,9 +18,9 @@ public:
         return configBlock;
     }
 
-    // 需要从Params中萃取每个输入输出的Dtype 递归调用PrepareParams 生成每个输入输出的GlobalTensor
+    // 需要从Params中萃取每个输入输出的Dtype 生成每个输入输出的Gm地址， gm内存大小， 生成GlobalTensor组成的tuple
     template <typename Params, typename... Args>
-    __aicore__ inline AscendC::Std::tuple<AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>,AscendC::GlobalTensor<float>> PrepareParams(Args... args) {
+    __aicore__ inline auto PrepareParams(Args... args) {
         AscendC::Std::tuple<AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>> params{};
         // AscendC::GlobalTensor<float> globalTensor;
         // globalTensor.SetGlobalBuffer(reinterpret_cast<__gm__ DataType*>(src), srcDataSize);
@@ -45,11 +43,10 @@ public:
 
         // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
         // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
-        // auto params = PrepareParams<Params>(args...);
-        AscendC::GlobalTensor<float> t1, t2, t3;
-        auto params = AscendC::Std::tuple<AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>, AscendC::GlobalTensor<float>>(t1, t2, t3);
+        auto params = PrepareParams<Params>(args...);
         uint32_t tupeSize = AscendC::Std::tuple_size<decltype(params)>::value;
         AscendC::printf("[kernel] copy in tupeSize:%u \n", tupeSize);
+        AscendC::printf("[kernel] copy in params:%u \n", params);
         // 执行计算
         // 循环执行
 
diff --git a/best_practices/atvos_demo/include/tile/tile_elewise.h b/best_practices/atvos_demo/include/tile/tile_elewise.h
index eeeecf335..40891a329 100644
--- a/best_practices/atvos_demo/include/tile/tile_elewise.h
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -6,13 +6,6 @@
 
 namespace ATVC::Tile {
 
-struct Config {//tile层的切分信息
-    uint32_t wholeBlockCount = 0;
-    uint32_t tileBlockCount = 0;
-    uint32_t basicNum = 0;
-    uint64_t gmOffset= 0;
-};
-
 template <typename Expr, typename ArgTup>
 __aicore__ inline void Evaluate(ArgTup& args)
 {
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index 0a82a8e62..d058c6621 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -6,7 +6,13 @@
 #include <utility>
 #include <vector>
 #include "kernel_operator.h"
-
+/*
+MyKernel入参：
+1. param:   1): kernel/block/tile层切分参数 
+            2): workspace （kernel层描述输入参数的大小、block层描述ub个数、大小等信息）
+2. 属性： AttrStruct: 是否能传递结构体？ 还是需要用device指针传递， 需要验证
+3. 输入输出（不定长参数 or 以tuple的形式？需要穿刺哪种形式能支持）
+*/
 template<class KernelOp>
 __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
 {
@@ -17,7 +23,7 @@ __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y,
     AscendC::printf("z: %p\n", z);
     op.Run(configDevice, x, y, z);
 }
-
+#include "../include/common.h"
 #include "../include/utils/expression/expression.h"
 #include "../include/tile/tile_elewise.h"
 #include "../include/block/block_elewise.h"
-- 
Gitee


From 5a739779f03fa31e32c604a5d8c05e3a2b6ccabe Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 24 Sep 2025 15:24:33 +0800
Subject: [PATCH 031/116] Support CopyIn and CopyOut expressions

---
 .../expr_template_demo.cpp                    | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index dcb6f962e..7ea277437 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -699,6 +699,35 @@ template <typename T, typename U>
     return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
 }
 
+template <typename T, typename U>
+struct OpCopyIn : BinaryOp<T, U> {
+    OpCopyIn() = default;
+    constexpr OpCopyIn(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+struct OpCopyOut : BinaryOp<T, U> {
+    OpCopyOut() = default;
+    constexpr OpCopyOut(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto CopyIn(Expression<T> dst, Expression<U> src)
+{
+    static_assert(IsLocalVar_v<T>,
+                  "Only a LocalVar can be the destination of CopyIn");
+    return Expression<OpCopyIn<T, U>>{{dst.data, src.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto CopyOut(Expression<T> src, Expression<U> dst)
+{
+    static_assert(
+        IsParam_v<U> || std::is_lvalue_reference_v<U>,
+        "Only a Param or reference can be the destination of CopyOut");
+    return Expression<OpCopyOut<T, U>>{{src.data, dst.data}};
+}
+
 // Base class to express that a class is a maker of calculation expression template
 class Maker {};
 
@@ -1319,6 +1348,14 @@ int main() // NOLINT(bugprone-exception-escape)
     auto r = Evaluate(result6, 1, 2);
     std::cout << r << '\n';
 
+    // Test CopyIn and CopyOut operations
+    auto srcParam = DefineParam<1, Tensor<float>>();
+    auto dstParam = DefineParam<2, Tensor<float>, ParamUsage::out>();
+    auto localVar = DefineLocalVar<1, Tensor<float>>();
+    auto result7 = (CopyIn(localVar, srcParam),
+                    CopyOut(localVar, dstParam));
+    //TYPE_DISPLAY(result7);
+
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
     std::vector<float> v3(300, 3.0F);
-- 
Gitee


From 40317e69fce96912cc41b6af236356fb1f765192 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 24 Sep 2025 15:37:46 +0800
Subject: [PATCH 032/116] Add demo evaluation of CopyIn and CopyOut

---
 .../expr_template_demo.cpp                    | 74 ++++++++++++++++++-
 1 file changed, 73 insertions(+), 1 deletion(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 7ea277437..5a24e9614 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1046,6 +1046,28 @@ void AddAssign(Tensor<T>& dst,
     }
 }
 
+template <typename T>
+void CopyIn(Tensor<T>& dst, const Tensor<T>& src)
+{
+    if (src.GetSize() > dst.GetSize()) {
+        throw std::logic_error("Source tensor is too big");
+    }
+    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
+        dst[i] = src[i];
+    }
+}
+
+template <typename T>
+void CopyOut(const Tensor<T>& src, Tensor<T>& dst)
+{
+    if (dst.GetSize() < src.GetSize()) {
+        throw std::logic_error("Destination tensor is too small");
+    }
+    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
+        dst[i] = src[i];
+    }
+}
+
 // Partial specializtion for E_x + E_y
 template <typename T, typename U>
 struct Evaluator<OpAdd<T, U>> {
@@ -1078,6 +1100,38 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     }
 };
 
+// Partial specialization for CopyIn(E_dst, E_src)
+template <typename T, typename U>
+struct Evaluator<OpCopyIn<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpCopyIn<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        auto& dst = Evaluator<T>{}(op.GetLhs(), args, localVars);
+        const auto& src = Evaluator<U>{}(op.GetRhs(), args, localVars);
+        CopyIn(dst, src);
+    }
+};
+
+// Partial specialization for CopyOut(E_src, E_dst)
+template <typename T, typename U>
+struct Evaluator<OpCopyOut<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpCopyOut<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        const auto& src = Evaluator<T>{}(op.GetLhs(), args, localVars);
+        auto& dst = Evaluator<U>{}(op.GetRhs(), args, localVars);
+        CopyOut(src, dst);
+    }
+};
+
 } // namespace DemoEval
 
 namespace Emulation {
@@ -1351,10 +1405,28 @@ int main() // NOLINT(bugprone-exception-escape)
     // Test CopyIn and CopyOut operations
     auto srcParam = DefineParam<1, Tensor<float>>();
     auto dstParam = DefineParam<2, Tensor<float>, ParamUsage::out>();
-    auto localVar = DefineLocalVar<1, Tensor<float>>();
+    auto localVar = DefineLocalVarLike<1>(srcParam);
     auto result7 = (CopyIn(localVar, srcParam),
                     CopyOut(localVar, dstParam));
     //TYPE_DISPLAY(result7);
+    Tensor<float> srcTensor;
+    srcTensor.SetSize(5);
+    for (std::size_t i = 0; i < 5; ++i) {
+        srcTensor[i] = static_cast<float>(i + 1);
+    }
+    Tensor<float> dstTensor;
+    dstTensor.SetSize(5);
+    std::cout << "Before: src=[" << srcTensor[0] << "," << srcTensor[1]
+              << "," << srcTensor[2] << "," << srcTensor[3] << ","
+              << srcTensor[4] << "] dst=[" << dstTensor[0] << ","
+              << dstTensor[1] << "," << dstTensor[2] << "," << dstTensor[3]
+              << "," << dstTensor[4] << "]\n";
+    Evaluate(result7, srcTensor, dstTensor);
+    std::cout << "After: src=[" << srcTensor[0] << "," << srcTensor[1]
+              << "," << srcTensor[2] << "," << srcTensor[3] << ","
+              << srcTensor[4] << "] dst=[" << dstTensor[0] << ","
+              << dstTensor[1] << "," << dstTensor[2] << "," << dstTensor[3]
+              << "," << dstTensor[4] << "]\n";
 
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
-- 
Gitee


From becc6285f8a4c2532075662d29edd495918b07db Mon Sep 17 00:00:00 2001
From: wly451717 <wly451717@noreply.gitcode.com>
Date: Wed, 24 Sep 2025 18:08:22 +0800
Subject: [PATCH 033/116] fix pipe name

---
 best_practices/atvos_demo/include/device/device_elewise.h | 2 +-
 best_practices/atvos_demo/test/main.cpp                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/best_practices/atvos_demo/include/device/device_elewise.h b/best_practices/atvos_demo/include/device/device_elewise.h
index 6dfee67d8..2c05501d0 100644
--- a/best_practices/atvos_demo/include/device/device_elewise.h
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -32,7 +32,7 @@ void CleanACL(aclrtStream &stream, aclrtContext &context, int32_t deviceId)
 // __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
 // {
 //     KernelOp op;
-//     AscendC::TPipe myPipe;
+//     AscendC::TPipe pipeIn;
 //     AscendC::printf("x: %p\n", x);
 //     AscendC::printf("y: %p\n", y);
 //     AscendC::printf("z: %p\n", z);
diff --git a/best_practices/atvos_demo/test/main.cpp b/best_practices/atvos_demo/test/main.cpp
index d058c6621..281d25f3a 100644
--- a/best_practices/atvos_demo/test/main.cpp
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -17,7 +17,7 @@ template<class KernelOp>
 __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
 {
     KernelOp op;
-    AscendC::TPipe myPipe;
+    AscendC::TPipe pipeIn;
     AscendC::printf("x: %p\n", x);
     AscendC::printf("y: %p\n", y);
     AscendC::printf("z: %p\n", z);
-- 
Gitee


From 3ba748b33cb688ecafc8d14eafa621ff99df4da3 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 30 Sep 2025 13:54:57 +0800
Subject: [PATCH 034/116] Implement Tensor with layout and slicing support

---
 .../expr_template_demo.cpp                    |  60 +----
 best_practices/expression_template/layout.h   | 236 +++++++++++++++++
 best_practices/expression_template/tensor.h   | 241 ++++++++++++++++++
 .../expression_template/tensor_test.cpp       |  34 +++
 4 files changed, 512 insertions(+), 59 deletions(-)
 create mode 100644 best_practices/expression_template/layout.h
 create mode 100644 best_practices/expression_template/tensor.h
 create mode 100644 best_practices/expression_template/tensor_test.cpp

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 5a24e9614..e7f3db3ae 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -5,6 +5,7 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
+#include "tensor.h"
 
 
 /* Utilities */
@@ -747,65 +748,6 @@ using Util::TMP::Size_v;
 
 using namespace ExprTmpl;
 
-template <typename T>
-class Tensor {
-public:
-    Tensor() = default;
-    explicit Tensor(std::vector<T>& src)
-    {
-        SetSize(src.size());
-    }
-
-    T& operator[](std::size_t pos)
-    {
-        return ptr_[pos];
-    }
-    const T& operator[](std::size_t pos) const
-    {
-        return ptr_[pos];
-    }
-
-    void Clear()
-    {
-        delete[] ptr_;
-        ptr_ = nullptr;
-        len_ = 0;
-    }
-
-    void SetSize(std::size_t size)
-    {
-        if (ptr_ != nullptr) {
-            throw std::logic_error(
-                "MyTensor::SetSize can only be called on an empty object");
-        }
-        ptr_ = new T[size];
-        len_ = size;
-    }
-    std::size_t GetSize() const
-    {
-        return len_;
-    }
-
-    void CopyIn(const std::vector<T>& src)
-    {
-        if (src.size() > len_) {
-            throw std::logic_error("Source vector is too big");
-        }
-        std::copy(src.begin(), src.end(), ptr_);
-    }
-    void CopyOut(std::vector<T>& dst)
-    {
-        if (dst.size() < len_) {
-            throw std::logic_error("Destination vector is too small");
-        }
-        std::copy_n(ptr_, len_, dst.begin());
-    }
-
-private:
-    T* ptr_{};
-    std::size_t len_{};
-};
-
 // Primary template
 template <typename T>
 struct Evaluator {
diff --git a/best_practices/expression_template/layout.h b/best_practices/expression_template/layout.h
new file mode 100644
index 000000000..65b178b66
--- /dev/null
+++ b/best_practices/expression_template/layout.h
@@ -0,0 +1,236 @@
+#ifndef LAYOUT_H
+#define LAYOUT_H
+
+#include <array>
+#include <cstddef>
+#include <functional>
+#include <numeric>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+namespace DemoEval {
+
+inline constexpr auto dynamicExtent = std::size_t(-1);
+
+template <typename T, std::size_t N>
+class FixedRankExtents {
+public:
+    using value_type = T;
+    static constexpr std::size_t rank = N;
+
+    constexpr FixedRankExtents() = default;
+
+    template <
+        typename... Args,
+        std::enable_if_t<(std::is_convertible_v<Args, T> && ...), int> = 0>
+    constexpr explicit FixedRankExtents(Args... args)
+        : data_{static_cast<T>(args)...}
+    {
+        static_assert(sizeof...(args) == N,
+                      "Number of arguments must match rank");
+    }
+
+    constexpr T operator[](std::size_t i) const { return data_[i]; }
+    constexpr T& operator[](std::size_t i) { return data_[i]; }
+
+    constexpr std::size_t size() const { return N; }
+
+    constexpr auto begin() const { return data_.begin(); }
+    constexpr auto end() const { return data_.end(); }
+
+private:
+    std::array<T, N> data_{};
+};
+
+template <typename T>
+class VariableRankExtents {
+public:
+    using value_type = T;
+    static constexpr std::size_t rank = dynamicExtent;
+
+    VariableRankExtents() = default;
+
+    template <typename... Args>
+    explicit VariableRankExtents(Args... args)
+        : data_{static_cast<T>(args)...}
+    {
+    }
+
+    template <typename U, std::size_t N>
+    VariableRankExtents(const FixedRankExtents<U, N>& extents)
+        : data_(extents.begin(), extents.end())
+    {}
+
+    T operator[](std::size_t i) const { return data_[i]; }
+    T& operator[](std::size_t i) { return data_[i]; }
+
+    std::size_t size() const { return data_.size(); }
+
+    auto begin() const { return data_.begin(); }
+    auto end() const { return data_.end(); }
+
+    void push_back(const T& value) { data_.push_back(value); }
+    void resize(std::size_t size) { data_.resize(size); }
+
+private:
+    std::vector<T> data_;
+};
+
+template <typename Shape = VariableRankExtents<std::size_t>,
+          typename Stride = Shape>
+class Layout {
+public:
+    using shape_type = Shape;
+    using stride_type = Stride;
+    using index_type = typename Shape::value_type;
+
+    constexpr Layout() = default;
+
+    template <typename S, typename = std::enable_if_t<
+                              !std::is_same_v<std::decay_t<S>, Layout>>>
+    constexpr explicit Layout(S&& shape)
+        : shape_(std::forward<S>(shape)), stride_(computeStride(shape_))
+    {
+    }
+
+    template <typename S, typename St>
+    constexpr Layout(const Layout<S, St>& other)
+        : shape_(other.shape()), stride_(other.stride())
+    {
+    }
+
+    template <typename S, typename St>
+    constexpr Layout(S&& shape, St&& stride, index_type base_offset = 0)
+        : shape_(std::forward<S>(shape)),
+          stride_(std::forward<St>(stride)),
+          base_offset_(base_offset)
+    {
+    }
+
+    constexpr Shape& shape() { return shape_; }
+    constexpr const Shape& shape() const { return shape_; }
+    constexpr Stride& stride() { return stride_; }
+    constexpr const Stride& stride() const { return stride_; }
+
+    template <typename... Coords>
+    constexpr index_type operator()(Coords... coords) const
+    {
+        if constexpr (Shape::rank == dynamicExtent) {
+            // Runtime validation for dynamic layouts
+            if (sizeof...(coords) != rank()) {
+                throw std::invalid_argument(
+                    "Number of coordinates must match layout rank");
+            }
+        } else {
+            static_assert(sizeof...(coords) == Shape::rank,
+                          "Number of coordinates must match layout rank");
+        }
+        return coordinateToIndex(coords...);
+    }
+
+    constexpr std::size_t size() const
+    {
+        return std::accumulate(shape_.begin(), shape_.end(), std::size_t(1),
+                               std::multiplies<std::size_t>{});
+    }
+
+    constexpr std::size_t rank() const { return shape_.size(); }
+
+    constexpr auto slice(std::size_t dim, index_type value = 0) const
+    {
+        using ExtentType = decltype(makeSlicedShape(
+            shape_, std::is_same<Shape, VariableRankExtents<index_type>>{}));
+        ExtentType newShape;
+        ExtentType newStride;
+
+        index_type newBaseOffset = base_offset_ + value * stride_[dim];
+
+        if constexpr (Shape::rank == dynamicExtent) {
+            newShape.resize(shape_.size() - 1);
+            newStride.resize(stride_.size() - 1);
+        }
+
+        // Copy all dimensions except the sliced one
+        std::size_t newIndex = 0;
+        for (std::size_t i = 0; i < shape_.size(); ++i) {
+            if (i != dim) {
+                newShape[newIndex] = shape_[i];
+                newStride[newIndex] = stride_[i];
+                ++newIndex;
+            }
+        }
+        return Layout<ExtentType, ExtentType>(
+            std::move(newShape), std::move(newStride), newBaseOffset);
+    }
+
+private:
+    template <typename S>
+    constexpr Stride computeStride(const S& shape) const
+    {
+        Stride stride;
+
+        if constexpr (S::rank == dynamicExtent) {
+            stride.resize(shape.size());
+        }
+
+        if (shape.size() > 0) {
+            stride[0] = 1;
+            for (std::size_t i = 1; i < shape.size(); ++i) {
+                stride[i] = stride[i - 1] * shape[i - 1];
+            }
+        }
+
+        return stride;
+    }
+
+    template <typename... Coords>
+    constexpr index_type coordinateToIndex(Coords... coords) const
+    {
+        return base_offset_ + coordinateToIndexImpl(0, coords...);
+    }
+
+    template <typename Coord>
+    constexpr index_type coordinateToIndexImpl(std::size_t dim,
+                                               Coord coord) const
+    {
+        return stride_[dim] * coord;
+    }
+
+    template <typename Coord, typename... Rest>
+    constexpr index_type coordinateToIndexImpl(std::size_t dim, Coord coord,
+                                               Rest... rest) const
+    {
+        return stride_[dim] * coord +
+               coordinateToIndexImpl(dim + 1, rest...);
+    }
+
+    template <typename Shape2>
+    static auto makeSlicedShape(const Shape2& /*shape*/,
+                                std::true_type /*is_dynamic*/)
+    {
+        return VariableRankExtents<index_type>{};
+    }
+
+    template <typename Shape2>
+    static auto makeSlicedShape(const Shape2& /*shape*/,
+                                std::false_type /*is_static*/)
+    {
+        return FixedRankExtents<index_type, Shape2::rank - 1>{};
+    }
+
+    Shape shape_;
+    Stride stride_;
+    index_type base_offset_{};
+};
+
+template <typename... Args>
+auto make_layout(Args... args)
+{
+    return Layout<FixedRankExtents<std::size_t, sizeof...(args)>>(
+        FixedRankExtents<std::size_t, sizeof...(args)>{args...});
+}
+
+} // namespace DemoEval
+
+#endif // LAYOUT_H
diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
new file mode 100644
index 000000000..6757b04f5
--- /dev/null
+++ b/best_practices/expression_template/tensor.h
@@ -0,0 +1,241 @@
+#ifndef TENSOR_H
+#define TENSOR_H
+
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+#include "layout.h"
+
+namespace DemoEval {
+
+template <typename T, typename L = Layout<VariableRankExtents<std::size_t>>>
+class Tensor {
+public:
+    using ValueType = T;
+    using LayoutType = L;
+    using IndexType = typename LayoutType::index_type;
+
+    Tensor() = default;
+    Tensor(T* ptr, std::size_t len, LayoutType layout)
+        : ptr_(ptr), len_(len), layout_(std::move(layout))
+    {
+    }
+    Tensor(std::initializer_list<T> init)
+    {
+        SetSize(init.size());
+        std::copy(init.begin(), init.end(), ptr_);
+        if constexpr (LayoutType::shape_type::rank == 1 ||
+                      LayoutType::shape_type::rank == dynamicExtent) {
+            SetLayout(make_layout(init.size()));
+        }
+    }
+    Tensor(std::initializer_list<T> init, const LayoutType& layout)
+        : layout_(layout)
+    {
+        SetSize(init.size());
+        std::copy(init.begin(), init.end(), ptr_);
+    }
+    explicit Tensor(const std::vector<T>& src)
+    {
+        SetSize(src.size());
+    }
+
+    T& operator[](std::size_t pos)
+    {
+        return ptr_[pos];
+    }
+    const T& operator[](std::size_t pos) const
+    {
+        return ptr_[pos];
+    }
+
+    template <typename... Coords>
+    T& operator()(Coords... coords)
+    {
+        return ptr_[layout_(coords...)];
+    }
+    template <typename... Coords>
+    const T& operator()(Coords... coords) const
+    {
+        return ptr_[layout_(coords...)];
+    }
+
+    template <typename Tp, typename V>
+    class iterator {
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type = V;
+        using pointer = V*;
+        using reference = V&;
+        using iterator_category = std::random_access_iterator_tag;
+
+        iterator(Tp tensor, IndexType pos)
+            : tensor_(tensor), pos_(pos)
+        {
+        }
+        bool operator==(const iterator& other) const
+        {
+            return tensor_ == other.tensor_ && pos_ == other.pos_;
+        }
+        bool operator!=(const iterator& other) const
+        {
+            return !(operator==(other));
+        }
+        V& operator*() const
+        {
+            return (*tensor_)(pos_);
+        }
+        V* operator->() const
+        {
+            return &(*tensor_)(pos_);
+        }
+        iterator& operator++()
+        {
+            ++pos_;
+            return *this;
+        }
+        iterator& operator--()
+        {
+            --pos_;
+            return *this;
+        }
+        iterator operator++(int)
+        {
+            iterator result = *this;
+            ++pos_;
+            return result;
+        }
+        iterator operator--(int)
+        {
+            iterator result = *this;
+            --pos_;
+            return result;
+        }
+        iterator& operator+=(difference_type n)
+        {
+            pos_ += n;
+            return *this;
+        }
+        iterator& operator-=(difference_type n)
+        {
+            pos_ -= n;
+            return *this;
+        }
+        iterator operator+(difference_type n) const
+        {
+            iterator result = *this;
+            result += n;
+            return result;
+        }
+        iterator operator-(difference_type n) const
+        {
+            iterator result = *this;
+            result -= n;
+            return result;
+        }
+        difference_type operator-(const iterator& other) const
+        {
+            return pos_ - other.pos_;
+        }
+
+    private:
+        Tp tensor_;
+        IndexType pos_;
+    };
+
+    template <typename U = LayoutType,
+              std::enable_if_t<U::shape_type::rank == 1, int> = 0>
+    auto begin()
+    {
+        return iterator<Tensor*, T>{this, 0};
+    }
+    template <typename U = LayoutType,
+              std::enable_if_t<U::shape_type::rank == 1, int> = 0>
+    auto begin() const
+    {
+        return iterator<const Tensor*, const T>{this, 0};
+    }
+    template <typename U = LayoutType,
+              std::enable_if_t<U::shape_type::rank == 1, int> = 0>
+    auto end()
+    {
+        return iterator<Tensor*, T>{this, layout_.size()};
+    }
+    template <typename U = LayoutType,
+              std::enable_if_t<U::shape_type::rank == 1, int> = 0>
+    auto end() const
+    {
+        return iterator<const Tensor*, const T>{this, layout_.size()};
+    }
+
+    auto Slice(std::size_t dim, IndexType value = 0)
+    {
+        if constexpr (LayoutType::shape_type::rank == dynamicExtent) {
+            Tensor result{ptr_, len_, layout_.slice(dim, value)};
+            return result;
+        } else {
+            Tensor<ValueType,
+                   Layout<FixedRankExtents<
+                       typename LayoutType::shape_type::value_type,
+                       LayoutType::shape_type::rank - 1>>>
+                result{ptr_, len_, layout_.slice(dim, value)};
+            return result;
+        }
+    }
+
+    void Clear()
+    {
+        delete[] ptr_;
+        ptr_ = nullptr;
+        len_ = 0;
+    }
+
+    void SetSize(std::size_t size)
+    {
+        if (ptr_ != nullptr) {
+            throw std::logic_error(
+                "Tensor::SetSize can only be called on an empty object");
+        }
+        ptr_ = new T[size];
+        len_ = size;
+    }
+    std::size_t GetSize() const
+    {
+        return len_;
+    }
+    void SetLayout(const LayoutType& layout)
+    {
+        layout_ = layout;
+    }
+    const LayoutType& GetLayout() const
+    {
+        return layout_;
+    }
+
+    void CopyIn(const std::vector<T>& src)
+    {
+        if (src.size() > len_) {
+            throw std::logic_error("Source vector is too big");
+        }
+        std::copy(src.begin(), src.end(), ptr_);
+    }
+    void CopyOut(std::vector<T>& dst)
+    {
+        if (dst.size() < len_) {
+            throw std::logic_error("Destination vector is too small");
+        }
+        std::copy_n(ptr_, len_, dst.begin());
+    }
+
+private:
+    T* ptr_{};
+    std::size_t len_{};
+    LayoutType layout_;
+};
+
+} // namespace DemoEval
+
+#endif // TENSOR_H
diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
new file mode 100644
index 000000000..6cecef30f
--- /dev/null
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -0,0 +1,34 @@
+#include "tensor.h"
+#include <algorithm>
+#include <cstddef>
+#include <iostream>
+#include <iterator>
+#include "layout.h"
+
+int main()
+{
+    using namespace DemoEval;
+
+    Tensor<float, Layout<FixedRankExtents<std::size_t, 2>>> tensor{
+        1, 2, 3, 4, 5, 6};
+    tensor.SetLayout(make_layout(2, 3));  // column-major only now
+    // Content is
+    //   1 3 5
+    //   2 4 6
+    for (int i = 0; i < 2; ++i) {
+        for (int j = 0; j < 3; ++j) {
+            std::cout << tensor(i, j) << ' ';
+        }
+        std::cout << '\n';
+    }
+    std::cout << '\n';
+
+    auto slice = tensor.Slice(0, 1);  // row (0th dimension) 1: {2, 4, 6}
+    slice(2) = 7;
+    std::copy(slice.begin(), slice.end(),
+              std::ostream_iterator<float>(std::cout, " "));
+    std::cout << '\n';
+
+    tensor.Clear();
+    // Neither tensor nor slice can be accessed from now on
+}
-- 
Gitee


From 29c6ce00c661319ec46e58c5e23b89063e67ad88 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 30 Sep 2025 20:00:01 +0800
Subject: [PATCH 035/116] Switch to row-major order

---
 best_practices/expression_template/layout.h        | 7 ++++---
 best_practices/expression_template/tensor_test.cpp | 8 ++++----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/best_practices/expression_template/layout.h b/best_practices/expression_template/layout.h
index 65b178b66..15881fb2f 100644
--- a/best_practices/expression_template/layout.h
+++ b/best_practices/expression_template/layout.h
@@ -175,9 +175,10 @@ private:
         }
 
         if (shape.size() > 0) {
-            stride[0] = 1;
-            for (std::size_t i = 1; i < shape.size(); ++i) {
-                stride[i] = stride[i - 1] * shape[i - 1];
+            // Row-major order: last dimension has stride 1
+            stride[shape.size() - 1] = 1;
+            for (std::size_t i = shape.size() - 1; i > 0; --i) {
+                stride[i - 1] = stride[i] * shape[i];
             }
         }
 
diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
index 6cecef30f..98ef8f78f 100644
--- a/best_practices/expression_template/tensor_test.cpp
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -11,10 +11,10 @@ int main()
 
     Tensor<float, Layout<FixedRankExtents<std::size_t, 2>>> tensor{
         1, 2, 3, 4, 5, 6};
-    tensor.SetLayout(make_layout(2, 3));  // column-major only now
+    tensor.SetLayout(make_layout(2, 3));  // row-major order now
     // Content is
-    //   1 3 5
-    //   2 4 6
+    //   1 2 3
+    //   4 5 6
     for (int i = 0; i < 2; ++i) {
         for (int j = 0; j < 3; ++j) {
             std::cout << tensor(i, j) << ' ';
@@ -23,7 +23,7 @@ int main()
     }
     std::cout << '\n';
 
-    auto slice = tensor.Slice(0, 1);  // row (0th dimension) 1: {2, 4, 6}
+    auto slice = tensor.Slice(0, 1);  // row (0th dimension) 1: {4, 5, 6}
     slice(2) = 7;
     std::copy(slice.begin(), slice.end(),
               std::ostream_iterator<float>(std::cout, " "));
-- 
Gitee


From dbb995736d6e01e11cc3c4c907d219b7d28e89d8 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 2 Oct 2025 21:26:03 +0800
Subject: [PATCH 036/116] Make iteration work on multi-dimensional tensors

---
 best_practices/expression_template/tensor.h   | 128 ++++++++++++++++++
 .../expression_template/tensor_test.cpp       |   4 +
 2 files changed, 132 insertions(+)

diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index 6757b04f5..2317c851e 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -1,11 +1,13 @@
 #ifndef TENSOR_H
 #define TENSOR_H
 
+#include <array>
 #include <cstddef>
 #include <initializer_list>
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
+#include <utility>
 #include <vector>
 #include "layout.h"
 
@@ -63,6 +65,7 @@ public:
         return ptr_[layout_(coords...)];
     }
 
+    // 1D iterator
     template <typename Tp, typename V>
     class iterator {
     public:
@@ -146,6 +149,97 @@ public:
         IndexType pos_;
     };
 
+    // Multi-dimensional iterator for fixed-rank tensors
+    template <typename Tp, typename V>
+    class multidim_iterator {
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type = V;
+        using pointer = V*;
+        using reference = V&;
+        using iterator_category = std::forward_iterator_tag;
+
+        static constexpr std::size_t rank = LayoutType::shape_type::rank;
+
+        multidim_iterator(Tp tensor, bool is_end = false) : tensor_(tensor)
+        {
+            coords_.fill(0);
+            if (is_end) {
+                // Set to end position: first coordinate = shape[0]
+                if (tensor_->GetLayout().shape().size() > 0) {
+                    coords_[0] = tensor_->GetLayout().shape()[0];
+                }
+            }
+        }
+
+        bool operator==(const multidim_iterator& other) const
+        {
+            return tensor_ == other.tensor_ && coords_ == other.coords_;
+        }
+
+        bool operator!=(const multidim_iterator& other) const
+        {
+            return !(*this == other);
+        }
+
+        V& operator*() const
+        {
+            return accessElement(std::make_index_sequence<rank>{});
+        }
+
+        V* operator->() const { return &(**this); }
+
+        multidim_iterator& operator++()
+        {
+            incrementCoords();
+            return *this;
+        }
+
+        multidim_iterator operator++(int)
+        {
+            multidim_iterator result = *this;
+            ++(*this);
+            return result;
+        }
+
+    private:
+        template <std::size_t... Is>
+        V& accessElement(std::index_sequence<Is...>) const
+        {
+            return (*tensor_)(coords_[Is]...);
+        }
+
+        void incrementCoords()
+        {
+            const auto& shape = tensor_->GetLayout().shape();
+
+            // Increment coordinates in row-major order (rightmost dimension
+            // first)
+            for (std::size_t dim = rank; dim > 0; --dim) {
+                std::size_t idx = dim - 1;
+                ++coords_[idx];
+
+                if (coords_[idx] < shape[idx]) {
+                    // No carry needed
+                    return;
+                } else {
+                    // Carry to next dimension
+                    coords_[idx] = 0;
+                }
+            }
+
+            // If we get here, we've overflowed - set to end position
+            coords_.fill(0);
+            if (shape.size() > 0) {
+                coords_[0] = shape[0];
+            }
+        }
+
+        Tp tensor_;
+        std::array<std::size_t, rank> coords_;
+    };
+
+    // For 1D tensors
     template <typename U = LayoutType,
               std::enable_if_t<U::shape_type::rank == 1, int> = 0>
     auto begin()
@@ -171,6 +265,40 @@ public:
         return iterator<const Tensor*, const T>{this, layout_.size()};
     }
 
+    // For multi-dimensional fixed-rank tensors
+    template <typename U = LayoutType,
+              std::enable_if_t<(U::shape_type::rank != dynamicExtent &&
+                                U::shape_type::rank != 1),
+                               int> = 0>
+    auto begin()
+    {
+        return multidim_iterator<Tensor*, T>{this, false};
+    }
+    template <typename U = LayoutType,
+              std::enable_if_t<(U::shape_type::rank != dynamicExtent &&
+                                U::shape_type::rank != 1),
+                               int> = 0>
+    auto begin() const
+    {
+        return multidim_iterator<const Tensor*, const T>{this, false};
+    }
+    template <typename U = LayoutType,
+              std::enable_if_t<(U::shape_type::rank != dynamicExtent &&
+                                U::shape_type::rank != 1),
+                               int> = 0>
+    auto end()
+    {
+        return multidim_iterator<Tensor*, T>{this, true};
+    }
+    template <typename U = LayoutType,
+              std::enable_if_t<(U::shape_type::rank != dynamicExtent &&
+                                U::shape_type::rank != 1),
+                               int> = 0>
+    auto end() const
+    {
+        return multidim_iterator<const Tensor*, const T>{this, true};
+    }
+
     auto Slice(std::size_t dim, IndexType value = 0)
     {
         if constexpr (LayoutType::shape_type::rank == dynamicExtent) {
diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
index 98ef8f78f..cf9e8d1a7 100644
--- a/best_practices/expression_template/tensor_test.cpp
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -23,6 +23,10 @@ int main()
     }
     std::cout << '\n';
 
+    std::copy(tensor.begin(), tensor.end(),
+              std::ostream_iterator<float>(std::cout, " "));
+    std::cout << '\n';
+
     auto slice = tensor.Slice(0, 1);  // row (0th dimension) 1: {4, 5, 6}
     slice(2) = 7;
     std::copy(slice.begin(), slice.end(),
-- 
Gitee


From 3fd00f311cf8c6f7a92ddc5fdfd3aa4866ad6d05 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 2 Oct 2025 21:28:20 +0800
Subject: [PATCH 037/116] Adjust code format

---
 best_practices/expression_template/layout.h |  3 +-
 best_practices/expression_template/tensor.h | 45 +++++----------------
 2 files changed, 11 insertions(+), 37 deletions(-)

diff --git a/best_practices/expression_template/layout.h b/best_practices/expression_template/layout.h
index 15881fb2f..ab2e0fa53 100644
--- a/best_practices/expression_template/layout.h
+++ b/best_practices/expression_template/layout.h
@@ -60,7 +60,8 @@ public:
     template <typename U, std::size_t N>
     VariableRankExtents(const FixedRankExtents<U, N>& extents)
         : data_(extents.begin(), extents.end())
-    {}
+    {
+    }
 
     T operator[](std::size_t i) const { return data_[i]; }
     T& operator[](std::size_t i) { return data_[i]; }
diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index 2317c851e..fd777d119 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -40,19 +40,10 @@ public:
         SetSize(init.size());
         std::copy(init.begin(), init.end(), ptr_);
     }
-    explicit Tensor(const std::vector<T>& src)
-    {
-        SetSize(src.size());
-    }
+    explicit Tensor(const std::vector<T>& src) { SetSize(src.size()); }
 
-    T& operator[](std::size_t pos)
-    {
-        return ptr_[pos];
-    }
-    const T& operator[](std::size_t pos) const
-    {
-        return ptr_[pos];
-    }
+    T& operator[](std::size_t pos) { return ptr_[pos]; }
+    const T& operator[](std::size_t pos) const { return ptr_[pos]; }
 
     template <typename... Coords>
     T& operator()(Coords... coords)
@@ -75,10 +66,7 @@ public:
         using reference = V&;
         using iterator_category = std::random_access_iterator_tag;
 
-        iterator(Tp tensor, IndexType pos)
-            : tensor_(tensor), pos_(pos)
-        {
-        }
+        iterator(Tp tensor, IndexType pos) : tensor_(tensor), pos_(pos) {}
         bool operator==(const iterator& other) const
         {
             return tensor_ == other.tensor_ && pos_ == other.pos_;
@@ -87,14 +75,8 @@ public:
         {
             return !(operator==(other));
         }
-        V& operator*() const
-        {
-            return (*tensor_)(pos_);
-        }
-        V* operator->() const
-        {
-            return &(*tensor_)(pos_);
-        }
+        V& operator*() const { return (*tensor_)(pos_); }
+        V* operator->() const { return &(*tensor_)(pos_); }
         iterator& operator++()
         {
             ++pos_;
@@ -330,18 +312,9 @@ public:
         ptr_ = new T[size];
         len_ = size;
     }
-    std::size_t GetSize() const
-    {
-        return len_;
-    }
-    void SetLayout(const LayoutType& layout)
-    {
-        layout_ = layout;
-    }
-    const LayoutType& GetLayout() const
-    {
-        return layout_;
-    }
+    std::size_t GetSize() const { return len_; }
+    void SetLayout(const LayoutType& layout) { layout_ = layout; }
+    const LayoutType& GetLayout() const { return layout_; }
 
     void CopyIn(const std::vector<T>& src)
     {
-- 
Gitee


From f9e678d51fd7a721246338a711f56a2a975117f5 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Sun, 19 Oct 2025 23:04:44 +0800
Subject: [PATCH 038/116] Implement a basic SlicedView

---
 best_practices/expression_template/tensor.h | 124 ++++++++++++++++++++
 1 file changed, 124 insertions(+)

diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index fd777d119..b5bbd3c8c 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -337,6 +337,130 @@ private:
     LayoutType layout_;
 };
 
+template <typename TensorType, std::size_t NumSliceDims>
+class SlicedView {
+public:
+    using ValueType = typename TensorType::ValueType;
+    using LayoutType = typename TensorType::LayoutType;
+    using IndexType = typename LayoutType::index_type;
+
+    static constexpr std::size_t tensorRank = LayoutType::shape_type::rank;
+    static constexpr std::size_t remainingRank = tensorRank - NumSliceDims;
+
+    SlicedView(TensorType& tensor,
+                   std::array<std::size_t, NumSliceDims> sliceDims)
+        : tensor_(tensor), sliceDims_(sliceDims)
+    {
+    }
+
+    class iterator {
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type =
+            Tensor<ValueType,
+                   Layout<FixedRankExtents<IndexType, remainingRank>>>;
+        using pointer = value_type*;
+        using reference = value_type&;
+        using iterator_category = std::forward_iterator_tag;
+
+        iterator(SlicedView* view, bool isEnd = false)
+            : view_(view), isEnd_(isEnd)
+        {
+            if (!isEnd) {
+                sliceCoords_.fill(0);
+                UpdateSubTensor();
+            }
+        }
+
+        bool operator!=(const iterator& other) const
+        {
+            if (isEnd_ && other.isEnd_) {
+                return false;
+            }
+            if (isEnd_ != other.isEnd_) {
+                return true;
+            }
+            return sliceCoords_ != other.sliceCoords_;
+        }
+
+        value_type& operator*() { return subTensor_; }
+        value_type* operator->() { return &subTensor_; }
+
+        iterator& operator++()
+        {
+            if (!isEnd_) {
+                Increment();
+                if (!isEnd_) {
+                    UpdateSubTensor();
+                }
+            }
+            return *this;
+        }
+
+    private:
+        void Increment()
+        {
+            const auto& shape = view_->tensor_.GetLayout().shape();
+
+            for (int i = static_cast<int>(NumSliceDims) - 1; i >= 0; --i) {
+                std::size_t dim =
+                    view_->sliceDims_[static_cast<std::size_t>(i)];
+                ++sliceCoords_[static_cast<std::size_t>(i)];
+
+                if (sliceCoords_[static_cast<std::size_t>(i)] <
+                    shape[dim]) {
+                    return;
+                }
+                sliceCoords_[static_cast<std::size_t>(i)] = 0;
+            }
+
+            isEnd_ = true;
+        }
+
+        void UpdateSubTensor()
+        {
+            subTensor_ = SliceRecursive<0>(view_->tensor_);
+        }
+
+        template <std::size_t Idx, typename T>
+        auto SliceRecursive(T& tensor)
+        {
+            std::size_t adjustedDim = view_->sliceDims_[Idx];
+            for (std::size_t j = 0; j < Idx; ++j) {
+                if (view_->sliceDims_[j] < adjustedDim) {
+                    --adjustedDim;
+                }
+            }
+
+            auto sliced = tensor.Slice(adjustedDim, sliceCoords_[Idx]);
+
+            if constexpr (Idx + 1 < NumSliceDims) {
+                return SliceRecursive<Idx + 1>(sliced);
+            } else {
+                return sliced;
+            }
+        }
+
+        SlicedView* view_;
+        std::array<std::size_t, NumSliceDims> sliceCoords_;
+        bool isEnd_ = false;
+        value_type subTensor_;
+    };
+
+    iterator begin() { return iterator{this, false}; }
+    iterator end() { return iterator{this, true}; }
+
+private:
+    TensorType& tensor_;
+    std::array<std::size_t, NumSliceDims> sliceDims_;
+};
+
+template <std::size_t N, typename TensorType>
+auto MakeSlicedView(TensorType& tensor, std::array<std::size_t, N> dims)
+{
+    return SlicedView<TensorType, N>{tensor, dims};
+}
+
 } // namespace DemoEval
 
 #endif // TENSOR_H
-- 
Gitee


From 793925fe3f1677977f4b338da077cbf8facc6683 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 20 Oct 2025 10:00:54 +0800
Subject: [PATCH 039/116] Fix a compilation problem with Clang

---
 .../expression_template/expr_template_demo.cpp           | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index e7f3db3ae..c8e1f2e48 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1235,12 +1235,15 @@ void CopyOut(OutParamTup& outParams, ArgTup& args)
                                    std::make_index_sequence<size>{});
 }
 
+template <typename T>
+using SimpleTensor = DemoEval::Tensor<T>;
+
 template <typename ExprMaker, typename... Args,
           typename = std::enable_if_t<
               std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
 void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
-    auto expr = maker.template Get<Tensor>();
+    auto expr = maker.template Get<SimpleTensor>();
     using Expr = typename decltype(expr)::Type;
     static_assert(
         !Expr::hasData,
@@ -1376,8 +1379,8 @@ int main() // NOLINT(bugprone-exception-escape)
     std::vector<float> v4(300, 4.0F);
     std::vector<float> v5(300);
     std::cout
-        << "sizeof(decltype(MyAddOp<float>{}.Get<Tensor>())) is "
-        << sizeof(decltype(MyAddOp<float>{}.Get<Tensor>())) << '\n';
+        << "sizeof(decltype(MyAddOp<float>{}.Get<Emulation::SimpleTensor>())) is "
+        << sizeof(decltype(MyAddOp<float>{}.Get<Emulation::SimpleTensor>())) << '\n';
     Emulation::DoElementwise(MyAddOp<float>{}, v1, v2, v3, v4, v5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
-- 
Gitee


From 5c61b6f0681a05437a36ecba973a54c084c8afe3 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 20 Oct 2025 10:31:48 +0800
Subject: [PATCH 040/116] Add and use PrepareLocalVars

---
 .../expression_template/expr_template_demo.cpp        | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index c8e1f2e48..9698b3f70 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1199,6 +1199,14 @@ auto ConvertArgs(ParamTup& params, ArgTup& args)
         std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
 }
 
+template <typename LocalVars, typename ArgTup>
+auto PrepareLocalVars(ArgTup& args)
+{
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, args);
+    return localVars;
+}
+
 template <typename Params, typename ParamTup>
 auto GetInParams(ParamTup& params)
 {
@@ -1259,8 +1267,7 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     auto params = PrepareParams<Params>(argTuple);
     auto convertedArgs = ConvertArgs<Params>(params, argTuple);
     using LocalVars = LocalVars_t<Expr>;
-    auto localVars = GetLocalVarTuple<LocalVars>();
-    MakeAlikeLocalVars<LocalVars>(localVars, convertedArgs);
+    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
 
     // tuple of references
     auto inParams = GetInParams<Params>(params);
-- 
Gitee


From c9f40d898b0959a9be7f07fa96d675cf7eac192a Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 20 Oct 2025 11:34:30 +0800
Subject: [PATCH 041/116] Fix memory leaks

---
 .../expr_template_demo.cpp                    | 69 ++++++++++++++++++-
 1 file changed, 67 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 9698b3f70..1235ac199 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -27,6 +27,16 @@ struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
 template <template <typename...> class T, typename U>
 inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
 
+template <typename T, typename = void>
+struct HasClear : std::false_type {};
+
+template <typename T>
+struct HasClear<T, std::void_t<decltype(std::declval<T&>().Clear())>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool HasClear_v = HasClear<T>::value;
+
 template <
     typename Tuple, typename Func,
     std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
@@ -848,6 +858,44 @@ void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
         std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
 }
 
+template <typename T>
+class final_action {
+public:
+    explicit final_action(T action) : action_(std::move(action)) {}
+
+    final_action(final_action&& other) noexcept
+        : action_(std::move(other.action_)),
+          is_active_(std::exchange(other.is_active_, false))
+    {
+    }
+
+    final_action(const final_action&) = delete;
+    final_action& operator=(const final_action&) = delete;
+    final_action& operator=(final_action&&) = delete;
+
+    ~final_action()
+    {
+        if (is_active_) {
+            action_();
+        }
+    }
+
+    void dismiss() noexcept
+    {
+        is_active_ = false;
+    }
+
+private:
+    T action_;
+    bool is_active_{true};
+};
+
+template <typename T>
+auto finally(T&& action)
+{
+    return final_action<std::decay_t<T>>(std::forward<T>(action));
+}
+
 template <typename T, typename... Args>
 auto Evaluate(const Expression<T>& expr, Args&&... args)
 {
@@ -858,6 +906,13 @@ auto Evaluate(const Expression<T>& expr, Args&&... args)
     [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
     auto localVars = GetLocalVarTuple<LocalVars>();
     MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
+    auto cleanup = finally([&] {
+        Util::ForEach(localVars, [](auto& arg) {
+            if constexpr (Util::HasClear_v<decltype(arg)>) {
+                arg.Clear();
+            }
+        });
+    });
     return Evaluator<T>{}(expr.data, argTuple, localVars);
 }
 
@@ -1277,8 +1332,16 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
     CopyOut<OutParams>(outParams, argTuple);
 
-    Util::ForEach(params, [](auto& arg) { arg.Clear(); });
-    Util::ForEach(localVars, [](auto& arg) { arg.Clear(); });
+    Util::ForEach(params, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+    Util::ForEach(localVars, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
 }
 
 } // namespace Emulation
@@ -1379,6 +1442,8 @@ int main() // NOLINT(bugprone-exception-escape)
               << srcTensor[4] << "] dst=[" << dstTensor[0] << ","
               << dstTensor[1] << "," << dstTensor[2] << "," << dstTensor[3]
               << "," << dstTensor[4] << "]\n";
+    srcTensor.Clear();
+    dstTensor.Clear();
 
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
-- 
Gitee


From b9ed204d3f40a7a47efd0254d2e477418e5c64b6 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 20 Oct 2025 11:50:58 +0800
Subject: [PATCH 042/116] Add layout template parameter to Tensor-related
 functions

---
 .../expression_template/expr_template_demo.cpp   | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 1235ac199..eb7561a09 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -5,6 +5,7 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
+#include "layout.h"
 #include "tensor.h"
 
 
@@ -807,8 +808,8 @@ void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
     dst.resize(src.size());
 }
 
-template <typename T>
-void MakeAlikeDatum(Tensor<T>& dst, const Tensor<T>& src)
+template <typename T, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<T, L>& src)
 {
     dst.SetSize(src.GetSize());
 }
@@ -1027,10 +1028,10 @@ void AddAssign(std::vector<T>& dst,
     }
 }
 
-template <typename T>
-void AddAssign(Tensor<T>& dst,
-               const Tensor<T>& src1,
-               const Tensor<T>& src2)
+template <typename T, typename L>
+void AddAssign(Tensor<T, L>& dst,
+               const Tensor<T, L>& src1,
+               const Tensor<T, L>& src2)
 {
     if (src1.GetSize() != src2.GetSize()) {
         throw std::logic_error("Tensor sizes do not match");
@@ -1299,7 +1300,8 @@ void CopyOut(OutParamTup& outParams, ArgTup& args)
 }
 
 template <typename T>
-using SimpleTensor = DemoEval::Tensor<T>;
+using SimpleTensor = DemoEval::Tensor<
+    T, DemoEval::Layout<DemoEval::FixedRankExtents<std::size_t, 1>>>;
 
 template <typename ExprMaker, typename... Args,
           typename = std::enable_if_t<
-- 
Gitee


From 34397edab88e337d141053839484c888c28de568 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 20 Oct 2025 17:47:29 +0800
Subject: [PATCH 043/116] Support CopyIn/CopyOut between tensors

---
 best_practices/expression_template/tensor.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index b5bbd3c8c..4cb749235 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -316,6 +316,23 @@ public:
     void SetLayout(const LayoutType& layout) { layout_ = layout; }
     const LayoutType& GetLayout() const { return layout_; }
 
+    template <typename L2>
+    void CopyIn(const Tensor<T, L2>& src)
+    {
+        if (src.GetSize() > len_) {
+            throw std::logic_error("Source vector is too big");
+        }
+        std::copy(src.begin(), src.end(), ptr_);
+    }
+    template <typename L2>
+    void CopyOut(Tensor<T, L2>& dst)
+    {
+        if (dst.GetSize() < len_) {
+            throw std::logic_error("Destination vector is too small");
+        }
+        std::copy_n(ptr_, len_, dst.begin());
+    }
+
     void CopyIn(const std::vector<T>& src)
     {
         if (src.size() > len_) {
-- 
Gitee


From 9819eb47f1545de6c4bba7f3c5669c86f861f8c3 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 21 Oct 2025 01:01:58 +0800
Subject: [PATCH 044/116] Support iteration over multi-D dynamic-rank tensors

---
 best_practices/expression_template/tensor.h | 142 +++++++++++++++++++-
 1 file changed, 141 insertions(+), 1 deletion(-)

diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index 4cb749235..13eef9da1 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -1,6 +1,7 @@
 #ifndef TENSOR_H
 #define TENSOR_H
 
+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <initializer_list>
@@ -221,6 +222,113 @@ public:
         std::array<std::size_t, rank> coords_;
     };
 
+    // Multi-dimensional iterator for dynamic-rank tensors
+    template <typename Tp, typename V>
+    class dynamic_multidim_iterator {
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type = V;
+        using pointer = V*;
+        using reference = V&;
+        using iterator_category = std::forward_iterator_tag;
+
+        dynamic_multidim_iterator(Tp tensor, bool is_end = false)
+            : tensor_(tensor)
+        {
+            const auto& shape = tensor_->GetLayout().shape();
+            coords_.resize(shape.size(), 0);
+            if (is_end && !coords_.empty()) {
+                coords_[0] = shape[0];
+            }
+        }
+
+        bool operator==(const dynamic_multidim_iterator& other) const
+        {
+            return tensor_ == other.tensor_ && coords_ == other.coords_;
+        }
+
+        bool operator!=(const dynamic_multidim_iterator& other) const
+        {
+            return !(*this == other);
+        }
+
+        V& operator*() const { return accessElement(); }
+
+        V* operator->() const { return &(**this); }
+
+        dynamic_multidim_iterator& operator++()
+        {
+            incrementCoords();
+            return *this;
+        }
+
+        dynamic_multidim_iterator operator++(int)
+        {
+            dynamic_multidim_iterator result = *this;
+            ++(*this);
+            return result;
+        }
+
+    private:
+        V& accessElement() const { return accessElementImpl(coords_, 0); }
+
+        template <typename Coord>
+        V& accessElementImpl(const std::vector<Coord>& coords,
+                             std::size_t idx) const
+        {
+            if (idx == coords.size() - 1) {
+                return (*tensor_)(coords[idx]);
+            }
+            if (idx == coords.size() - 2) {
+                return (*tensor_)(coords[idx], coords[idx + 1]);
+            }
+            if (idx == coords.size() - 3) {
+                return (*tensor_)(coords[idx], coords[idx + 1],
+                                  coords[idx + 2]);
+            }
+            if (idx == coords.size() - 4) {
+                return (*tensor_)(coords[idx], coords[idx + 1],
+                                  coords[idx + 2], coords[idx + 3]);
+            }
+            if (idx == coords.size() - 5) {
+                return (*tensor_)(coords[idx], coords[idx + 1],
+                                  coords[idx + 2], coords[idx + 3],
+                                  coords[idx + 4]);
+            }
+            if (idx == coords.size() - 6) {
+                return (*tensor_)(coords[idx], coords[idx + 1],
+                                  coords[idx + 2], coords[idx + 3],
+                                  coords[idx + 4], coords[idx + 5]);
+            }
+            throw std::runtime_error(
+                "Tensor rank > 6 not supported for iteration");
+        }
+
+        void incrementCoords()
+        {
+            const auto& shape = tensor_->GetLayout().shape();
+
+            for (std::size_t dim = coords_.size(); dim > 0; --dim) {
+                std::size_t idx = dim - 1;
+                ++coords_[idx];
+
+                if (coords_[idx] < shape[idx]) {
+                    return;
+                } else {
+                    coords_[idx] = 0;
+                }
+            }
+
+            std::fill(coords_.begin(), coords_.end(), 0);
+            if (!coords_.empty()) {
+                coords_[0] = shape[0];
+            }
+        }
+
+        Tp tensor_;
+        std::vector<std::size_t> coords_;
+    };
+
     // For 1D tensors
     template <typename U = LayoutType,
               std::enable_if_t<U::shape_type::rank == 1, int> = 0>
@@ -281,6 +389,38 @@ public:
         return multidim_iterator<const Tensor*, const T>{this, true};
     }
 
+    // For multi-dimensional dynamic-rank tensors
+    template <
+        typename U = LayoutType,
+        std::enable_if_t<U::shape_type::rank == dynamicExtent, int> = 0>
+    auto begin()
+    {
+        return dynamic_multidim_iterator<Tensor*, T>{this, false};
+    }
+    template <
+        typename U = LayoutType,
+        std::enable_if_t<U::shape_type::rank == dynamicExtent, int> = 0>
+    auto begin() const
+    {
+        return dynamic_multidim_iterator<const Tensor*, const T>{this,
+                                                                 false};
+    }
+    template <
+        typename U = LayoutType,
+        std::enable_if_t<U::shape_type::rank == dynamicExtent, int> = 0>
+    auto end()
+    {
+        return dynamic_multidim_iterator<Tensor*, T>{this, true};
+    }
+    template <
+        typename U = LayoutType,
+        std::enable_if_t<U::shape_type::rank == dynamicExtent, int> = 0>
+    auto end() const
+    {
+        return dynamic_multidim_iterator<const Tensor*, const T>{this,
+                                                                 true};
+    }
+
     auto Slice(std::size_t dim, IndexType value = 0)
     {
         if constexpr (LayoutType::shape_type::rank == dynamicExtent) {
@@ -365,7 +505,7 @@ public:
     static constexpr std::size_t remainingRank = tensorRank - NumSliceDims;
 
     SlicedView(TensorType& tensor,
-                   std::array<std::size_t, NumSliceDims> sliceDims)
+               std::array<std::size_t, NumSliceDims> sliceDims)
         : tensor_(tensor), sliceDims_(sliceDims)
     {
     }
-- 
Gitee


From f6ff885e9b406acd2c59bf8bdba5bc8619c3e57e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 21 Oct 2025 14:34:54 +0800
Subject: [PATCH 045/116] Allow variable-rank tensor to be assigned by other
 tensors

---
 best_practices/expression_template/layout.h   | 17 ++++++++++
 best_practices/expression_template/tensor.h   | 33 +++++++++++++++++++
 .../expression_template/tensor_test.cpp       |  6 ++++
 3 files changed, 56 insertions(+)

diff --git a/best_practices/expression_template/layout.h b/best_practices/expression_template/layout.h
index ab2e0fa53..04b12346a 100644
--- a/best_practices/expression_template/layout.h
+++ b/best_practices/expression_template/layout.h
@@ -1,6 +1,7 @@
 #ifndef LAYOUT_H
 #define LAYOUT_H
 
+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <functional>
@@ -63,6 +64,14 @@ public:
     {
     }
 
+    template <typename U, std::size_t N>
+    VariableRankExtents& operator=(const FixedRankExtents<U, N>& extents)
+    {
+        data_.resize(N);
+        std::copy_n(extents.begin(), N, data_.begin());
+        return *this;
+    }
+
     T operator[](std::size_t i) const { return data_[i]; }
     T& operator[](std::size_t i) { return data_[i]; }
 
@@ -109,6 +118,14 @@ public:
     {
     }
 
+    template <typename S, typename St>
+    constexpr Layout& operator=(const Layout<S, St>& other)
+    {
+        shape_ = other.shape();
+        stride_ = other.stride();
+        return *this;
+    }
+
     constexpr Shape& shape() { return shape_; }
     constexpr const Shape& shape() const { return shape_; }
     constexpr Stride& stride() { return stride_; }
diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index 13eef9da1..f79f5ce66 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -41,8 +41,18 @@ public:
         SetSize(init.size());
         std::copy(init.begin(), init.end(), ptr_);
     }
+    explicit Tensor(std::size_t size) { SetSize(size); }
     explicit Tensor(const std::vector<T>& src) { SetSize(src.size()); }
 
+    template <typename L2>
+    Tensor& operator=(const Tensor<T, L2>& other)
+    {
+        ptr_ = other.ptr_;
+        len_ = other.len_;
+        layout_ = other.layout_;
+        return *this;
+    }
+
     T& operator[](std::size_t pos) { return ptr_[pos]; }
     const T& operator[](std::size_t pos) const { return ptr_[pos]; }
 
@@ -421,6 +431,8 @@ public:
                                                                  true};
     }
 
+    std::size_t size() const { return len_; }
+
     auto Slice(std::size_t dim, IndexType value = 0)
     {
         if constexpr (LayoutType::shape_type::rank == dynamicExtent) {
@@ -465,6 +477,11 @@ public:
         std::copy(src.begin(), src.end(), ptr_);
     }
     template <typename L2>
+    void CopyIn(const Tensor<T, L2>& src, std::size_t pos, std::size_t len)
+    {
+        std::copy_n(&src[pos], len, ptr_);
+    }
+    template <typename L2>
     void CopyOut(Tensor<T, L2>& dst)
     {
         if (dst.GetSize() < len_) {
@@ -472,6 +489,11 @@ public:
         }
         std::copy_n(ptr_, len_, dst.begin());
     }
+    template <typename L2>
+    void CopyOut(Tensor<T, L2>& dst, std::size_t pos, std::size_t len)
+    {
+        std::copy_n(ptr_, len, &dst[pos]);
+    }
 
     void CopyIn(const std::vector<T>& src)
     {
@@ -480,6 +502,10 @@ public:
         }
         std::copy(src.begin(), src.end(), ptr_);
     }
+    void CopyIn(const std::vector<T>& src, std::size_t pos, std::size_t len)
+    {
+        std::copy_n(&src[pos], len, ptr_);
+    }
     void CopyOut(std::vector<T>& dst)
     {
         if (dst.size() < len_) {
@@ -487,8 +513,15 @@ public:
         }
         std::copy_n(ptr_, len_, dst.begin());
     }
+    void CopyOut(std::vector<T>& dst, std::size_t pos, std::size_t len)
+    {
+        std::copy_n(ptr_, len, &dst[pos]);
+    }
 
 private:
+    template <typename T2, typename L2>
+    friend class Tensor;
+
     T* ptr_{};
     std::size_t len_{};
     LayoutType layout_;
diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
index cf9e8d1a7..0f833b671 100644
--- a/best_practices/expression_template/tensor_test.cpp
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -33,6 +33,12 @@ int main()
               std::ostream_iterator<float>(std::cout, " "));
     std::cout << '\n';
 
+    Tensor<float> tensor2;
+    tensor2 = tensor;
+    std::copy(tensor2.begin(), tensor2.end(),
+              std::ostream_iterator<float>(std::cout, " "));
+    std::cout << '\n';
+
     tensor.Clear();
     // Neither tensor nor slice can be accessed from now on
 }
-- 
Gitee


From 53db6b1f00db4c82540e0cf7064723ca55d845dd Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 21 Oct 2025 15:05:37 +0800
Subject: [PATCH 046/116] Add block emulation

---
 .../expr_template_demo.cpp                    | 273 +++++++++++++++++-
 1 file changed, 272 insertions(+), 1 deletion(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index eb7561a09..8e9658e1c 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <cstddef>
 #include <iostream>
 #include <stdexcept>
@@ -1159,7 +1160,7 @@ constexpr auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
 
 template <typename Params, std::size_t Index, typename ParamTup,
           typename ArgTup>
-constexpr auto ConvertOneArg(ParamTup& params, ArgTup& args)
+constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
 {
     constexpr auto pos =
         Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
@@ -1322,7 +1323,11 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
 
     // tuple of values
     auto params = PrepareParams<Params>(argTuple);
+
+    // tuple of references
     auto convertedArgs = ConvertArgs<Params>(params, argTuple);
+
+    // tuple of values
     using LocalVars = LocalVars_t<Expr>;
     auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
 
@@ -1348,6 +1353,267 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
 
 } // namespace Emulation
 
+namespace BlockEmulation {
+
+using namespace DemoEval;
+
+namespace Detail {
+
+template <typename ParamType, typename... Arg>
+constexpr auto ConstructParam(Arg... arg)
+{
+    // decay_t is very important here.  If ParamType::Type were a
+    // reference type and decaying did not happen, the expression below
+    // would become a reinterpret_cast: disasters would follow then.
+    return typename std::decay_t<typename ParamType::Type>(arg...);
+}
+
+template <typename Params, std::size_t... Ints, typename... Arg>
+constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
+{
+    return std::make_tuple(
+        ConstructParam<
+            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
+            arg...)...);
+}
+
+template <typename Params, std::size_t Index, typename ParamTup,
+          typename ArgTup>
+constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
+{
+    constexpr auto pos =
+        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
+    if constexpr (pos < Util::TMP::Size_v<Params>) {
+        return std::get<pos>(params);
+    } else {
+        return std::get<Index>(args);
+    }
+}
+
+template <typename Params, typename ParamTup, typename ArgTup,
+          std::size_t... Ints>
+constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+                     std::index_sequence<Ints...>)
+{
+    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
+}
+
+template <typename Params, std::size_t Index, ParamUsage... usages,
+          typename ParamTup>
+constexpr auto GetOneParam(ParamTup& params)
+{
+    using Param = Util::TMP::Get_t<Params, Index>;
+    if constexpr (((Param::usage == usages) || ...)) {
+        return std::forward_as_tuple(std::get<Index>(params));
+    } else {
+        return std::tuple<>{};
+    }
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetInParamsImpl(ParamTup& params,
+                               std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetOutParamsImpl(ParamTup& params,
+                                std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename InParams, std::size_t Index, typename T, typename ArgTup>
+void CopyInOneParam(T& param, ArgTup& args, std::size_t pos, std::size_t len)
+{
+    using Param = Util::TMP::Get_t<InParams, Index>;
+    param.CopyIn(std::get<Param::number - 1>(args), pos, len);
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyInImpl(InParamTup& inParams, ArgTup& args, std::size_t pos, std::size_t len,
+                std::index_sequence<Ints...>)
+{
+    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args, pos, len), ...);
+}
+
+template <typename OutParams, std::size_t Index, typename T, typename ArgTup>
+void CopyOutOneParam(T& param, ArgTup& args, std::size_t pos, std::size_t len)
+{
+    using Param = Util::TMP::Get_t<OutParams, Index>;
+    param.CopyOut(std::get<Param::number - 1>(args), pos, len);
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyOutImpl(OutParamTup& outParams, ArgTup& args, std::size_t pos, std::size_t len,
+                 std::index_sequence<Ints...>)
+{
+    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args, pos, len), ...);
+}
+
+} // namespace Detail
+
+template <typename Params, typename... Arg>
+auto PrepareParams(Arg... arg)
+{
+    return Detail::PrepareParamsImpl<Params>(
+        std::make_index_sequence<Size_v<Params>>{}, arg...);
+}
+
+template <typename Params, typename ParamTup, typename ArgTup>
+auto ConvertArgs(ParamTup& params, ArgTup& args)
+{
+    return Detail::ConvertArgsImpl<Params>(
+        params, args,
+        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
+}
+
+template <typename LocalVars, typename ArgTup>
+auto PrepareLocalVars(ArgTup& args)
+{
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, args);
+    return localVars;
+}
+
+template <typename Params, typename ParamTup>
+auto GetInParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetInParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename Params, typename ParamTup>
+auto GetOutParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetOutParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup>
+void CopyIn(InParamTup& inParams, ArgTup& args, std::size_t pos, std::size_t len)
+{
+    constexpr auto size = Size_v<InParams>;
+    static_assert(Size_v<InParams> == std::tuple_size_v<InParamTup>);
+    Detail::CopyInImpl<InParams>(inParams, args, pos, len,
+                                 std::make_index_sequence<size>{});
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup>
+void CopyOut(OutParamTup& outParams, ArgTup& args, std::size_t pos, std::size_t len)
+{
+    constexpr auto size = Size_v<OutParams>;
+    static_assert(size == std::tuple_size_v<OutParamTup>);
+    Detail::CopyOutImpl<OutParams>(outParams, args, pos, len,
+                                   std::make_index_sequence<size>{});
+}
+
+constexpr std::size_t blockSize = 32;
+
+template <typename T>
+using BlockTensor =
+    DemoEval::Tensor<T, Layout<FixedRankExtents<std::size_t, 1>>>;
+
+template <typename T>
+using SimpleTensor = DemoEval::Tensor<T>;
+
+template <typename ExprMaker, typename... Args,
+          typename = std::enable_if_t<
+              std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(const ExprMaker& maker, Args&&... args)
+{
+    auto expr = maker.template Get<BlockTensor>();
+    using Expr = typename decltype(expr)::Type;
+    static_assert(
+        !Expr::hasData,
+        "This expression template is not supposed to contain data");
+
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+
+    using Params = Params_t<Expr>;
+    using InParams = InParams_t<Expr>;
+    using OutParams = OutParams_t<Expr>;
+
+    // tuple of values
+    auto params = PrepareParams<Params>(blockSize);
+
+    // tuple of references
+    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
+
+    // tuple of values
+    using LocalVars = LocalVars_t<Expr>;
+    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
+
+    // tuple of references
+    auto inParams = GetInParams<Params>(params);
+    auto outParams = GetOutParams<Params>(params);
+
+    static_assert(Util::TMP::Size_v<InParams> != 0);
+    const std::size_t len =
+        std::get<Util::TMP::Get_t<InParams, 0>::number>(argTuple).size();
+    const std::size_t lenWholeBlock = len / blockSize * blockSize;
+    std::size_t i = 0;
+    for (; i < lenWholeBlock; i += blockSize) {
+        CopyIn<InParams>(inParams, argTuple, i, blockSize);
+        Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
+        CopyOut<OutParams>(outParams, argTuple, i, blockSize);
+    }
+    if (i < len) {
+        std::size_t sizeTailBlock = len - i;
+        auto exprTailBlock = maker.template Get<SimpleTensor>();
+        using ExprTailBlock = typename decltype(exprTailBlock)::Type;
+        using ParamsTailBlock = Params_t<ExprTailBlock>;
+        using InParamsTailBlock = InParams_t<ExprTailBlock>;
+        using OutParamsTailBlock = OutParams_t<ExprTailBlock>;
+
+        auto paramsTailBlock = PrepareParams<ParamsTailBlock>();
+        paramsTailBlock = params;  // Reuse allocated Tensor storage
+
+        auto convertedArgsTailBlock =
+            ConvertArgs<ParamsTailBlock>(paramsTailBlock, argTuple);
+
+        using LocalVarsTailBlock = LocalVars_t<ExprTailBlock>;
+        auto localVarsTailBlock = GetLocalVarTuple<LocalVarsTailBlock>();
+        localVarsTailBlock = localVars;  // Reuse allocated Tensor storage
+
+        auto inParamsTailBlock =
+            GetInParams<ParamsTailBlock>(paramsTailBlock);
+        auto outParamsTailBlock =
+            GetOutParams<ParamsTailBlock>(paramsTailBlock);
+
+        CopyIn<InParamsTailBlock>(inParamsTailBlock, argTuple, i,
+                                  sizeTailBlock);
+        Evaluator<ExprTailBlock>{}(
+            exprTailBlock.data, convertedArgsTailBlock, localVarsTailBlock);
+        CopyOut<OutParamsTailBlock>(outParamsTailBlock, argTuple, i,
+                                    sizeTailBlock);
+    }
+
+    Util::ForEach(params, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+    Util::ForEach(localVars, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+}
+
+} // namespace BlockEmulation
+
 
 /* Test */
 
@@ -1458,4 +1724,9 @@ int main() // NOLINT(bugprone-exception-escape)
     Emulation::DoElementwise(MyAddOp<float>{}, v1, v2, v3, v4, v5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
+
+    std::fill(v5.begin(), v5.end(), 0.0F);
+    BlockEmulation::DoElementwise(MyAddOp<float>{}, v1, v2, v3, v4, v5);
+    std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
+              << '\n';
 }
-- 
Gitee


From 0080914612726ea9985df104e7be871cd45d1654 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 21 Oct 2025 15:15:01 +0800
Subject: [PATCH 047/116] Shorten names

---
 .../expr_template_demo.cpp                    | 50 ++++++++-----------
 1 file changed, 22 insertions(+), 28 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 8e9658e1c..f1b89dc2d 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1570,34 +1570,28 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
         CopyOut<OutParams>(outParams, argTuple, i, blockSize);
     }
     if (i < len) {
-        std::size_t sizeTailBlock = len - i;
-        auto exprTailBlock = maker.template Get<SimpleTensor>();
-        using ExprTailBlock = typename decltype(exprTailBlock)::Type;
-        using ParamsTailBlock = Params_t<ExprTailBlock>;
-        using InParamsTailBlock = InParams_t<ExprTailBlock>;
-        using OutParamsTailBlock = OutParams_t<ExprTailBlock>;
-
-        auto paramsTailBlock = PrepareParams<ParamsTailBlock>();
-        paramsTailBlock = params;  // Reuse allocated Tensor storage
-
-        auto convertedArgsTailBlock =
-            ConvertArgs<ParamsTailBlock>(paramsTailBlock, argTuple);
-
-        using LocalVarsTailBlock = LocalVars_t<ExprTailBlock>;
-        auto localVarsTailBlock = GetLocalVarTuple<LocalVarsTailBlock>();
-        localVarsTailBlock = localVars;  // Reuse allocated Tensor storage
-
-        auto inParamsTailBlock =
-            GetInParams<ParamsTailBlock>(paramsTailBlock);
-        auto outParamsTailBlock =
-            GetOutParams<ParamsTailBlock>(paramsTailBlock);
-
-        CopyIn<InParamsTailBlock>(inParamsTailBlock, argTuple, i,
-                                  sizeTailBlock);
-        Evaluator<ExprTailBlock>{}(
-            exprTailBlock.data, convertedArgsTailBlock, localVarsTailBlock);
-        CopyOut<OutParamsTailBlock>(outParamsTailBlock, argTuple, i,
-                                    sizeTailBlock);
+        std::size_t sizeTB = len - i;  // tail-block size
+        auto exprTB = maker.template Get<SimpleTensor>();
+        using ExprTB = typename decltype(exprTB)::Type;
+        using ParamsTB = Params_t<ExprTB>;
+        using InParamsTB = InParams_t<ExprTB>;
+        using OutParamsTB = OutParams_t<ExprTB>;
+
+        auto paramsTB = PrepareParams<ParamsTB>();
+        paramsTB = params;  // Reuse allocated Tensor storage
+
+        auto convertedArgsTB = ConvertArgs<ParamsTB>(paramsTB, argTuple);
+
+        using LocalVarsTB = LocalVars_t<ExprTB>;
+        auto localVarsTB = GetLocalVarTuple<LocalVarsTB>();
+        localVarsTB = localVars;  // Reuse allocated Tensor storage
+
+        auto inParamsTB = GetInParams<ParamsTB>(paramsTB);
+        auto outParamsTB = GetOutParams<ParamsTB>(paramsTB);
+
+        CopyIn<InParamsTB>(inParamsTB, argTuple, i, sizeTB);
+        Evaluator<ExprTB>{}(exprTB.data, convertedArgsTB, localVarsTB);
+        CopyOut<OutParamsTB>(outParamsTB, argTuple, i, sizeTB);
     }
 
     Util::ForEach(params, [](auto& arg) {
-- 
Gitee


From 8025104f842f7dd76511fe5d71081afb4fb1dde1 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 09:46:24 +0800
Subject: [PATCH 048/116] Add CompressedData and UnaryOp

---
 .../expr_template_demo.cpp                    | 148 +++++++++++++++---
 1 file changed, 130 insertions(+), 18 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index f1b89dc2d..89a40c680 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -55,6 +55,45 @@ void ForEach(Tuple&& tuple, Func&& func)
 
 namespace Detail {
 
+// Storage implementations for different compression scenarios
+template <typename T, bool Compress>
+struct CompressedDataStorage;
+
+// Case 1: Not compressed
+template <typename T>
+struct CompressedDataStorage<T, false> {
+    template <typename U,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
+    explicit CompressedDataStorage(U&& u) : data_(std::forward<U>(u))
+    {
+    }
+
+    CompressedDataStorage() = default;
+
+    T& Data() { return data_; }
+    const T& Data() const { return data_; }
+
+private:
+    T data_;
+};
+
+// Case 2: Compressed
+template <typename T>
+struct CompressedDataStorage<T, true> : private T {
+    template <typename U,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
+    explicit CompressedDataStorage(U&& u) : T(std::forward<U>(u))
+    {
+    }
+
+    CompressedDataStorage() = default;
+
+    T& Data() { return static_cast<T&>(*this); }
+    const T& Data() const { return static_cast<const T&>(*this); }
+};
+
 // Storage implementations for different compression scenarios
 template <typename T1, typename T2, bool CompressFirst, bool CompressSecond>
 struct CompressedPairStorage;
@@ -62,31 +101,30 @@ struct CompressedPairStorage;
 // Case 1: Neither can be compressed
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, false, false> {
-    T1 first;
-    T2 second;
-
     template <typename U1, typename U2>
     CompressedPairStorage(U1&& f, U2&& s)
-        : first(std::forward<U1>(f)), second(std::forward<U2>(s))
+        : first_(std::forward<U1>(f)), second_(std::forward<U2>(s))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T1& First() { return first; }
-    const T1& First() const { return first; }
-    T2& Second() { return second; }
-    const T2& Second() const { return second; }
+    T1& First() { return first_; }
+    const T1& First() const { return first_; }
+    T2& Second() { return second_; }
+    const T2& Second() const { return second_; }
+
+private:
+    T1 first_;
+    T2 second_;
 };
 
 // Case 2: Only first can be compressed
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, true, false> : private T1 {
-    T2 second;
-
     template <typename U1, typename U2>
     CompressedPairStorage(U1&& f, U2&& s)
-        : T1(std::forward<U1>(f)), second(std::forward<U2>(s))
+        : T1(std::forward<U1>(f)), second_(std::forward<U2>(s))
     {
     }
 
@@ -94,27 +132,31 @@ struct CompressedPairStorage<T1, T2, true, false> : private T1 {
 
     T1& First() { return static_cast<T1&>(*this); }
     const T1& First() const { return static_cast<const T1&>(*this); }
-    T2& Second() { return second; }
-    const T2& Second() const { return second; }
+    T2& Second() { return second_; }
+    const T2& Second() const { return second_; }
+
+private:
+    T2 second_;
 };
 
 // Case 3: Only second can be compressed
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, false, true> : private T2 {
-    T1 first;
-
     template <typename U1, typename U2>
     CompressedPairStorage(U1&& f, U2&& s)
-        : T2(std::forward<U2>(s)), first(std::forward<U1>(f))
+        : T2(std::forward<U2>(s)), first_(std::forward<U1>(f))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T1& First() { return first; }
-    const T1& First() const { return first; }
+    T1& First() { return first_; }
+    const T1& First() const { return first_; }
     T2& Second() { return static_cast<T2&>(*this); }
     const T2& Second() const { return static_cast<const T2&>(*this); }
+
+private:
+    T1 first_;
 };
 
 // Case 4: Both can be compressed, different types
@@ -152,6 +194,58 @@ struct CompressedPairStorage<T, T, true, true> : private T {
 
 } // namespace Detail
 
+template <typename T>
+class CompressedData : private Detail::CompressedDataStorage<
+                           T, std::is_empty_v<T> && !std::is_final_v<T>> {
+    using Storage = Detail::CompressedDataStorage<
+        T, std::is_empty_v<T> && !std::is_final_v<T>>;
+
+public:
+    using Type = T;
+
+    // Default constructor
+    CompressedData() = default;
+
+    // Perfect forwarding constructor
+    template <typename U,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<U>, CompressedData>>>
+    explicit CompressedData(U&& u) : Storage(std::forward<U>(u))
+    {
+    }
+
+    // Accessors for data
+    T& Data() { return Storage::Data(); }
+    const T& Data() const { return Storage::Data(); }
+
+    // Swap
+    void swap(CompressedData& other) noexcept
+    {
+        using std::swap;
+        swap(Data(), other.Data());
+    }
+};
+
+// Swap function
+template <typename T>
+void swap(CompressedData<T>& lhs, CompressedData<T>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+// Equality comparison operators
+template <typename T>
+bool operator==(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
+{
+    return lhs.Data() == rhs.Data();
+}
+
+template <typename T>
+bool operator!=(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
+{
+    return !(lhs == rhs);
+}
+
 template <typename T1, typename T2>
 class CompressedPair
     : private Detail::CompressedPairStorage<
@@ -537,6 +631,24 @@ struct CheckVarNum {
     };
 };
 
+template <typename T>
+struct UnaryOp : private Util::CompressedData<T> {
+private:
+    using Storage = Util::CompressedData<T>;
+
+public:
+    static_assert(!std::is_rvalue_reference_v<T>,
+                  "Rvalue references cannot be stored");
+    static constexpr bool hasData = HasDataTrait<T>::value;
+    using IsUnaryOp = void;
+    using DataType = T;
+
+    UnaryOp() = default;
+    constexpr UnaryOp(T t) : Storage(t) {}
+
+    constexpr const T& GetData() const { return Storage::Data(); }
+};
+
 template <typename T, typename U>
 struct BinaryOp : private Util::CompressedPair<T, U> {
 private:
-- 
Gitee


From c6e676bfc5e773c09e9ffa848eee47fc68f4786e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 09:52:11 +0800
Subject: [PATCH 049/116] Minor adjustment for consistency

---
 best_practices/expression_template/expr_template_demo.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 89a40c680..cefe63b15 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -252,7 +252,6 @@ class CompressedPair
           T1, T2,
           std::is_empty_v<T1> && !std::is_final_v<T1>,
           std::is_empty_v<T2> && !std::is_final_v<T2>> {
-private:
     using Storage = Detail::CompressedPairStorage<
         T1, T2,
         std::is_empty_v<T1> && !std::is_final_v<T1>,
-- 
Gitee


From 5052d82ac64c329fb410c8c191ac09d6abbbd0a6 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 10:03:26 +0800
Subject: [PATCH 050/116] Rename CopyIn/CopyOut ops to CopyInData/CopyOutData

---
 .../expr_template_demo.cpp                    | 34 ++++++++++---------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index cefe63b15..38c715efd 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -824,32 +824,34 @@ template <typename T, typename U>
 }
 
 template <typename T, typename U>
-struct OpCopyIn : BinaryOp<T, U> {
-    OpCopyIn() = default;
-    constexpr OpCopyIn(T t, U u) : BinaryOp<T, U>(t, u) {}
+struct OpCopyInData : BinaryOp<T, U> {
+    OpCopyInData() = default;
+    constexpr OpCopyInData(T t, U u) : BinaryOp<T, U>(t, u) {}
 };
 
 template <typename T, typename U>
-struct OpCopyOut : BinaryOp<T, U> {
-    OpCopyOut() = default;
-    constexpr OpCopyOut(T t, U u) : BinaryOp<T, U>(t, u) {}
+struct OpCopyOutData : BinaryOp<T, U> {
+    OpCopyOutData() = default;
+    constexpr OpCopyOutData(T t, U u) : BinaryOp<T, U>(t, u) {}
 };
 
 template <typename T, typename U>
-[[nodiscard]] constexpr auto CopyIn(Expression<T> dst, Expression<U> src)
+[[nodiscard]] constexpr auto CopyInData(Expression<T> dst,
+                                        Expression<U> src)
 {
     static_assert(IsLocalVar_v<T>,
                   "Only a LocalVar can be the destination of CopyIn");
-    return Expression<OpCopyIn<T, U>>{{dst.data, src.data}};
+    return Expression<OpCopyInData<T, U>>{{dst.data, src.data}};
 }
 
 template <typename T, typename U>
-[[nodiscard]] constexpr auto CopyOut(Expression<T> src, Expression<U> dst)
+[[nodiscard]] constexpr auto CopyOutData(Expression<T> src,
+                                         Expression<U> dst)
 {
     static_assert(
         IsParam_v<U> || std::is_lvalue_reference_v<U>,
         "Only a Param or reference can be the destination of CopyOut");
-    return Expression<OpCopyOut<T, U>>{{src.data, dst.data}};
+    return Expression<OpCopyOutData<T, U>>{{src.data, dst.data}};
 }
 
 // Base class to express that a class is a maker of calculation expression template
@@ -1212,11 +1214,11 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
 
 // Partial specialization for CopyIn(E_dst, E_src)
 template <typename T, typename U>
-struct Evaluator<OpCopyIn<T, U>> {
+struct Evaluator<OpCopyInData<T, U>> {
     using Type = void;
 
     template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpCopyIn<T, U>& op,
+    void operator()(const OpCopyInData<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -1228,11 +1230,11 @@ struct Evaluator<OpCopyIn<T, U>> {
 
 // Partial specialization for CopyOut(E_src, E_dst)
 template <typename T, typename U>
-struct Evaluator<OpCopyOut<T, U>> {
+struct Evaluator<OpCopyOutData<T, U>> {
     using Type = void;
 
     template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpCopyOut<T, U>& op,
+    void operator()(const OpCopyOutData<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -1794,8 +1796,8 @@ int main() // NOLINT(bugprone-exception-escape)
     auto srcParam = DefineParam<1, Tensor<float>>();
     auto dstParam = DefineParam<2, Tensor<float>, ParamUsage::out>();
     auto localVar = DefineLocalVarLike<1>(srcParam);
-    auto result7 = (CopyIn(localVar, srcParam),
-                    CopyOut(localVar, dstParam));
+    auto result7 = (CopyInData(localVar, srcParam),
+                    CopyOutData(localVar, dstParam));
     //TYPE_DISPLAY(result7);
     Tensor<float> srcTensor;
     srcTensor.SetSize(5);
-- 
Gitee


From 8a3eb09a9abb653665569eed4d665caef018279c Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 11:18:35 +0800
Subject: [PATCH 051/116] Test on 3-D tensor data

---
 .../expression_template/tensor_test.cpp       | 23 ++++++++++++-------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
index 0f833b671..faa2daeeb 100644
--- a/best_practices/expression_template/tensor_test.cpp
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -9,26 +9,33 @@ int main()
 {
     using namespace DemoEval;
 
-    Tensor<float, Layout<FixedRankExtents<std::size_t, 2>>> tensor{
-        1, 2, 3, 4, 5, 6};
-    tensor.SetLayout(make_layout(2, 3));  // row-major order now
+    Tensor<float, Layout<FixedRankExtents<std::size_t, 3>>> tensor{
+        1, 2, 3, 4, 5, 6, 11, 12, 13, 14, 15, 16};
+    tensor.SetLayout(make_layout(2, 2, 3));  // row-major order now
     // Content is
     //   1 2 3
     //   4 5 6
+    //
+    //   11 12 13
+    //   14 15 16
     for (int i = 0; i < 2; ++i) {
-        for (int j = 0; j < 3; ++j) {
-            std::cout << tensor(i, j) << ' ';
+        for (int j = 0; j < 2; ++j) {
+            for (int k = 0; k < 3; ++k) {
+                std::cout << tensor(i, j, k) << ' ';
+            }
+            std::cout << '\n';
         }
-        std::cout << '\n';
     }
     std::cout << '\n';
 
+    // Iterate over all data
     std::copy(tensor.begin(), tensor.end(),
               std::ostream_iterator<float>(std::cout, " "));
     std::cout << '\n';
 
-    auto slice = tensor.Slice(0, 1);  // row (0th dimension) 1: {4, 5, 6}
-    slice(2) = 7;
+    auto slice = tensor.Slice(1, 1);
+    // {{4, 5, 6}, {14, 15, 16}}
+    slice(0, 2) = 7;
     std::copy(slice.begin(), slice.end(),
               std::ostream_iterator<float>(std::cout, " "));
     std::cout << '\n';
-- 
Gitee


From 34b2c947c4a3c23ab9bb300806b8a06d6605946b Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 15:54:13 +0800
Subject: [PATCH 052/116] Support serial CopyIn/CopyOut with GlobalTensor

---
 .../expr_template_demo.cpp                    | 78 +++++++++++++------
 best_practices/expression_template/tensor.h   | 39 ++++++++++
 .../expression_template/tensor_test.cpp       | 34 +++++++-
 3 files changed, 125 insertions(+), 26 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 38c715efd..f6cd2dd22 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -9,6 +9,13 @@
 #include "layout.h"
 #include "tensor.h"
 
+template <typename T>
+struct type_displayer;
+
+#define CONCAT(x, y) x ## y
+#define PASTE(x, y) CONCAT(x, y)
+#define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
+
 
 /* Utilities */
 
@@ -1542,33 +1549,56 @@ constexpr auto GetOutParamsImpl(ParamTup& params,
 }
 
 template <typename InParams, std::size_t Index, typename T, typename ArgTup>
-void CopyInOneParam(T& param, ArgTup& args, std::size_t pos, std::size_t len)
+void CopyInOneParam(T& param, ArgTup& args, std::size_t len)
 {
     using Param = Util::TMP::Get_t<InParams, Index>;
-    param.CopyIn(std::get<Param::number - 1>(args), pos, len);
+    if constexpr (Util::IsSpecializationOf_v<
+                      Tensor, std::decay_t<typename Param::Type>>) {
+        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
+        if constexpr (Util::IsSpecializationOf_v<
+                          GlobalTensor, std::decay_t<SourceType>>) {
+            std::get<Param::number - 1>(args).CopyTo(param, len);
+        } else {
+            static_assert(Util::AlwaysFalse_v<T>,
+                          "I do not know how to copy in on this type");
+        }
+    }
 }
 
 template <typename InParams, typename InParamTup, typename ArgTup,
           std::size_t... Ints>
-void CopyInImpl(InParamTup& inParams, ArgTup& args, std::size_t pos, std::size_t len,
+void CopyInImpl(InParamTup& inParams, ArgTup& args, std::size_t len,
                 std::index_sequence<Ints...>)
 {
-    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args, pos, len), ...);
+    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args, len),
+     ...);
 }
 
-template <typename OutParams, std::size_t Index, typename T, typename ArgTup>
-void CopyOutOneParam(T& param, ArgTup& args, std::size_t pos, std::size_t len)
+template <typename OutParams, std::size_t Index, typename T,
+          typename ArgTup>
+void CopyOutOneParam(T& param, ArgTup& args, std::size_t len)
 {
     using Param = Util::TMP::Get_t<OutParams, Index>;
-    param.CopyOut(std::get<Param::number - 1>(args), pos, len);
+    if constexpr (Util::IsSpecializationOf_v<
+                      Tensor, std::decay_t<typename Param::Type>>) {
+        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
+        if constexpr (Util::IsSpecializationOf_v<
+                          GlobalTensor, std::decay_t<SourceType>>) {
+            std::get<Param::number - 1>(args).CopyFrom(param, len);
+        } else {
+            static_assert(Util::AlwaysFalse_v<T>,
+                          "I do not know how to copy out on this type");
+        }
+    }
 }
 
 template <typename OutParams, typename OutParamTup, typename ArgTup,
           std::size_t... Ints>
-void CopyOutImpl(OutParamTup& outParams, ArgTup& args, std::size_t pos, std::size_t len,
+void CopyOutImpl(OutParamTup& outParams, ArgTup& args, std::size_t len,
                  std::index_sequence<Ints...>)
 {
-    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args, pos, len), ...);
+    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args, len),
+     ...);
 }
 
 } // namespace Detail
@@ -1615,20 +1645,20 @@ auto GetOutParams(ParamTup& params)
 }
 
 template <typename InParams, typename InParamTup, typename ArgTup>
-void CopyIn(InParamTup& inParams, ArgTup& args, std::size_t pos, std::size_t len)
+void CopyIn(InParamTup& inParams, ArgTup& args, std::size_t len)
 {
     constexpr auto size = Size_v<InParams>;
     static_assert(Size_v<InParams> == std::tuple_size_v<InParamTup>);
-    Detail::CopyInImpl<InParams>(inParams, args, pos, len,
+    Detail::CopyInImpl<InParams>(inParams, args, len,
                                  std::make_index_sequence<size>{});
 }
 
 template <typename OutParams, typename OutParamTup, typename ArgTup>
-void CopyOut(OutParamTup& outParams, ArgTup& args, std::size_t pos, std::size_t len)
+void CopyOut(OutParamTup& outParams, ArgTup& args, std::size_t len)
 {
     constexpr auto size = Size_v<OutParams>;
     static_assert(size == std::tuple_size_v<OutParamTup>);
-    Detail::CopyOutImpl<OutParams>(outParams, args, pos, len,
+    Detail::CopyOutImpl<OutParams>(outParams, args, len,
                                    std::make_index_sequence<size>{});
 }
 
@@ -1678,9 +1708,9 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     const std::size_t lenWholeBlock = len / blockSize * blockSize;
     std::size_t i = 0;
     for (; i < lenWholeBlock; i += blockSize) {
-        CopyIn<InParams>(inParams, argTuple, i, blockSize);
+        CopyIn<InParams>(inParams, argTuple, blockSize);
         Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
-        CopyOut<OutParams>(outParams, argTuple, i, blockSize);
+        CopyOut<OutParams>(outParams, argTuple, blockSize);
     }
     if (i < len) {
         std::size_t sizeTB = len - i;  // tail-block size
@@ -1702,9 +1732,9 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
         auto inParamsTB = GetInParams<ParamsTB>(paramsTB);
         auto outParamsTB = GetOutParams<ParamsTB>(paramsTB);
 
-        CopyIn<InParamsTB>(inParamsTB, argTuple, i, sizeTB);
+        CopyIn<InParamsTB>(inParamsTB, argTuple, sizeTB);
         Evaluator<ExprTB>{}(exprTB.data, convertedArgsTB, localVarsTB);
-        CopyOut<OutParamsTB>(outParamsTB, argTuple, i, sizeTB);
+        CopyOut<OutParamsTB>(outParamsTB, argTuple, sizeTB);
     }
 
     Util::ForEach(params, [](auto& arg) {
@@ -1724,13 +1754,6 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
 
 /* Test */
 
-template <typename T>
-struct type_displayer;
-
-#define CONCAT(x, y) x ## y
-#define PASTE(x, y) CONCAT(x, y)
-#define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
-
 template <typename T>
 struct MyAddOp : ExprTmpl::Maker {
     template <template <typename> class VectorType>
@@ -1833,7 +1856,12 @@ int main() // NOLINT(bugprone-exception-escape)
               << '\n';
 
     std::fill(v5.begin(), v5.end(), 0.0F);
-    BlockEmulation::DoElementwise(MyAddOp<float>{}, v1, v2, v3, v4, v5);
+    GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
+    GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
+    GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
+    GlobalTensor<float> t4(v4.data(), 300, make_layout(300));
+    GlobalTensor<float> t5(v5.data(), 300, make_layout(300));
+    BlockEmulation::DoElementwise(MyAddOp<float>{}, t1, t2, t3, t4, t5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
 }
diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index f79f5ce66..6240d344e 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -527,6 +527,45 @@ private:
     LayoutType layout_;
 };
 
+// Just a Tensor that remembers the copy position
+template <typename T, typename L = Layout<VariableRankExtents<std::size_t>>>
+class GlobalTensor : private Tensor<T, L> {
+    using Base = Tensor<T, L>;
+
+public:
+    GlobalTensor(const Tensor<T, L>& tensor)
+        : Base(tensor), it_(Base::begin())
+    {
+    }
+    GlobalTensor(T* ptr, std::size_t len, L layout)
+        : Base(ptr, len, layout), it_(Base::begin())
+    {
+    }
+
+    using Base::begin;
+    using Base::end;
+    using Base::size;
+
+    template <typename L2>
+    void CopyFrom(const Tensor<T, L2>& src, std::size_t count)
+    {
+        it_ = std::copy_n(src.begin(), count, it_);
+    }
+    template <typename L2>
+    void CopyTo(Tensor<T, L2>& dst, std::size_t count)
+    {
+        auto itOut = dst.begin();
+        for (std::size_t i = 0; i != count; ++i) {
+            *itOut = *it_;
+            ++itOut;
+            ++it_;
+        }
+    }
+
+private:
+    decltype(std::declval<Base&>().begin()) it_;
+};
+
 template <typename TensorType, std::size_t NumSliceDims>
 class SlicedView {
 public:
diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
index faa2daeeb..ad6f39a94 100644
--- a/best_practices/expression_template/tensor_test.cpp
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -46,6 +46,38 @@ int main()
               std::ostream_iterator<float>(std::cout, " "));
     std::cout << '\n';
 
+    Tensor<float> result(128);
+    result.SetLayout(make_layout(128));
+    std::fill(result.begin(), result.end(), 0.0F);
+    {
+        GlobalTensor<float> gt{result};
+        gt.CopyFrom(tensor2, 12);
+        gt.CopyFrom(tensor2, 12);
+    }
+    std::copy(result.begin(), result.end(),
+              std::ostream_iterator<float>(std::cout, " "));
+    std::cout << '\n';
+    std::fill(tensor2.begin(), tensor2.end(), 0.0F);
+    {
+        std::copy(tensor2.begin(), tensor2.end(),
+                  std::ostream_iterator<float>(std::cout, " "));
+        std::cout << '\n';
+        GlobalTensor<float> gt{result};
+        gt.CopyTo(tensor2, 12);
+        std::copy(tensor2.begin(), tensor2.end(),
+                  std::ostream_iterator<float>(std::cout, " "));
+        std::cout << '\n';
+        gt.CopyTo(tensor2, 12);
+        std::copy(tensor2.begin(), tensor2.end(),
+                  std::ostream_iterator<float>(std::cout, " "));
+        std::cout << '\n';
+        gt.CopyTo(tensor2, 12);
+        std::copy(tensor2.begin(), tensor2.end(),
+                  std::ostream_iterator<float>(std::cout, " "));
+        std::cout << '\n';
+    }
+
+    result.Clear();
     tensor.Clear();
-    // Neither tensor nor slice can be accessed from now on
+    // No tensor or slice can be accessed from now on
 }
-- 
Gitee


From c67d28ef17486045c23744e8d2178c8b0a157dd2 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 16:14:06 +0800
Subject: [PATCH 053/116] Add basic subtraction support

No AssignSubtract yet.
---
 .../expr_template_demo.cpp                    | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index f6cd2dd22..d733b1765 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -830,6 +830,30 @@ template <typename T, typename U>
     return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
 }
 
+template <typename T, typename U>
+struct OpSubtract : BinaryOp<T, U> {
+    OpSubtract() = default;
+    constexpr OpSubtract(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator-(Expression<T> lhs, Expression<U> rhs)
+{
+    return Expression<OpSubtract<T, U>>{{lhs.data, rhs.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator-(Expression<T> lhs, U&& rhs)
+{
+    return Expression<OpSubtract<T, U>>{{lhs.data, std::forward<U>(rhs)}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator-(T&& lhs, Expression<U> rhs)
+{
+    return Expression<OpSubtract<T, U>>{{std::forward<T>(lhs), rhs.data}};
+}
+
 template <typename T, typename U>
 struct OpCopyInData : BinaryOp<T, U> {
     OpCopyInData() = default;
@@ -1127,6 +1151,12 @@ auto Add(const T& src1, const U& src2)
     return src1 + src2;
 }
 
+template <typename T, typename U>
+auto Subtract(const T& src1, const U& src2)
+{
+    return src1 - src2;
+}
+
 template <typename T, typename U, typename V>
 void AddAssign(T& dst, const U& src1, const V& src2)
 {
@@ -1203,6 +1233,22 @@ struct Evaluator<OpAdd<T, U>> {
     }
 };
 
+// Partial specializtion for E_x - E_y
+template <typename T, typename U>
+struct Evaluator<OpSubtract<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpSubtract<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Subtract(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                        Evaluator<U>{}(op.GetRhs(), args, localVars));
+    }
+};
+
 // Partial specializtion for E_z = E_x + E_y
 template <typename T, typename U, typename V>
 struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
-- 
Gitee


From 12c3fd65964b298cf277ff184034a72a0ec82bb7 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 16:26:09 +0800
Subject: [PATCH 054/116] Move data definition from DemoEval to Demo

---
 best_practices/expression_template/expr_template_demo.cpp | 5 ++++-
 best_practices/expression_template/layout.h               | 4 ++--
 best_practices/expression_template/tensor.h               | 4 ++--
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index d733b1765..1c04d2ac6 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -899,6 +899,7 @@ class Maker {};
 
 namespace DemoEval {
 
+using Demo::Tensor;
 using Util::TMP::FindUnique_t;
 using Util::TMP::Size_v;
 
@@ -1468,7 +1469,7 @@ void CopyOut(OutParamTup& outParams, ArgTup& args)
 
 template <typename T>
 using SimpleTensor = DemoEval::Tensor<
-    T, DemoEval::Layout<DemoEval::FixedRankExtents<std::size_t, 1>>>;
+    T, Demo::Layout<Demo::FixedRankExtents<std::size_t, 1>>>;
 
 template <typename ExprMaker, typename... Args,
           typename = std::enable_if_t<
@@ -1521,6 +1522,7 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
 
 namespace BlockEmulation {
 
+using namespace Demo;
 using namespace DemoEval;
 
 namespace Detail {
@@ -1820,6 +1822,7 @@ struct MyAddOp : ExprTmpl::Maker {
 int main() // NOLINT(bugprone-exception-escape)
 {
     using namespace ExprTmpl;
+    using namespace Demo;
     using namespace DemoEval;
 
     auto _1 = DefineParam<1, int>();
diff --git a/best_practices/expression_template/layout.h b/best_practices/expression_template/layout.h
index 04b12346a..1289386c3 100644
--- a/best_practices/expression_template/layout.h
+++ b/best_practices/expression_template/layout.h
@@ -10,7 +10,7 @@
 #include <type_traits>
 #include <vector>
 
-namespace DemoEval {
+namespace Demo {
 
 inline constexpr auto dynamicExtent = std::size_t(-1);
 
@@ -250,6 +250,6 @@ auto make_layout(Args... args)
         FixedRankExtents<std::size_t, sizeof...(args)>{args...});
 }
 
-} // namespace DemoEval
+} // namespace Demo
 
 #endif // LAYOUT_H
diff --git a/best_practices/expression_template/tensor.h b/best_practices/expression_template/tensor.h
index 6240d344e..31fdac282 100644
--- a/best_practices/expression_template/tensor.h
+++ b/best_practices/expression_template/tensor.h
@@ -12,7 +12,7 @@
 #include <vector>
 #include "layout.h"
 
-namespace DemoEval {
+namespace Demo {
 
 template <typename T, typename L = Layout<VariableRankExtents<std::size_t>>>
 class Tensor {
@@ -690,6 +690,6 @@ auto MakeSlicedView(TensorType& tensor, std::array<std::size_t, N> dims)
     return SlicedView<TensorType, N>{tensor, dims};
 }
 
-} // namespace DemoEval
+} // namespace Demo
 
 #endif // TENSOR_H
-- 
Gitee


From 3e1a6d21a28fbddb86e73c6a64d9b90cabb16eee Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 17:20:16 +0800
Subject: [PATCH 055/116] Add Param CopyIn/CopyOut operators

No evaluation yet.
---
 .../expr_template_demo.cpp                    | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 1c04d2ac6..ea1dd6310 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -773,6 +773,38 @@ struct OutParams {
 template <typename T>
 using OutParams_t = typename OutParams<T>::Type;
 
+template <typename T>
+struct OpCopyInParam : UnaryOp<T> {
+    OpCopyInParam() = default;
+    constexpr OpCopyInParam(T t) : UnaryOp<T>(t) {}
+};
+
+template <typename T>
+[[nodiscard]] constexpr auto CopyIn(Expression<T> t)
+{
+    static_assert(IsParam_v<T>, "Only a Param supports CopyIn");
+    static_assert(
+        T::usage == ParamUsage::in || T::usage == ParamUsage::in_out,
+        "Param usage must be in or in_out");
+    return Expression<OpCopyInParam<T>>{{t.data}};
+}
+
+template <typename T>
+struct OpCopyOutParam : UnaryOp<T> {
+    OpCopyOutParam() = default;
+    constexpr OpCopyOutParam(T t) : UnaryOp<T>(t) {}
+};
+
+template <typename T>
+[[nodiscard]] constexpr auto CopyOut(Expression<T> t)
+{
+    static_assert(IsParam_v<T>, "Only a Param supports CopyOut");
+    static_assert(
+        T::usage == ParamUsage::out || T::usage == ParamUsage::in_out,
+        "Param usage must be out or in_out");
+    return Expression<OpCopyOutParam<T>>{{t.data}};
+}
+
 template <typename T, typename U>
 struct OpAssign : BinaryOp<T, U> {
     OpAssign() = default;
@@ -1892,6 +1924,13 @@ int main() // NOLINT(bugprone-exception-escape)
     srcTensor.Clear();
     dstTensor.Clear();
 
+    auto src1 = DefineParam<1, Tensor<float>>();
+    auto src2 = DefineParam<2, Tensor<float>>();
+    auto dest = DefineParam<3, Tensor<float>, ParamUsage::out>();
+    [[maybe_unused]] auto result8 =
+        (CopyIn(src1), CopyIn(src2), dest = src1 + src2, CopyOut(dest));
+    //TYPE_DISPLAY(result8);
+
     std::vector<float> v1(300, 1.0F);
     std::vector<float> v2(300, 2.0F);
     std::vector<float> v3(300, 3.0F);
-- 
Gitee


From f72e7b5deebec766b5543a4383443bb612e270f7 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 17:46:20 +0800
Subject: [PATCH 056/116] Separate demo into smaller files

---
 .../expression_template/block_emulation.h     |  295 +++
 .../expression_template/demo_eval.h           |  419 ++++
 .../expression_template/emulation.h           |  235 +++
 .../expr_template_demo.cpp                    | 1830 +----------------
 .../expression_template/expr_tmpl.h           |  430 ++++
 best_practices/expression_template/util.h     |  505 +++++
 6 files changed, 1889 insertions(+), 1825 deletions(-)
 create mode 100644 best_practices/expression_template/block_emulation.h
 create mode 100644 best_practices/expression_template/demo_eval.h
 create mode 100644 best_practices/expression_template/emulation.h
 create mode 100644 best_practices/expression_template/expr_tmpl.h
 create mode 100644 best_practices/expression_template/util.h

diff --git a/best_practices/expression_template/block_emulation.h b/best_practices/expression_template/block_emulation.h
new file mode 100644
index 000000000..98fc5f551
--- /dev/null
+++ b/best_practices/expression_template/block_emulation.h
@@ -0,0 +1,295 @@
+#ifndef BLOCK_EMULATION_H
+#define BLOCK_EMULATION_H
+
+/* Block Emulation */
+
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "demo_eval.h"
+#include "expr_tmpl.h"
+#include "layout.h"
+#include "tensor.h"
+#include "util.h"
+
+namespace BlockEmulation {
+
+using namespace Demo;
+using namespace DemoEval;
+
+namespace Detail {
+
+template <typename ParamType, typename... Arg>
+constexpr auto ConstructParam(Arg... arg)
+{
+    // decay_t is very important here.  If ParamType::Type were a
+    // reference type and decaying did not happen, the expression below
+    // would become a reinterpret_cast: disasters would follow then.
+    return typename std::decay_t<typename ParamType::Type>(arg...);
+}
+
+template <typename Params, std::size_t... Ints, typename... Arg>
+constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
+{
+    return std::make_tuple(
+        ConstructParam<
+            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
+            arg...)...);
+}
+
+template <typename Params, std::size_t Index, typename ParamTup,
+          typename ArgTup>
+constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
+{
+    constexpr auto pos =
+        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
+    if constexpr (pos < Util::TMP::Size_v<Params>) {
+        return std::get<pos>(params);
+    } else {
+        return std::get<Index>(args);
+    }
+}
+
+template <typename Params, typename ParamTup, typename ArgTup,
+          std::size_t... Ints>
+constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+                     std::index_sequence<Ints...>)
+{
+    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
+}
+
+template <typename Params, std::size_t Index, ParamUsage... usages,
+          typename ParamTup>
+constexpr auto GetOneParam(ParamTup& params)
+{
+    using Param = Util::TMP::Get_t<Params, Index>;
+    if constexpr (((Param::usage == usages) || ...)) {
+        return std::forward_as_tuple(std::get<Index>(params));
+    } else {
+        return std::tuple<>{};
+    }
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetInParamsImpl(ParamTup& params,
+                               std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetOutParamsImpl(ParamTup& params,
+                                std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename InParams, std::size_t Index, typename T, typename ArgTup>
+void CopyInOneParam(T& param, ArgTup& args, std::size_t len)
+{
+    using Param = Util::TMP::Get_t<InParams, Index>;
+    if constexpr (Util::IsSpecializationOf_v<
+                      Tensor, std::decay_t<typename Param::Type>>) {
+        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
+        if constexpr (Util::IsSpecializationOf_v<
+                          GlobalTensor, std::decay_t<SourceType>>) {
+            std::get<Param::number - 1>(args).CopyTo(param, len);
+        } else {
+            static_assert(Util::AlwaysFalse_v<T>,
+                          "I do not know how to copy in on this type");
+        }
+    }
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyInImpl(InParamTup& inParams, ArgTup& args, std::size_t len,
+                std::index_sequence<Ints...>)
+{
+    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args, len),
+     ...);
+}
+
+template <typename OutParams, std::size_t Index, typename T,
+          typename ArgTup>
+void CopyOutOneParam(T& param, ArgTup& args, std::size_t len)
+{
+    using Param = Util::TMP::Get_t<OutParams, Index>;
+    if constexpr (Util::IsSpecializationOf_v<
+                      Tensor, std::decay_t<typename Param::Type>>) {
+        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
+        if constexpr (Util::IsSpecializationOf_v<
+                          GlobalTensor, std::decay_t<SourceType>>) {
+            std::get<Param::number - 1>(args).CopyFrom(param, len);
+        } else {
+            static_assert(Util::AlwaysFalse_v<T>,
+                          "I do not know how to copy out on this type");
+        }
+    }
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyOutImpl(OutParamTup& outParams, ArgTup& args, std::size_t len,
+                 std::index_sequence<Ints...>)
+{
+    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args, len),
+     ...);
+}
+
+} // namespace Detail
+
+template <typename Params, typename... Arg>
+auto PrepareParams(Arg... arg)
+{
+    return Detail::PrepareParamsImpl<Params>(
+        std::make_index_sequence<Size_v<Params>>{}, arg...);
+}
+
+template <typename Params, typename ParamTup, typename ArgTup>
+auto ConvertArgs(ParamTup& params, ArgTup& args)
+{
+    return Detail::ConvertArgsImpl<Params>(
+        params, args,
+        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
+}
+
+template <typename LocalVars, typename ArgTup>
+auto PrepareLocalVars(ArgTup& args)
+{
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, args);
+    return localVars;
+}
+
+template <typename Params, typename ParamTup>
+auto GetInParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetInParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename Params, typename ParamTup>
+auto GetOutParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetOutParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup>
+void CopyIn(InParamTup& inParams, ArgTup& args, std::size_t len)
+{
+    constexpr auto size = Size_v<InParams>;
+    static_assert(Size_v<InParams> == std::tuple_size_v<InParamTup>);
+    Detail::CopyInImpl<InParams>(inParams, args, len,
+                                 std::make_index_sequence<size>{});
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup>
+void CopyOut(OutParamTup& outParams, ArgTup& args, std::size_t len)
+{
+    constexpr auto size = Size_v<OutParams>;
+    static_assert(size == std::tuple_size_v<OutParamTup>);
+    Detail::CopyOutImpl<OutParams>(outParams, args, len,
+                                   std::make_index_sequence<size>{});
+}
+
+constexpr std::size_t blockSize = 32;
+
+template <typename T>
+using BlockTensor =
+    DemoEval::Tensor<T, Layout<FixedRankExtents<std::size_t, 1>>>;
+
+template <typename T>
+using SimpleTensor = DemoEval::Tensor<T>;
+
+template <typename ExprMaker, typename... Args,
+          typename = std::enable_if_t<
+              std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(const ExprMaker& maker, Args&&... args)
+{
+    auto expr = maker.template Get<BlockTensor>();
+    using Expr = typename decltype(expr)::Type;
+    static_assert(
+        !Expr::hasData,
+        "This expression template is not supposed to contain data");
+
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+
+    using Params = Params_t<Expr>;
+    using InParams = InParams_t<Expr>;
+    using OutParams = OutParams_t<Expr>;
+
+    // tuple of values
+    auto params = PrepareParams<Params>(blockSize);
+
+    // tuple of references
+    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
+
+    // tuple of values
+    using LocalVars = LocalVars_t<Expr>;
+    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
+
+    // tuple of references
+    auto inParams = GetInParams<Params>(params);
+    auto outParams = GetOutParams<Params>(params);
+
+    static_assert(Util::TMP::Size_v<InParams> != 0);
+    const std::size_t len =
+        std::get<Util::TMP::Get_t<InParams, 0>::number>(argTuple).size();
+    const std::size_t lenWholeBlock = len / blockSize * blockSize;
+    std::size_t i = 0;
+    for (; i < lenWholeBlock; i += blockSize) {
+        CopyIn<InParams>(inParams, argTuple, blockSize);
+        Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
+        CopyOut<OutParams>(outParams, argTuple, blockSize);
+    }
+    if (i < len) {
+        std::size_t sizeTB = len - i;  // tail-block size
+        auto exprTB = maker.template Get<SimpleTensor>();
+        using ExprTB = typename decltype(exprTB)::Type;
+        using ParamsTB = Params_t<ExprTB>;
+        using InParamsTB = InParams_t<ExprTB>;
+        using OutParamsTB = OutParams_t<ExprTB>;
+
+        auto paramsTB = PrepareParams<ParamsTB>();
+        paramsTB = params;  // Reuse allocated Tensor storage
+
+        auto convertedArgsTB = ConvertArgs<ParamsTB>(paramsTB, argTuple);
+
+        using LocalVarsTB = LocalVars_t<ExprTB>;
+        auto localVarsTB = GetLocalVarTuple<LocalVarsTB>();
+        localVarsTB = localVars;  // Reuse allocated Tensor storage
+
+        auto inParamsTB = GetInParams<ParamsTB>(paramsTB);
+        auto outParamsTB = GetOutParams<ParamsTB>(paramsTB);
+
+        CopyIn<InParamsTB>(inParamsTB, argTuple, sizeTB);
+        Evaluator<ExprTB>{}(exprTB.data, convertedArgsTB, localVarsTB);
+        CopyOut<OutParamsTB>(outParamsTB, argTuple, sizeTB);
+    }
+
+    Util::ForEach(params, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+    Util::ForEach(localVars, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+}
+
+} // namespace BlockEmulation
+
+#endif // BLOCK_EMULATION_H
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
new file mode 100644
index 000000000..1d8dc5408
--- /dev/null
+++ b/best_practices/expression_template/demo_eval.h
@@ -0,0 +1,419 @@
+#ifndef DEMO_EVAL_H
+#define DEMO_EVAL_H
+
+/* Demo Evaluation */
+
+#include <cstddef>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "expr_tmpl.h"
+#include "tensor.h"
+#include "util.h"
+
+namespace DemoEval {
+
+using Demo::Tensor;
+using Util::TMP::FindUnique_t;
+using Util::TMP::Size_v;
+
+using namespace ExprTmpl;
+
+// Primary template
+template <typename T>
+struct Evaluator {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(const T& value,
+                              ArgTup& args,
+                              LocalVarTup& localVars) const
+    {
+        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
+            return value(args, localVars);
+        } else {
+            return value;
+        }
+    }
+};
+
+template <std::size_t N, typename T>
+constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
+{
+    using ResultType = typename Evaluator<T>::Type;
+    return Expression<LocalVar<N, ResultType>>{};
+}
+
+namespace Detail {
+
+template <typename Params, std::size_t... Ints>
+constexpr auto GetParamTupleImpl(std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              Params>::Type{}...);
+}
+
+template <typename LocalVars, std::size_t... Ints>
+constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              LocalVars>::Type{}...);
+}
+
+template <typename T>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename T, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<T, L>& src)
+{
+    dst.SetSize(src.GetSize());
+}
+
+template <typename L, typename T, typename ArgTup>
+void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
+{
+    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
+    if constexpr (!std::is_same_v<typename L::Like, void>) {
+        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
+    }
+}
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup,
+          std::size_t... Ints>
+void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
+                            std::index_sequence<Ints...>)
+{
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
+         std::get<Ints>(localVars), args),
+     ...);
+}
+
+} // namespace Detail
+
+template <typename Params>
+constexpr auto GetParamTuple()
+{
+    constexpr auto paramCount = Size_v<Params>;
+    return Detail::GetParamTupleImpl<Params>(
+        std::make_index_sequence<paramCount>{});
+};
+
+template <typename LocalVars>
+constexpr auto GetLocalVarTuple()
+{
+    constexpr auto localVarCount = Size_v<LocalVars>;
+    return Detail::GetLocalVarTupleImpl<LocalVars>(
+        std::make_index_sequence<localVarCount>{});
+};
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup>
+void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
+{
+    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
+        localVars, args,
+        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
+}
+
+template <typename T>
+class final_action {
+public:
+    explicit final_action(T action) : action_(std::move(action)) {}
+
+    final_action(final_action&& other) noexcept
+        : action_(std::move(other.action_)),
+          is_active_(std::exchange(other.is_active_, false))
+    {
+    }
+
+    final_action(const final_action&) = delete;
+    final_action& operator=(const final_action&) = delete;
+    final_action& operator=(final_action&&) = delete;
+
+    ~final_action()
+    {
+        if (is_active_) {
+            action_();
+        }
+    }
+
+    void dismiss() noexcept
+    {
+        is_active_ = false;
+    }
+
+private:
+    T action_;
+    bool is_active_{true};
+};
+
+template <typename T>
+auto finally(T&& action)
+{
+    return final_action<std::decay_t<T>>(std::forward<T>(action));
+}
+
+template <typename T, typename... Args>
+auto Evaluate(const Expression<T>& expr, Args&&... args)
+{
+    // Declare local variables so that we can always use xTup& in
+    // Evaluator<>::operator()
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+    using LocalVars = LocalVars_t<T>;
+    [[maybe_unused]] Params_t<T> dummy; // Force checking the params
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
+    auto cleanup = finally([&] {
+        Util::ForEach(localVars, [](auto& arg) {
+            if constexpr (Util::HasClear_v<decltype(arg)>) {
+                arg.Clear();
+            }
+        });
+    });
+    return Evaluator<T>{}(expr.data, argTuple, localVars);
+}
+
+// Treat Evaluator<Expression<T>> as Evaluator<T>
+template <typename T>
+struct Evaluator<Expression<T>> : Evaluator<T> {};
+
+// Partial specialization for LocalVar
+template <std::size_t N, typename T, typename L>
+struct Evaluator<LocalVar<N, T, L>> {
+    using Type = T&;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              ArgTup& /*args*/,
+                              LocalVarTup& localVars) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return std::get<N - 1>(localVars);
+    }
+};
+
+// Partial specialization for Param
+template <std::size_t N, typename T, ParamUsage U>
+struct Evaluator<Param<N, T, U>> {
+    using Type = T;
+
+    template <typename ArgTup, typename LocalVarTup>
+    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+                              ArgTup& args,
+                              LocalVarTup& /*localVars*/) const
+    {
+        static_assert(N > 0, "Param number starts from 1");
+        constexpr auto index = N - 1;
+        using NthType =
+            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
+        if constexpr (std::is_same_v<T, NthType> ||
+                      std::is_same_v<T&, NthType> ||
+                      std::is_same_v<T&&, NthType>) {
+            return std::get<index>(args);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(std::get<index>(args));
+        }
+    }
+};
+
+template <typename T, typename U>
+void Assign(T& dst, const U& src)
+{
+    dst = src;
+}
+
+// Partial specializtion for E_y = E_x
+template <typename T, typename U>
+struct Evaluator<OpAssign<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Assign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                      Evaluator<U>{}(op.GetRhs(), args, localVars));
+    }
+};
+
+// Partial specializtion for E_x, E_y
+template <typename T, typename U>
+struct Evaluator<OpAndThen<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAndThen<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        // operator, evaluates sequentially
+        return Evaluator<T>{}(op.GetLhs(), args, localVars),
+               Evaluator<U>{}(op.GetRhs(), args, localVars);
+    }
+};
+
+template <typename T, typename U>
+auto Add(const T& src1, const U& src2)
+{
+    return src1 + src2;
+}
+
+template <typename T, typename U>
+auto Subtract(const T& src1, const U& src2)
+{
+    return src1 - src2;
+}
+
+template <typename T, typename U, typename V>
+void AddAssign(T& dst, const U& src1, const V& src2)
+{
+    dst = src1 + src2;
+}
+
+template <typename T>
+void AddAssign(std::vector<T>& dst,
+               const std::vector<T>& src1,
+               const std::vector<T>& src2)
+{
+    if (src1.size() != src2.size()) {
+        throw std::logic_error("vector sizes do not match");
+    }
+    if (src1.size() != dst.size()) {
+        throw std::logic_error("Destination vector should be like source");
+    }
+    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+template <typename T, typename L>
+void AddAssign(Tensor<T, L>& dst,
+               const Tensor<T, L>& src1,
+               const Tensor<T, L>& src2)
+{
+    if (src1.GetSize() != src2.GetSize()) {
+        throw std::logic_error("Tensor sizes do not match");
+    }
+    if (src1.GetSize() != dst.GetSize()) {
+        throw std::logic_error("Destination tensor should be like source");
+    }
+    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+template <typename T>
+void CopyIn(Tensor<T>& dst, const Tensor<T>& src)
+{
+    if (src.GetSize() > dst.GetSize()) {
+        throw std::logic_error("Source tensor is too big");
+    }
+    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
+        dst[i] = src[i];
+    }
+}
+
+template <typename T>
+void CopyOut(const Tensor<T>& src, Tensor<T>& dst)
+{
+    if (dst.GetSize() < src.GetSize()) {
+        throw std::logic_error("Destination tensor is too small");
+    }
+    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
+        dst[i] = src[i];
+    }
+}
+
+// Partial specializtion for E_x + E_y
+template <typename T, typename U>
+struct Evaluator<OpAdd<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAdd<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Add(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                   Evaluator<U>{}(op.GetRhs(), args, localVars));
+    }
+};
+
+// Partial specializtion for E_x - E_y
+template <typename T, typename U>
+struct Evaluator<OpSubtract<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpSubtract<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Subtract(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                        Evaluator<U>{}(op.GetRhs(), args, localVars));
+    }
+};
+
+// Partial specializtion for E_z = E_x + E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return AddAssign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                         Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
+                         Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
+    }
+};
+
+// Partial specialization for CopyIn(E_dst, E_src)
+template <typename T, typename U>
+struct Evaluator<OpCopyInData<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpCopyInData<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        auto& dst = Evaluator<T>{}(op.GetLhs(), args, localVars);
+        const auto& src = Evaluator<U>{}(op.GetRhs(), args, localVars);
+        CopyIn(dst, src);
+    }
+};
+
+// Partial specialization for CopyOut(E_src, E_dst)
+template <typename T, typename U>
+struct Evaluator<OpCopyOutData<T, U>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpCopyOutData<T, U>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        const auto& src = Evaluator<T>{}(op.GetLhs(), args, localVars);
+        auto& dst = Evaluator<U>{}(op.GetRhs(), args, localVars);
+        CopyOut(src, dst);
+    }
+};
+
+} // namespace DemoEval
+
+#endif // DEMO_EVAL_H
diff --git a/best_practices/expression_template/emulation.h b/best_practices/expression_template/emulation.h
new file mode 100644
index 000000000..fe08db926
--- /dev/null
+++ b/best_practices/expression_template/emulation.h
@@ -0,0 +1,235 @@
+#ifndef EMULATION_H
+#define EMULATION_H
+
+/* Emulation */
+
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "demo_eval.h"
+#include "expr_tmpl.h"
+#include "layout.h"
+#include "util.h"
+
+namespace Emulation {
+
+using namespace DemoEval;
+
+namespace Detail {
+
+template <typename ParamType, typename ArgTup>
+constexpr auto ConstructParam(ArgTup& args)
+{
+    // decay_t is very important here.  If ParamType::Type were a
+    // reference type and decaying did not happen, the expression below
+    // would become a reinterpret_cast: disasters would follow then.
+    return typename std::decay_t<typename ParamType::Type>(
+        std::get<ParamType::number - 1>(args));
+}
+
+template <typename Params, typename ArgTup, std::size_t... Ints>
+constexpr auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        ConstructParam<
+            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
+            args)...);
+}
+
+template <typename Params, std::size_t Index, typename ParamTup,
+          typename ArgTup>
+constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
+{
+    constexpr auto pos =
+        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
+    if constexpr (pos < Util::TMP::Size_v<Params>) {
+        return std::get<pos>(params);
+    } else {
+        return std::get<Index>(args);
+    }
+}
+
+template <typename Params, typename ParamTup, typename ArgTup,
+          std::size_t... Ints>
+constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+                     std::index_sequence<Ints...>)
+{
+    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
+}
+
+template <typename Params, std::size_t Index, ParamUsage... usages,
+          typename ParamTup>
+constexpr auto GetOneParam(ParamTup& params)
+{
+    using Param = Util::TMP::Get_t<Params, Index>;
+    if constexpr (((Param::usage == usages) || ...)) {
+        return std::forward_as_tuple(std::get<Index>(params));
+    } else {
+        return std::tuple<>{};
+    }
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetInParamsImpl(ParamTup& params,
+                               std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetOutParamsImpl(ParamTup& params,
+                                std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename InParams, std::size_t Index, typename T, typename ArgTup>
+void CopyInOneParam(T& param, ArgTup& args)
+{
+    using Param = Util::TMP::Get_t<InParams, Index>;
+    param.CopyIn(std::get<Param::number - 1>(args));
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyInImpl(InParamTup& inParams, ArgTup& args,
+                std::index_sequence<Ints...>)
+{
+    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args), ...);
+}
+
+template <typename OutParams, std::size_t Index, typename T, typename ArgTup>
+void CopyOutOneParam(T& param, ArgTup& args)
+{
+    using Param = Util::TMP::Get_t<OutParams, Index>;
+    param.CopyOut(std::get<Param::number - 1>(args));
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup,
+          std::size_t... Ints>
+void CopyOutImpl(OutParamTup& outParams, ArgTup& args,
+                 std::index_sequence<Ints...>)
+{
+    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args), ...);
+}
+
+} // namespace Detail
+
+template <typename Params, typename ArgTup>
+auto PrepareParams(ArgTup& argTuple)
+{
+    return Detail::PrepareParamsImpl<Params>(
+        argTuple, std::make_index_sequence<Size_v<Params>>{});
+}
+
+template <typename Params, typename ParamTup, typename ArgTup>
+auto ConvertArgs(ParamTup& params, ArgTup& args)
+{
+    return Detail::ConvertArgsImpl<Params>(
+        params, args,
+        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
+}
+
+template <typename LocalVars, typename ArgTup>
+auto PrepareLocalVars(ArgTup& args)
+{
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, args);
+    return localVars;
+}
+
+template <typename Params, typename ParamTup>
+auto GetInParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetInParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename Params, typename ParamTup>
+auto GetOutParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetOutParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename InParams, typename InParamTup, typename ArgTup>
+void CopyIn(InParamTup& inParams, ArgTup& args)
+{
+    constexpr auto size = Size_v<InParams>;
+    static_assert(size == std::tuple_size_v<InParamTup>);
+    Detail::CopyInImpl<InParams>(inParams, args,
+                                 std::make_index_sequence<size>{});
+}
+
+template <typename OutParams, typename OutParamTup, typename ArgTup>
+void CopyOut(OutParamTup& outParams, ArgTup& args)
+{
+    constexpr auto size = Size_v<OutParams>;
+    static_assert(size == std::tuple_size_v<OutParamTup>);
+    Detail::CopyOutImpl<OutParams>(outParams, args,
+                                   std::make_index_sequence<size>{});
+}
+
+template <typename T>
+using SimpleTensor = DemoEval::Tensor<
+    T, Demo::Layout<Demo::FixedRankExtents<std::size_t, 1>>>;
+
+template <typename ExprMaker, typename... Args,
+          typename = std::enable_if_t<
+              std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
+void DoElementwise(const ExprMaker& maker, Args&&... args)
+{
+    auto expr = maker.template Get<SimpleTensor>();
+    using Expr = typename decltype(expr)::Type;
+    static_assert(
+        !Expr::hasData,
+        "This expression template is not supposed to contain data");
+
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+
+    using Params = Params_t<Expr>;
+    using InParams = InParams_t<Expr>;
+    using OutParams = OutParams_t<Expr>;
+
+    // tuple of values
+    auto params = PrepareParams<Params>(argTuple);
+
+    // tuple of references
+    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
+
+    // tuple of values
+    using LocalVars = LocalVars_t<Expr>;
+    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
+
+    // tuple of references
+    auto inParams = GetInParams<Params>(params);
+    auto outParams = GetOutParams<Params>(params);
+
+    CopyIn<InParams>(inParams, argTuple);
+    Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
+    CopyOut<OutParams>(outParams, argTuple);
+
+    Util::ForEach(params, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+    Util::ForEach(localVars, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+}
+
+} // namespace Emulation
+
+#endif // EMULATION_H
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index ea1dd6310..e163788bc 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1,1835 +1,15 @@
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
-#include <stdexcept>
-#include <tuple>
 #include <type_traits>
-#include <utility>
 #include <vector>
+#include "block_emulation.h"
+#include "demo_eval.h"
+#include "emulation.h"
+#include "expr_tmpl.h"
 #include "layout.h"
 #include "tensor.h"
-
-template <typename T>
-struct type_displayer;
-
-#define CONCAT(x, y) x ## y
-#define PASTE(x, y) CONCAT(x, y)
-#define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
-
-
-/* Utilities */
-
-namespace Util {
-
-template <typename T>
-struct AlwaysFalse : std::false_type {};
-
-template <typename T>
-inline constexpr bool AlwaysFalse_v = AlwaysFalse<T>::value;
-
-template <template <typename...> class T, typename U>
-struct IsSpecializationOf : std::false_type {};
-
-template <template <typename...> class T, typename... Us>
-struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
-
-template <template <typename...> class T, typename U>
-inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
-
-template <typename T, typename = void>
-struct HasClear : std::false_type {};
-
-template <typename T>
-struct HasClear<T, std::void_t<decltype(std::declval<T&>().Clear())>>
-    : std::true_type {};
-
-template <typename T>
-inline constexpr bool HasClear_v = HasClear<T>::value;
-
-template <
-    typename Tuple, typename Func,
-    std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
-                     int> = 0>
-void ForEach(Tuple&& tuple, Func&& func)
-{
-    std::apply(
-        [&func](auto&&... args) {
-            (std::forward<Func>(func)(std::forward<decltype(args)>(args)),
-             ...);
-        },
-        std::forward<Tuple>(tuple));
-}
-
-namespace Detail {
-
-// Storage implementations for different compression scenarios
-template <typename T, bool Compress>
-struct CompressedDataStorage;
-
-// Case 1: Not compressed
-template <typename T>
-struct CompressedDataStorage<T, false> {
-    template <typename U,
-              typename = std::enable_if_t<
-                  !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
-    explicit CompressedDataStorage(U&& u) : data_(std::forward<U>(u))
-    {
-    }
-
-    CompressedDataStorage() = default;
-
-    T& Data() { return data_; }
-    const T& Data() const { return data_; }
-
-private:
-    T data_;
-};
-
-// Case 2: Compressed
-template <typename T>
-struct CompressedDataStorage<T, true> : private T {
-    template <typename U,
-              typename = std::enable_if_t<
-                  !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
-    explicit CompressedDataStorage(U&& u) : T(std::forward<U>(u))
-    {
-    }
-
-    CompressedDataStorage() = default;
-
-    T& Data() { return static_cast<T&>(*this); }
-    const T& Data() const { return static_cast<const T&>(*this); }
-};
-
-// Storage implementations for different compression scenarios
-template <typename T1, typename T2, bool CompressFirst, bool CompressSecond>
-struct CompressedPairStorage;
-
-// Case 1: Neither can be compressed
-template <typename T1, typename T2>
-struct CompressedPairStorage<T1, T2, false, false> {
-    template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
-        : first_(std::forward<U1>(f)), second_(std::forward<U2>(s))
-    {
-    }
-
-    CompressedPairStorage() = default;
-
-    T1& First() { return first_; }
-    const T1& First() const { return first_; }
-    T2& Second() { return second_; }
-    const T2& Second() const { return second_; }
-
-private:
-    T1 first_;
-    T2 second_;
-};
-
-// Case 2: Only first can be compressed
-template <typename T1, typename T2>
-struct CompressedPairStorage<T1, T2, true, false> : private T1 {
-    template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
-        : T1(std::forward<U1>(f)), second_(std::forward<U2>(s))
-    {
-    }
-
-    CompressedPairStorage() = default;
-
-    T1& First() { return static_cast<T1&>(*this); }
-    const T1& First() const { return static_cast<const T1&>(*this); }
-    T2& Second() { return second_; }
-    const T2& Second() const { return second_; }
-
-private:
-    T2 second_;
-};
-
-// Case 3: Only second can be compressed
-template <typename T1, typename T2>
-struct CompressedPairStorage<T1, T2, false, true> : private T2 {
-    template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
-        : T2(std::forward<U2>(s)), first_(std::forward<U1>(f))
-    {
-    }
-
-    CompressedPairStorage() = default;
-
-    T1& First() { return first_; }
-    const T1& First() const { return first_; }
-    T2& Second() { return static_cast<T2&>(*this); }
-    const T2& Second() const { return static_cast<const T2&>(*this); }
-
-private:
-    T1 first_;
-};
-
-// Case 4: Both can be compressed, different types
-template <typename T1, typename T2>
-struct CompressedPairStorage<T1, T2, true, true> : private T1, private T2 {
-    template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
-        : T1(std::forward<U1>(f)), T2(std::forward<U2>(s))
-    {
-    }
-
-    CompressedPairStorage() = default;
-
-    T1& First() { return static_cast<T1&>(*this); }
-    const T1& First() const { return static_cast<const T1&>(*this); }
-    T2& Second() { return static_cast<T2&>(*this); }
-    const T2& Second() const { return static_cast<const T2&>(*this); }
-};
-
-// Case 5: Both can be compressed, same type
-template <typename T>
-struct CompressedPairStorage<T, T, true, true> : private T {
-    template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&&) : T(std::forward<U1>(f))
-    {
-    }
-
-    CompressedPairStorage() = default;
-
-    T& First() { return static_cast<T&>(*this); }
-    const T& First() const { return static_cast<const T&>(*this); }
-    T& Second() { return static_cast<T&>(*this); }
-    const T& Second() const { return static_cast<const T&>(*this); }
-};
-
-} // namespace Detail
-
-template <typename T>
-class CompressedData : private Detail::CompressedDataStorage<
-                           T, std::is_empty_v<T> && !std::is_final_v<T>> {
-    using Storage = Detail::CompressedDataStorage<
-        T, std::is_empty_v<T> && !std::is_final_v<T>>;
-
-public:
-    using Type = T;
-
-    // Default constructor
-    CompressedData() = default;
-
-    // Perfect forwarding constructor
-    template <typename U,
-              typename = std::enable_if_t<
-                  !std::is_same_v<std::decay_t<U>, CompressedData>>>
-    explicit CompressedData(U&& u) : Storage(std::forward<U>(u))
-    {
-    }
-
-    // Accessors for data
-    T& Data() { return Storage::Data(); }
-    const T& Data() const { return Storage::Data(); }
-
-    // Swap
-    void swap(CompressedData& other) noexcept
-    {
-        using std::swap;
-        swap(Data(), other.Data());
-    }
-};
-
-// Swap function
-template <typename T>
-void swap(CompressedData<T>& lhs, CompressedData<T>& rhs) noexcept
-{
-    lhs.swap(rhs);
-}
-
-// Equality comparison operators
-template <typename T>
-bool operator==(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
-{
-    return lhs.Data() == rhs.Data();
-}
-
-template <typename T>
-bool operator!=(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
-{
-    return !(lhs == rhs);
-}
-
-template <typename T1, typename T2>
-class CompressedPair
-    : private Detail::CompressedPairStorage<
-          T1, T2,
-          std::is_empty_v<T1> && !std::is_final_v<T1>,
-          std::is_empty_v<T2> && !std::is_final_v<T2>> {
-    using Storage = Detail::CompressedPairStorage<
-        T1, T2,
-        std::is_empty_v<T1> && !std::is_final_v<T1>,
-        std::is_empty_v<T2> && !std::is_final_v<T2>>;
-
-public:
-    using FirstType = T1;
-    using SecondType = T2;
-
-    // Default constructor
-    CompressedPair() = default;
-
-    // Perfect forwarding constructor
-    template<typename U1, typename U2>
-    CompressedPair(U1&& f, U2&& s)
-        : Storage(std::forward<U1>(f), std::forward<U2>(s)) {}
-
-    // Accessors for first element
-    T1& First() { return Storage::First(); }
-    const T1& First() const { return Storage::First(); }
-
-    // Accessors for second element
-    T2& Second() { return Storage::Second(); }
-    const T2& Second() const { return Storage::Second(); }
-
-    // Swap
-    void swap(CompressedPair& other) noexcept
-    {
-        using std::swap;
-        swap(First(), other.First());
-        swap(Second(), other.Second());
-    }
-};
-
-// Deduction guide
-template <typename T1, typename T2>
-CompressedPair(T1&& f, T2&& s)
-    -> CompressedPair<std::decay_t<T1>, std::decay_t<T2>>;
-
-// Swap function
-template <typename T1, typename T2>
-void swap(CompressedPair<T1, T2>& lhs, CompressedPair<T1, T2>& rhs) noexcept
-{
-    lhs.swap(rhs);
-}
-
-// Equality comparison operators
-template <typename T1, typename T2>
-bool operator==(const CompressedPair<T1, T2>& lhs,
-                const CompressedPair<T1, T2>& rhs)
-{
-    return lhs.First() == rhs.First() && lhs.Second() == rhs.Second();
-}
-
-template <typename T1, typename T2>
-bool operator!=(const CompressedPair<T1, T2>& lhs,
-                const CompressedPair<T1, T2>& rhs)
-{
-    return !(lhs == rhs);
-}
-
-namespace TMP {
-
-template <typename... Ts>
-struct TypeList {};
-
-template <typename List>
-struct First;
-
-template <typename Head, typename... Tail>
-struct First<TypeList<Head, Tail...>> {
-    using Type = Head;
-};
-
-template <typename List>
-using First_t = typename First<List>::Type;
-
-template <typename List>
-struct Size;
-
-template <typename... Ts>
-struct Size<TypeList<Ts...>> {
-    static constexpr std::size_t value = sizeof...(Ts);
-};
-
-template <typename List>
-inline constexpr std::size_t Size_v = Size<List>::value;
-
-template <typename T, typename List>
-struct Prepend;
-
-template <typename T, typename... Ts>
-struct Prepend<T, TypeList<Ts...>> {
-    using Type = TypeList<T, Ts...>;
-};
-
-template <typename T, typename List>
-using Prepend_t = typename Prepend<T, List>::Type;
-
-template <typename... Lists>
-struct Concatenate;
-
-template <>
-struct Concatenate<> {
-    using Type = TypeList<>;
-};
-
-template <typename... Ts>
-struct Concatenate<TypeList<Ts...>> {
-    using Type = TypeList<Ts...>;
-};
-
-template <typename... Ts, typename... Us>
-struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
-    using Type = TypeList<Ts..., Us...>;
-};
-
-template <typename List1, typename List2, typename List3, typename... Lists>
-struct Concatenate<List1, List2, List3, Lists...> {
-    using Type =
-        typename Concatenate<typename Concatenate<List1, List2>::Type,
-                             List3, Lists...>::Type;
-};
-
-template <typename... Lists>
-using Concatenate_t = typename Concatenate<Lists...>::Type;
-
-template <template <typename> class Pred, typename List>
-struct Check;
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Check<Pred, TypeList<Head, Tail...>> {
-    static constexpr bool value =
-        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
-};
-
-template <template <typename> class Pred>
-struct Check<Pred, TypeList<>> {
-    static constexpr bool value = true;
-};
-
-template <template <typename> class Pred, typename List>
-inline constexpr bool Check_v = Check<Pred, List>::value;
-
-template <template <typename> class Pred, typename List>
-struct Filter;
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Filter<Pred, TypeList<Head, Tail...>> {
-    using Type = typename std::conditional_t<
-        Pred<Head>::value,
-        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
-        typename Filter<Pred, TypeList<Tail...>>::Type>;
-};
-
-template <template <typename> class Pred>
-struct Filter<Pred, TypeList<>> {
-    using Type = TypeList<>;
-};
-
-template <template <typename> class Pred, typename List>
-using Filter_t = typename Filter<Pred, List>::Type;
-
-template <template <typename> class Pred, typename List, typename = void>
-struct Find;
-
-template <template <typename> class Pred>
-struct Find<Pred, TypeList<>> {
-    static constexpr std::size_t value = 0;
-};
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Find<Pred, TypeList<Head, Tail...>,
-            std::enable_if_t<Pred<Head>::value>> {
-    static constexpr std::size_t value = 0;
-};
-
-template <template <typename> class Pred, typename Head, typename... Tail>
-struct Find<Pred, TypeList<Head, Tail...>,
-            std::enable_if_t<!Pred<Head>::value>> {
-    static constexpr std::size_t value =
-        Find<Pred, TypeList<Tail...>>::value + 1;
-};
-
-template <template <typename> class Pred, typename List>
-inline constexpr std::size_t Find_v = Find<Pred, List>::value;
-
-template <typename List, std::size_t N>
-struct Get;
-
-template <typename Head, typename... Tail, std::size_t N>
-struct Get<TypeList<Head, Tail...>, N> {
-    using Type = typename Get<TypeList<Tail...>, N - 1>::Type;
-};
-
-template <typename Head, typename... Tail>
-struct Get<TypeList<Head, Tail...>, 0> {
-    using Type = Head;
-};
-
-template <std::size_t N>
-struct Get<TypeList<>, N> {
-    static_assert(N < 0, "Index out of bounds in Get");
-};
-
-template <typename List, std::size_t N>
-using Get_t = typename Get<List, N>::Type;
-
-template <typename List>
-struct Unique;
-
-template <typename Head, typename... Tail>
-struct Unique<TypeList<Head, Tail...>> {
-    template <typename T>
-    struct IsNotHead : std::bool_constant<!std::is_same_v<T, Head>> {};
-
-    using Type = Prepend_t<
-        Head,
-        typename Unique<Filter_t<IsNotHead, TypeList<Tail...>>>::Type>;
-};
-
-template <>
-struct Unique<TypeList<>> {
-    using Type = TypeList<>;
-};
-
-template <typename List>
-using Unique_t = typename Unique<List>::Type;
-
-template <template <typename> class Pred, typename List>
-struct FindUnique {
-    using ResultList = Filter_t<Pred, List>;
-    static_assert(Size_v<ResultList> != 0, "Cannot find the specified element");
-    static_assert(Size_v<ResultList> == 1, "A unique result is expected");
-    using Type = First_t<ResultList>;
-};
-
-template <template <typename> class Pred, typename List>
-using FindUnique_t = typename FindUnique<Pred, List>::Type;
-
-} // namespace TMP
-
-} // namespace Util
-
-
-/* Expression templates */
-
-// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
-// NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature)
-// NOLINTBEGIN(misc-unconventional-assign-operator)
-
-namespace ExprTmpl {
-
-using Util::TMP::TypeList;
-
-template <typename T, typename = void>
-struct HasDataTrait {
-    static constexpr bool value = true;
-};
-
-template <typename T>
-struct HasDataTrait<T, std::void_t<decltype(T::hasData)>> {
-    static constexpr bool value = T::hasData;
-};
-
-// Type for a basic "expression".  If T is trivial (as it should normally
-// be), Expression<T> is trivially copy-constructible and trivially move-
-// constructible, but is not trivially assignable.  Objects of the same
-// Expression type cannot be assigned, because the data member is const.
-// Objects of different Expression types can be assigned, but it will
-// result in a new Expression object (and is not a "normal" assignment).
-template <typename T>
-struct Expression {
-    static_assert(!std::is_rvalue_reference_v<T>,
-                  "Rvalue references cannot be stored");
-    using Type = T;
-    static constexpr bool hasData = HasDataTrait<T>::value;
-
-    T const data{};
-
-    template <typename U>
-    [[nodiscard]] constexpr auto operator=(Expression<U> u);
-};
-
-// Let T deduce to value type or lvalue reference type
-template <typename T>
-Expression(T&& value) -> Expression<T>;
-
-template <typename T>
-using IsExpression = Util::IsSpecializationOf<Expression, T>;
-
-template <typename T>
-inline constexpr bool IsExpression_v = IsExpression<T>::value;
-
-template <std::size_t N, typename T, typename L = void>
-struct LocalVar {
-    static_assert(!std::is_reference_v<T>,
-                  "A LocalVar must not be a reference");
-    using Type = T;
-    using Like = L;
-    static constexpr std::size_t number = N;
-    static constexpr bool hasData = false;
-
-    template <typename V>
-    constexpr auto operator=(Expression<V>)
-    {
-        static_assert(Util::AlwaysFalse_v<V>,
-                      "Please use Expression<LocalVar> for assignment");
-    }
-};
-
-template <typename T>
-struct IsLocalVar : std::false_type {};
-
-template <std::size_t N, typename T, typename L>
-struct IsLocalVar<LocalVar<N, T, L>> : std::true_type {};
-
-template <typename T>
-inline constexpr bool IsLocalVar_v = IsLocalVar<T>::value;
-
-enum class ParamUsage {
-    in,
-    out,
-    in_out,
-    //temporary,
-};
-
-template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
-struct Param {
-    using Type = T;
-    static constexpr std::size_t number = N;
-    static constexpr ParamUsage usage = U;
-    static constexpr bool hasData = false;
-
-    template <typename V>
-    constexpr auto operator=(Expression<V>)
-    {
-        static_assert(Util::AlwaysFalse_v<V>,
-                      "Please use Expression<Param> for assignment");
-    }
-};
-
-template <typename T>
-struct IsParam : std::false_type {};
-
-template <std::size_t N, typename T, ParamUsage U>
-struct IsParam<Param<N, T, U>> : std::true_type {};
-
-template <typename T>
-inline constexpr bool IsParam_v = IsParam<T>::value;
-
-template <std::size_t N, typename T>
-constexpr auto DefineLocalVar()
-{
-    return Expression<LocalVar<N, T>>{};
-}
-
-template <std::size_t N, typename L>
-constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
-{
-    static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
-    return Expression<LocalVar<N, typename L::Type, L>>{};
-}
-
-template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
-constexpr auto DefineParam()
-{
-    return Expression<Param<N, T, U>>{};
-}
-
-template <std::size_t N>
-struct CheckVarNum {
-    template <typename T>
-    struct Checker {
-        static constexpr bool value = (T::number == N);
-    };
-};
-
-template <typename T>
-struct UnaryOp : private Util::CompressedData<T> {
-private:
-    using Storage = Util::CompressedData<T>;
-
-public:
-    static_assert(!std::is_rvalue_reference_v<T>,
-                  "Rvalue references cannot be stored");
-    static constexpr bool hasData = HasDataTrait<T>::value;
-    using IsUnaryOp = void;
-    using DataType = T;
-
-    UnaryOp() = default;
-    constexpr UnaryOp(T t) : Storage(t) {}
-
-    constexpr const T& GetData() const { return Storage::Data(); }
-};
-
-template <typename T, typename U>
-struct BinaryOp : private Util::CompressedPair<T, U> {
-private:
-    using Storage = Util::CompressedPair<T, U>;
-
-public:
-    static_assert(!(std::is_rvalue_reference_v<T> ||
-                    std::is_rvalue_reference_v<U>),
-                  "Rvalue references cannot be stored");
-    static constexpr bool hasData =
-        HasDataTrait<T>::value || HasDataTrait<U>::value;
-    using IsBinaryOp = void;
-    using LhsType = T;
-    using RhsType = U;
-
-    BinaryOp() = default;
-    constexpr BinaryOp(T t, U u) : Storage(t, u) {}
-
-    constexpr const T& GetLhs() const { return Storage::First(); }
-    constexpr const U& GetRhs() const { return Storage::Second(); }
-};
-
-namespace Detail {
-
-template <typename T, typename = void>
-struct LocalVarCollector {
-    using Type = TypeList<>;
-};
-
-template <typename T>
-struct LocalVarCollector<T, std::enable_if_t<IsLocalVar_v<T>>> {
-    using Type = TypeList<T>;
-};
-
-template <typename T>
-struct LocalVarCollector<T, std::void_t<typename T::IsBinaryOp>> {
-    using Type = Util::TMP::Concatenate_t<
-        typename LocalVarCollector<typename T::LhsType>::Type,
-        typename LocalVarCollector<typename T::RhsType>::Type>;
-};
-
-template <typename T, typename = void>
-struct ParamCollector {
-    using Type = TypeList<>;
-};
-
-template <typename T>
-struct ParamCollector<T, std::enable_if_t<IsParam_v<T>>> {
-    using Type = TypeList<T>;
-};
-
-template <typename T>
-struct ParamCollector<T, std::void_t<typename T::IsBinaryOp>> {
-    using Type = Util::TMP::Concatenate_t<
-        typename ParamCollector<typename T::LhsType>::Type,
-        typename ParamCollector<typename T::RhsType>::Type>;
-};
-
-} // namespace Detail
-
-template <typename T>
-struct LocalVars {
-    using Type =
-        Util::TMP::Unique_t<typename Detail::LocalVarCollector<T>::Type>;
-
-private:
-    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
-
-    template <typename U>
-    struct InRange
-        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
-    static_assert(Util::TMP::Check_v<InRange, Type>,
-                  "LocalVars must be numbered sequentially from 1");
-};
-
-template <typename T>
-using LocalVars_t = typename LocalVars<T>::Type;
-
-template <typename T>
-struct Params {
-    using Type =
-        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
-
-private:
-    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
-
-    template <typename U>
-    struct InRange
-        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
-    static_assert(Util::TMP::Check_v<InRange, Type>,
-                  "Params must be numbered sequentially from 1");
-};
-
-template <typename T>
-using Params_t = typename Params<T>::Type;
-
-template <typename T>
-struct InParams {
-    template <typename U>
-    struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
-                                        U::usage == ParamUsage::in_out> {};
-    using Type = Util::TMP::Filter_t<IsInVar, Params_t<T>>;
-};
-
-template <typename T>
-using InParams_t = typename InParams<T>::Type;
-
-template <typename T>
-struct OutParams {
-    template <typename U>
-    struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
-                                         U::usage == ParamUsage::in_out> {};
-    using Type = Util::TMP::Filter_t<IsOutVar, Params_t<T>>;
-};
-
-template <typename T>
-using OutParams_t = typename OutParams<T>::Type;
-
-template <typename T>
-struct OpCopyInParam : UnaryOp<T> {
-    OpCopyInParam() = default;
-    constexpr OpCopyInParam(T t) : UnaryOp<T>(t) {}
-};
-
-template <typename T>
-[[nodiscard]] constexpr auto CopyIn(Expression<T> t)
-{
-    static_assert(IsParam_v<T>, "Only a Param supports CopyIn");
-    static_assert(
-        T::usage == ParamUsage::in || T::usage == ParamUsage::in_out,
-        "Param usage must be in or in_out");
-    return Expression<OpCopyInParam<T>>{{t.data}};
-}
-
-template <typename T>
-struct OpCopyOutParam : UnaryOp<T> {
-    OpCopyOutParam() = default;
-    constexpr OpCopyOutParam(T t) : UnaryOp<T>(t) {}
-};
-
-template <typename T>
-[[nodiscard]] constexpr auto CopyOut(Expression<T> t)
-{
-    static_assert(IsParam_v<T>, "Only a Param supports CopyOut");
-    static_assert(
-        T::usage == ParamUsage::out || T::usage == ParamUsage::in_out,
-        "Param usage must be out or in_out");
-    return Expression<OpCopyOutParam<T>>{{t.data}};
-}
-
-template <typename T, typename U>
-struct OpAssign : BinaryOp<T, U> {
-    OpAssign() = default;
-    constexpr OpAssign(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
-template <typename T>
-template <typename U>
-[[nodiscard]] constexpr auto Expression<T>::operator=(Expression<U> u)
-{
-    static_assert(
-        (IsParam_v<T> || IsLocalVar_v<T> || std::is_lvalue_reference_v<T>),
-        "Only a Param, LocalVar, or reference can appear on the left side "
-        "of assignment");
-    return Expression<OpAssign<T, U>>{{data, u.data}};
-}
-
-template <typename T, typename U>
-struct OpAndThen : BinaryOp<T, U> {
-    OpAndThen() = default;
-    constexpr OpAndThen(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
-{
-    return Expression<OpAndThen<T, U>>{{t.data, u.data}};
-}
-
-// Disallow dangerous expressions like (Expression{2}, 3)
-template <typename T, typename U>
-constexpr auto operator,(Expression<T>t, U&& u) = delete;
-
-template <typename T, typename U>
-struct OpAdd : BinaryOp<T, U> {
-    OpAdd() = default;
-    constexpr OpAdd(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
-{
-    return Expression<OpAdd<T, U>>{{lhs.data, rhs.data}};
-}
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator+(Expression<T> lhs, U&& rhs)
-{
-    return Expression<OpAdd<T, U>>{{lhs.data, std::forward<U>(rhs)}};
-}
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator+(T&& lhs, Expression<U> rhs)
-{
-    return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
-}
-
-template <typename T, typename U>
-struct OpSubtract : BinaryOp<T, U> {
-    OpSubtract() = default;
-    constexpr OpSubtract(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator-(Expression<T> lhs, Expression<U> rhs)
-{
-    return Expression<OpSubtract<T, U>>{{lhs.data, rhs.data}};
-}
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator-(Expression<T> lhs, U&& rhs)
-{
-    return Expression<OpSubtract<T, U>>{{lhs.data, std::forward<U>(rhs)}};
-}
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto operator-(T&& lhs, Expression<U> rhs)
-{
-    return Expression<OpSubtract<T, U>>{{std::forward<T>(lhs), rhs.data}};
-}
-
-template <typename T, typename U>
-struct OpCopyInData : BinaryOp<T, U> {
-    OpCopyInData() = default;
-    constexpr OpCopyInData(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
-template <typename T, typename U>
-struct OpCopyOutData : BinaryOp<T, U> {
-    OpCopyOutData() = default;
-    constexpr OpCopyOutData(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto CopyInData(Expression<T> dst,
-                                        Expression<U> src)
-{
-    static_assert(IsLocalVar_v<T>,
-                  "Only a LocalVar can be the destination of CopyIn");
-    return Expression<OpCopyInData<T, U>>{{dst.data, src.data}};
-}
-
-template <typename T, typename U>
-[[nodiscard]] constexpr auto CopyOutData(Expression<T> src,
-                                         Expression<U> dst)
-{
-    static_assert(
-        IsParam_v<U> || std::is_lvalue_reference_v<U>,
-        "Only a Param or reference can be the destination of CopyOut");
-    return Expression<OpCopyOutData<T, U>>{{src.data, dst.data}};
-}
-
-// Base class to express that a class is a maker of calculation expression template
-class Maker {};
-
-} // namespace ExprTmpl
-
-// NOLINTEND(misc-unconventional-assign-operator)
-// NOLINTEND(cppcoreguidelines-c-copy-assignment-signature)
-// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
-
-
-/* Evaluation */
-
-namespace DemoEval {
-
-using Demo::Tensor;
-using Util::TMP::FindUnique_t;
-using Util::TMP::Size_v;
-
-using namespace ExprTmpl;
-
-// Primary template
-template <typename T>
-struct Evaluator {
-    using Type = T;
-
-    template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(const T& value,
-                              ArgTup& args,
-                              LocalVarTup& localVars) const
-    {
-        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
-            return value(args, localVars);
-        } else {
-            return value;
-        }
-    }
-};
-
-template <std::size_t N, typename T>
-constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
-{
-    using ResultType = typename Evaluator<T>::Type;
-    return Expression<LocalVar<N, ResultType>>{};
-}
-
-namespace Detail {
-
-template <typename Params, std::size_t... Ints>
-constexpr auto GetParamTupleImpl(std::index_sequence<Ints...>)
-{
-    return std::make_tuple(
-        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
-                              Params>::Type{}...);
-}
-
-template <typename LocalVars, std::size_t... Ints>
-constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
-{
-    return std::make_tuple(
-        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
-                              LocalVars>::Type{}...);
-}
-
-template <typename T>
-void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
-{
-    dst.resize(src.size());
-}
-
-template <typename T, typename L>
-void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<T, L>& src)
-{
-    dst.SetSize(src.GetSize());
-}
-
-template <typename L, typename T, typename ArgTup>
-void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
-{
-    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
-    if constexpr (!std::is_same_v<typename L::Like, void>) {
-        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
-    }
-}
-
-template <typename LocalVars, typename LocalVarTup, typename ArgTup,
-          std::size_t... Ints>
-void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
-                            std::index_sequence<Ints...>)
-{
-    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
-         std::get<Ints>(localVars), args),
-     ...);
-}
-
-} // namespace Detail
-
-template <typename Params>
-constexpr auto GetParamTuple()
-{
-    constexpr auto paramCount = Size_v<Params>;
-    return Detail::GetParamTupleImpl<Params>(
-        std::make_index_sequence<paramCount>{});
-};
-
-template <typename LocalVars>
-constexpr auto GetLocalVarTuple()
-{
-    constexpr auto localVarCount = Size_v<LocalVars>;
-    return Detail::GetLocalVarTupleImpl<LocalVars>(
-        std::make_index_sequence<localVarCount>{});
-};
-
-template <typename LocalVars, typename LocalVarTup, typename ArgTup>
-void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
-{
-    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
-        localVars, args,
-        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
-}
-
-template <typename T>
-class final_action {
-public:
-    explicit final_action(T action) : action_(std::move(action)) {}
-
-    final_action(final_action&& other) noexcept
-        : action_(std::move(other.action_)),
-          is_active_(std::exchange(other.is_active_, false))
-    {
-    }
-
-    final_action(const final_action&) = delete;
-    final_action& operator=(const final_action&) = delete;
-    final_action& operator=(final_action&&) = delete;
-
-    ~final_action()
-    {
-        if (is_active_) {
-            action_();
-        }
-    }
-
-    void dismiss() noexcept
-    {
-        is_active_ = false;
-    }
-
-private:
-    T action_;
-    bool is_active_{true};
-};
-
-template <typename T>
-auto finally(T&& action)
-{
-    return final_action<std::decay_t<T>>(std::forward<T>(action));
-}
-
-template <typename T, typename... Args>
-auto Evaluate(const Expression<T>& expr, Args&&... args)
-{
-    // Declare local variables so that we can always use xTup& in
-    // Evaluator<>::operator()
-    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
-    using LocalVars = LocalVars_t<T>;
-    [[maybe_unused]] Params_t<T> dummy;  // Force checking the params
-    auto localVars = GetLocalVarTuple<LocalVars>();
-    MakeAlikeLocalVars<LocalVars>(localVars, argTuple);
-    auto cleanup = finally([&] {
-        Util::ForEach(localVars, [](auto& arg) {
-            if constexpr (Util::HasClear_v<decltype(arg)>) {
-                arg.Clear();
-            }
-        });
-    });
-    return Evaluator<T>{}(expr.data, argTuple, localVars);
-}
-
-// Treat Evaluator<Expression<T>> as Evaluator<T>
-template <typename T>
-struct Evaluator<Expression<T>> : Evaluator<T> {};
-
-// Partial specialization for LocalVar
-template <std::size_t N, typename T, typename L>
-struct Evaluator<LocalVar<N, T, L>> {
-    using Type = T&;
-
-    template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
-                              ArgTup& /*args*/,
-                              LocalVarTup& localVars) const
-    {
-        static_assert(N > 0, "LocalVar number starts from 1");
-        return std::get<N - 1>(localVars);
-    }
-};
-
-// Partial specialization for Param
-template <std::size_t N, typename T, ParamUsage U>
-struct Evaluator<Param<N, T, U>> {
-    using Type = T;
-
-    template <typename ArgTup, typename LocalVarTup>
-    decltype(auto) operator()(Param<N, T, U> /*unused*/,
-                              ArgTup& args,
-                              LocalVarTup& /*localVars*/) const
-    {
-        static_assert(N > 0, "Param number starts from 1");
-        constexpr auto index = N - 1;
-        using NthType =
-            std::tuple_element_t<index, std::remove_reference_t<ArgTup>>;
-        if constexpr (std::is_same_v<T, NthType> ||
-                      std::is_same_v<T&, NthType> ||
-                      std::is_same_v<T&&, NthType>) {
-            return std::get<index>(args);
-        } else {
-            static_assert(
-                U == ParamUsage::in,
-                "Only in-parameters allow implicit type conversions");
-            return static_cast<T>(std::get<index>(args));
-        }
-    }
-};
-
-template <typename T, typename U>
-void Assign(T& dst, const U& src)
-{
-    dst = src;
-}
-
-// Partial specializtion for E_y = E_x
-template <typename T, typename U>
-struct Evaluator<OpAssign<T, U>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpAssign<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return Assign(Evaluator<T>{}(op.GetLhs(), args, localVars),
-                      Evaluator<U>{}(op.GetRhs(), args, localVars));
-    }
-};
-
-// Partial specializtion for E_x, E_y
-template <typename T, typename U>
-struct Evaluator<OpAndThen<T, U>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAndThen<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        // operator, evaluates sequentially
-        return Evaluator<T>{}(op.GetLhs(), args, localVars),
-               Evaluator<U>{}(op.GetRhs(), args, localVars);
-    }
-};
-
-template <typename T, typename U>
-auto Add(const T& src1, const U& src2)
-{
-    return src1 + src2;
-}
-
-template <typename T, typename U>
-auto Subtract(const T& src1, const U& src2)
-{
-    return src1 - src2;
-}
-
-template <typename T, typename U, typename V>
-void AddAssign(T& dst, const U& src1, const V& src2)
-{
-    dst = src1 + src2;
-}
-
-template <typename T>
-void AddAssign(std::vector<T>& dst,
-               const std::vector<T>& src1,
-               const std::vector<T>& src2)
-{
-    if (src1.size() != src2.size()) {
-        throw std::logic_error("vector sizes do not match");
-    }
-    if (src1.size() != dst.size()) {
-        throw std::logic_error("Destination vector should be like source");
-    }
-    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
-        dst[i] = src1[i] + src2[i];
-    }
-}
-
-template <typename T, typename L>
-void AddAssign(Tensor<T, L>& dst,
-               const Tensor<T, L>& src1,
-               const Tensor<T, L>& src2)
-{
-    if (src1.GetSize() != src2.GetSize()) {
-        throw std::logic_error("Tensor sizes do not match");
-    }
-    if (src1.GetSize() != dst.GetSize()) {
-        throw std::logic_error("Destination tensor should be like source");
-    }
-    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
-        dst[i] = src1[i] + src2[i];
-    }
-}
-
-template <typename T>
-void CopyIn(Tensor<T>& dst, const Tensor<T>& src)
-{
-    if (src.GetSize() > dst.GetSize()) {
-        throw std::logic_error("Source tensor is too big");
-    }
-    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
-        dst[i] = src[i];
-    }
-}
-
-template <typename T>
-void CopyOut(const Tensor<T>& src, Tensor<T>& dst)
-{
-    if (dst.GetSize() < src.GetSize()) {
-        throw std::logic_error("Destination tensor is too small");
-    }
-    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
-        dst[i] = src[i];
-    }
-}
-
-// Partial specializtion for E_x + E_y
-template <typename T, typename U>
-struct Evaluator<OpAdd<T, U>> {
-    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
-                              std::declval<typename Evaluator<U>::Type>()));
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAdd<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return Add(Evaluator<T>{}(op.GetLhs(), args, localVars),
-                   Evaluator<U>{}(op.GetRhs(), args, localVars));
-    }
-};
-
-// Partial specializtion for E_x - E_y
-template <typename T, typename U>
-struct Evaluator<OpSubtract<T, U>> {
-    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
-                              std::declval<typename Evaluator<U>::Type>()));
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpSubtract<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return Subtract(Evaluator<T>{}(op.GetLhs(), args, localVars),
-                        Evaluator<U>{}(op.GetRhs(), args, localVars));
-    }
-};
-
-// Partial specializtion for E_z = E_x + E_y
-template <typename T, typename U, typename V>
-struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return AddAssign(Evaluator<T>{}(op.GetLhs(), args, localVars),
-                         Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
-                         Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
-    }
-};
-
-// Partial specialization for CopyIn(E_dst, E_src)
-template <typename T, typename U>
-struct Evaluator<OpCopyInData<T, U>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpCopyInData<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        auto& dst = Evaluator<T>{}(op.GetLhs(), args, localVars);
-        const auto& src = Evaluator<U>{}(op.GetRhs(), args, localVars);
-        CopyIn(dst, src);
-    }
-};
-
-// Partial specialization for CopyOut(E_src, E_dst)
-template <typename T, typename U>
-struct Evaluator<OpCopyOutData<T, U>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    void operator()(const OpCopyOutData<T, U>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        const auto& src = Evaluator<T>{}(op.GetLhs(), args, localVars);
-        auto& dst = Evaluator<U>{}(op.GetRhs(), args, localVars);
-        CopyOut(src, dst);
-    }
-};
-
-} // namespace DemoEval
-
-namespace Emulation {
-
-using namespace DemoEval;
-
-namespace Detail {
-
-template <typename ParamType, typename ArgTup>
-constexpr auto ConstructParam(ArgTup& args)
-{
-    // decay_t is very important here.  If ParamType::Type were a
-    // reference type and decaying did not happen, the expression below
-    // would become a reinterpret_cast: disasters would follow then.
-    return typename std::decay_t<typename ParamType::Type>(
-        std::get<ParamType::number - 1>(args));
-}
-
-template <typename Params, typename ArgTup, std::size_t... Ints>
-constexpr auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
-{
-    return std::make_tuple(
-        ConstructParam<
-            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
-            args)...);
-}
-
-template <typename Params, std::size_t Index, typename ParamTup,
-          typename ArgTup>
-constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
-{
-    constexpr auto pos =
-        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
-    if constexpr (pos < Util::TMP::Size_v<Params>) {
-        return std::get<pos>(params);
-    } else {
-        return std::get<Index>(args);
-    }
-}
-
-template <typename Params, typename ParamTup, typename ArgTup,
-          std::size_t... Ints>
-constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
-                     std::index_sequence<Ints...>)
-{
-    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
-}
-
-template <typename Params, std::size_t Index, ParamUsage... usages,
-          typename ParamTup>
-constexpr auto GetOneParam(ParamTup& params)
-{
-    using Param = Util::TMP::Get_t<Params, Index>;
-    if constexpr (((Param::usage == usages) || ...)) {
-        return std::forward_as_tuple(std::get<Index>(params));
-    } else {
-        return std::tuple<>{};
-    }
-}
-
-template <typename Params, typename ParamTup, std::size_t... Ints>
-constexpr auto GetInParamsImpl(ParamTup& params,
-                               std::index_sequence<Ints...>)
-{
-    return std::tuple_cat(
-        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
-            params)...);
-}
-
-template <typename Params, typename ParamTup, std::size_t... Ints>
-constexpr auto GetOutParamsImpl(ParamTup& params,
-                                std::index_sequence<Ints...>)
-{
-    return std::tuple_cat(
-        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
-            params)...);
-}
-
-template <typename InParams, std::size_t Index, typename T, typename ArgTup>
-void CopyInOneParam(T& param, ArgTup& args)
-{
-    using Param = Util::TMP::Get_t<InParams, Index>;
-    param.CopyIn(std::get<Param::number - 1>(args));
-}
-
-template <typename InParams, typename InParamTup, typename ArgTup,
-          std::size_t... Ints>
-void CopyInImpl(InParamTup& inParams, ArgTup& args,
-                std::index_sequence<Ints...>)
-{
-    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args), ...);
-}
-
-template <typename OutParams, std::size_t Index, typename T, typename ArgTup>
-void CopyOutOneParam(T& param, ArgTup& args)
-{
-    using Param = Util::TMP::Get_t<OutParams, Index>;
-    param.CopyOut(std::get<Param::number - 1>(args));
-}
-
-template <typename OutParams, typename OutParamTup, typename ArgTup,
-          std::size_t... Ints>
-void CopyOutImpl(OutParamTup& outParams, ArgTup& args,
-                 std::index_sequence<Ints...>)
-{
-    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args), ...);
-}
-
-} // namespace Detail
-
-template <typename Params, typename ArgTup>
-auto PrepareParams(ArgTup& argTuple)
-{
-    return Detail::PrepareParamsImpl<Params>(
-        argTuple, std::make_index_sequence<Size_v<Params>>{});
-}
-
-template <typename Params, typename ParamTup, typename ArgTup>
-auto ConvertArgs(ParamTup& params, ArgTup& args)
-{
-    return Detail::ConvertArgsImpl<Params>(
-        params, args,
-        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
-}
-
-template <typename LocalVars, typename ArgTup>
-auto PrepareLocalVars(ArgTup& args)
-{
-    auto localVars = GetLocalVarTuple<LocalVars>();
-    MakeAlikeLocalVars<LocalVars>(localVars, args);
-    return localVars;
-}
-
-template <typename Params, typename ParamTup>
-auto GetInParams(ParamTup& params)
-{
-    constexpr auto size = Size_v<Params>;
-    static_assert(size == std::tuple_size_v<ParamTup>);
-    return Detail::GetInParamsImpl<Params>(
-        params, std::make_index_sequence<size>{});
-}
-
-template <typename Params, typename ParamTup>
-auto GetOutParams(ParamTup& params)
-{
-    constexpr auto size = Size_v<Params>;
-    static_assert(size == std::tuple_size_v<ParamTup>);
-    return Detail::GetOutParamsImpl<Params>(
-        params, std::make_index_sequence<size>{});
-}
-
-template <typename InParams, typename InParamTup, typename ArgTup>
-void CopyIn(InParamTup& inParams, ArgTup& args)
-{
-    constexpr auto size = Size_v<InParams>;
-    static_assert(size == std::tuple_size_v<InParamTup>);
-    Detail::CopyInImpl<InParams>(inParams, args,
-                                 std::make_index_sequence<size>{});
-}
-
-template <typename OutParams, typename OutParamTup, typename ArgTup>
-void CopyOut(OutParamTup& outParams, ArgTup& args)
-{
-    constexpr auto size = Size_v<OutParams>;
-    static_assert(size == std::tuple_size_v<OutParamTup>);
-    Detail::CopyOutImpl<OutParams>(outParams, args,
-                                   std::make_index_sequence<size>{});
-}
-
-template <typename T>
-using SimpleTensor = DemoEval::Tensor<
-    T, Demo::Layout<Demo::FixedRankExtents<std::size_t, 1>>>;
-
-template <typename ExprMaker, typename... Args,
-          typename = std::enable_if_t<
-              std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
-void DoElementwise(const ExprMaker& maker, Args&&... args)
-{
-    auto expr = maker.template Get<SimpleTensor>();
-    using Expr = typename decltype(expr)::Type;
-    static_assert(
-        !Expr::hasData,
-        "This expression template is not supposed to contain data");
-
-    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
-
-    using Params = Params_t<Expr>;
-    using InParams = InParams_t<Expr>;
-    using OutParams = OutParams_t<Expr>;
-
-    // tuple of values
-    auto params = PrepareParams<Params>(argTuple);
-
-    // tuple of references
-    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
-
-    // tuple of values
-    using LocalVars = LocalVars_t<Expr>;
-    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
-
-    // tuple of references
-    auto inParams = GetInParams<Params>(params);
-    auto outParams = GetOutParams<Params>(params);
-
-    CopyIn<InParams>(inParams, argTuple);
-    Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
-    CopyOut<OutParams>(outParams, argTuple);
-
-    Util::ForEach(params, [](auto& arg) {
-        if constexpr (Util::HasClear_v<decltype(arg)>) {
-            arg.Clear();
-        }
-    });
-    Util::ForEach(localVars, [](auto& arg) {
-        if constexpr (Util::HasClear_v<decltype(arg)>) {
-            arg.Clear();
-        }
-    });
-}
-
-} // namespace Emulation
-
-namespace BlockEmulation {
-
-using namespace Demo;
-using namespace DemoEval;
-
-namespace Detail {
-
-template <typename ParamType, typename... Arg>
-constexpr auto ConstructParam(Arg... arg)
-{
-    // decay_t is very important here.  If ParamType::Type were a
-    // reference type and decaying did not happen, the expression below
-    // would become a reinterpret_cast: disasters would follow then.
-    return typename std::decay_t<typename ParamType::Type>(arg...);
-}
-
-template <typename Params, std::size_t... Ints, typename... Arg>
-constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
-{
-    return std::make_tuple(
-        ConstructParam<
-            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
-            arg...)...);
-}
-
-template <typename Params, std::size_t Index, typename ParamTup,
-          typename ArgTup>
-constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
-{
-    constexpr auto pos =
-        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
-    if constexpr (pos < Util::TMP::Size_v<Params>) {
-        return std::get<pos>(params);
-    } else {
-        return std::get<Index>(args);
-    }
-}
-
-template <typename Params, typename ParamTup, typename ArgTup,
-          std::size_t... Ints>
-constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
-                     std::index_sequence<Ints...>)
-{
-    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
-}
-
-template <typename Params, std::size_t Index, ParamUsage... usages,
-          typename ParamTup>
-constexpr auto GetOneParam(ParamTup& params)
-{
-    using Param = Util::TMP::Get_t<Params, Index>;
-    if constexpr (((Param::usage == usages) || ...)) {
-        return std::forward_as_tuple(std::get<Index>(params));
-    } else {
-        return std::tuple<>{};
-    }
-}
-
-template <typename Params, typename ParamTup, std::size_t... Ints>
-constexpr auto GetInParamsImpl(ParamTup& params,
-                               std::index_sequence<Ints...>)
-{
-    return std::tuple_cat(
-        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
-            params)...);
-}
-
-template <typename Params, typename ParamTup, std::size_t... Ints>
-constexpr auto GetOutParamsImpl(ParamTup& params,
-                                std::index_sequence<Ints...>)
-{
-    return std::tuple_cat(
-        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
-            params)...);
-}
-
-template <typename InParams, std::size_t Index, typename T, typename ArgTup>
-void CopyInOneParam(T& param, ArgTup& args, std::size_t len)
-{
-    using Param = Util::TMP::Get_t<InParams, Index>;
-    if constexpr (Util::IsSpecializationOf_v<
-                      Tensor, std::decay_t<typename Param::Type>>) {
-        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
-        if constexpr (Util::IsSpecializationOf_v<
-                          GlobalTensor, std::decay_t<SourceType>>) {
-            std::get<Param::number - 1>(args).CopyTo(param, len);
-        } else {
-            static_assert(Util::AlwaysFalse_v<T>,
-                          "I do not know how to copy in on this type");
-        }
-    }
-}
-
-template <typename InParams, typename InParamTup, typename ArgTup,
-          std::size_t... Ints>
-void CopyInImpl(InParamTup& inParams, ArgTup& args, std::size_t len,
-                std::index_sequence<Ints...>)
-{
-    (CopyInOneParam<InParams, Ints>(std::get<Ints>(inParams), args, len),
-     ...);
-}
-
-template <typename OutParams, std::size_t Index, typename T,
-          typename ArgTup>
-void CopyOutOneParam(T& param, ArgTup& args, std::size_t len)
-{
-    using Param = Util::TMP::Get_t<OutParams, Index>;
-    if constexpr (Util::IsSpecializationOf_v<
-                      Tensor, std::decay_t<typename Param::Type>>) {
-        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
-        if constexpr (Util::IsSpecializationOf_v<
-                          GlobalTensor, std::decay_t<SourceType>>) {
-            std::get<Param::number - 1>(args).CopyFrom(param, len);
-        } else {
-            static_assert(Util::AlwaysFalse_v<T>,
-                          "I do not know how to copy out on this type");
-        }
-    }
-}
-
-template <typename OutParams, typename OutParamTup, typename ArgTup,
-          std::size_t... Ints>
-void CopyOutImpl(OutParamTup& outParams, ArgTup& args, std::size_t len,
-                 std::index_sequence<Ints...>)
-{
-    (CopyOutOneParam<OutParams, Ints>(std::get<Ints>(outParams), args, len),
-     ...);
-}
-
-} // namespace Detail
-
-template <typename Params, typename... Arg>
-auto PrepareParams(Arg... arg)
-{
-    return Detail::PrepareParamsImpl<Params>(
-        std::make_index_sequence<Size_v<Params>>{}, arg...);
-}
-
-template <typename Params, typename ParamTup, typename ArgTup>
-auto ConvertArgs(ParamTup& params, ArgTup& args)
-{
-    return Detail::ConvertArgsImpl<Params>(
-        params, args,
-        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
-}
-
-template <typename LocalVars, typename ArgTup>
-auto PrepareLocalVars(ArgTup& args)
-{
-    auto localVars = GetLocalVarTuple<LocalVars>();
-    MakeAlikeLocalVars<LocalVars>(localVars, args);
-    return localVars;
-}
-
-template <typename Params, typename ParamTup>
-auto GetInParams(ParamTup& params)
-{
-    constexpr auto size = Size_v<Params>;
-    static_assert(size == std::tuple_size_v<ParamTup>);
-    return Detail::GetInParamsImpl<Params>(
-        params, std::make_index_sequence<size>{});
-}
-
-template <typename Params, typename ParamTup>
-auto GetOutParams(ParamTup& params)
-{
-    constexpr auto size = Size_v<Params>;
-    static_assert(size == std::tuple_size_v<ParamTup>);
-    return Detail::GetOutParamsImpl<Params>(
-        params, std::make_index_sequence<size>{});
-}
-
-template <typename InParams, typename InParamTup, typename ArgTup>
-void CopyIn(InParamTup& inParams, ArgTup& args, std::size_t len)
-{
-    constexpr auto size = Size_v<InParams>;
-    static_assert(Size_v<InParams> == std::tuple_size_v<InParamTup>);
-    Detail::CopyInImpl<InParams>(inParams, args, len,
-                                 std::make_index_sequence<size>{});
-}
-
-template <typename OutParams, typename OutParamTup, typename ArgTup>
-void CopyOut(OutParamTup& outParams, ArgTup& args, std::size_t len)
-{
-    constexpr auto size = Size_v<OutParams>;
-    static_assert(size == std::tuple_size_v<OutParamTup>);
-    Detail::CopyOutImpl<OutParams>(outParams, args, len,
-                                   std::make_index_sequence<size>{});
-}
-
-constexpr std::size_t blockSize = 32;
-
-template <typename T>
-using BlockTensor =
-    DemoEval::Tensor<T, Layout<FixedRankExtents<std::size_t, 1>>>;
-
-template <typename T>
-using SimpleTensor = DemoEval::Tensor<T>;
-
-template <typename ExprMaker, typename... Args,
-          typename = std::enable_if_t<
-              std::is_base_of_v<ExprTmpl::Maker, ExprMaker>>>
-void DoElementwise(const ExprMaker& maker, Args&&... args)
-{
-    auto expr = maker.template Get<BlockTensor>();
-    using Expr = typename decltype(expr)::Type;
-    static_assert(
-        !Expr::hasData,
-        "This expression template is not supposed to contain data");
-
-    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
-
-    using Params = Params_t<Expr>;
-    using InParams = InParams_t<Expr>;
-    using OutParams = OutParams_t<Expr>;
-
-    // tuple of values
-    auto params = PrepareParams<Params>(blockSize);
-
-    // tuple of references
-    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
-
-    // tuple of values
-    using LocalVars = LocalVars_t<Expr>;
-    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
-
-    // tuple of references
-    auto inParams = GetInParams<Params>(params);
-    auto outParams = GetOutParams<Params>(params);
-
-    static_assert(Util::TMP::Size_v<InParams> != 0);
-    const std::size_t len =
-        std::get<Util::TMP::Get_t<InParams, 0>::number>(argTuple).size();
-    const std::size_t lenWholeBlock = len / blockSize * blockSize;
-    std::size_t i = 0;
-    for (; i < lenWholeBlock; i += blockSize) {
-        CopyIn<InParams>(inParams, argTuple, blockSize);
-        Evaluator<Expr>{}(expr.data, convertedArgs, localVars);
-        CopyOut<OutParams>(outParams, argTuple, blockSize);
-    }
-    if (i < len) {
-        std::size_t sizeTB = len - i;  // tail-block size
-        auto exprTB = maker.template Get<SimpleTensor>();
-        using ExprTB = typename decltype(exprTB)::Type;
-        using ParamsTB = Params_t<ExprTB>;
-        using InParamsTB = InParams_t<ExprTB>;
-        using OutParamsTB = OutParams_t<ExprTB>;
-
-        auto paramsTB = PrepareParams<ParamsTB>();
-        paramsTB = params;  // Reuse allocated Tensor storage
-
-        auto convertedArgsTB = ConvertArgs<ParamsTB>(paramsTB, argTuple);
-
-        using LocalVarsTB = LocalVars_t<ExprTB>;
-        auto localVarsTB = GetLocalVarTuple<LocalVarsTB>();
-        localVarsTB = localVars;  // Reuse allocated Tensor storage
-
-        auto inParamsTB = GetInParams<ParamsTB>(paramsTB);
-        auto outParamsTB = GetOutParams<ParamsTB>(paramsTB);
-
-        CopyIn<InParamsTB>(inParamsTB, argTuple, sizeTB);
-        Evaluator<ExprTB>{}(exprTB.data, convertedArgsTB, localVarsTB);
-        CopyOut<OutParamsTB>(outParamsTB, argTuple, sizeTB);
-    }
-
-    Util::ForEach(params, [](auto& arg) {
-        if constexpr (Util::HasClear_v<decltype(arg)>) {
-            arg.Clear();
-        }
-    });
-    Util::ForEach(localVars, [](auto& arg) {
-        if constexpr (Util::HasClear_v<decltype(arg)>) {
-            arg.Clear();
-        }
-    });
-}
-
-} // namespace BlockEmulation
+#include "util.h" // IWYU pragma: keep
 
 
 /* Test */
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
new file mode 100644
index 000000000..cb27f9795
--- /dev/null
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -0,0 +1,430 @@
+#ifndef EXPR_TMPL_H
+#define EXPR_TMPL_H
+
+/* Expression templates */
+
+#include <cstddef>
+#include <type_traits>
+#include "util.h"
+
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
+// NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTBEGIN(misc-unconventional-assign-operator)
+
+namespace ExprTmpl {
+
+using Util::TMP::TypeList;
+
+template <typename T, typename = void>
+struct HasDataTrait {
+    static constexpr bool value = true;
+};
+
+template <typename T>
+struct HasDataTrait<T, std::void_t<decltype(T::hasData)>> {
+    static constexpr bool value = T::hasData;
+};
+
+// Type for a basic "expression".  If T is trivial (as it should normally
+// be), Expression<T> is trivially copy-constructible and trivially move-
+// constructible, but is not trivially assignable.  Objects of the same
+// Expression type cannot be assigned, because the data member is const.
+// Objects of different Expression types can be assigned, but it will
+// result in a new Expression object (and is not a "normal" assignment).
+template <typename T>
+struct Expression {
+    static_assert(!std::is_rvalue_reference_v<T>,
+                  "Rvalue references cannot be stored");
+    using Type = T;
+    static constexpr bool hasData = HasDataTrait<T>::value;
+
+    T const data{};
+
+    template <typename U>
+    [[nodiscard]] constexpr auto operator=(Expression<U> u);
+};
+
+// Let T deduce to value type or lvalue reference type
+template <typename T>
+Expression(T&& value) -> Expression<T>;
+
+template <typename T>
+using IsExpression = Util::IsSpecializationOf<Expression, T>;
+
+template <typename T>
+inline constexpr bool IsExpression_v = IsExpression<T>::value;
+
+template <std::size_t N, typename T, typename L = void>
+struct LocalVar {
+    static_assert(!std::is_reference_v<T>,
+                  "A LocalVar must not be a reference");
+    using Type = T;
+    using Like = L;
+    static constexpr std::size_t number = N;
+    static constexpr bool hasData = false;
+
+    template <typename V>
+    constexpr auto operator=(Expression<V>)
+    {
+        static_assert(Util::AlwaysFalse_v<V>,
+                      "Please use Expression<LocalVar> for assignment");
+    }
+};
+
+template <typename T>
+struct IsLocalVar : std::false_type {};
+
+template <std::size_t N, typename T, typename L>
+struct IsLocalVar<LocalVar<N, T, L>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsLocalVar_v = IsLocalVar<T>::value;
+
+enum class ParamUsage {
+    in,
+    out,
+    in_out,
+    //temporary,
+};
+
+template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
+struct Param {
+    using Type = T;
+    static constexpr std::size_t number = N;
+    static constexpr ParamUsage usage = U;
+    static constexpr bool hasData = false;
+
+    template <typename V>
+    constexpr auto operator=(Expression<V>)
+    {
+        static_assert(Util::AlwaysFalse_v<V>,
+                      "Please use Expression<Param> for assignment");
+    }
+};
+
+template <typename T>
+struct IsParam : std::false_type {};
+
+template <std::size_t N, typename T, ParamUsage U>
+struct IsParam<Param<N, T, U>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsParam_v = IsParam<T>::value;
+
+template <std::size_t N, typename T>
+constexpr auto DefineLocalVar()
+{
+    return Expression<LocalVar<N, T>>{};
+}
+
+template <std::size_t N, typename L>
+constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
+{
+    static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
+    return Expression<LocalVar<N, typename L::Type, L>>{};
+}
+
+template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
+constexpr auto DefineParam()
+{
+    return Expression<Param<N, T, U>>{};
+}
+
+template <std::size_t N>
+struct CheckVarNum {
+    template <typename T>
+    struct Checker {
+        static constexpr bool value = (T::number == N);
+    };
+};
+
+template <typename T>
+struct UnaryOp : private Util::CompressedData<T> {
+private:
+    using Storage = Util::CompressedData<T>;
+
+public:
+    static_assert(!std::is_rvalue_reference_v<T>,
+                  "Rvalue references cannot be stored");
+    static constexpr bool hasData = HasDataTrait<T>::value;
+    using IsUnaryOp = void;
+    using DataType = T;
+
+    UnaryOp() = default;
+    constexpr UnaryOp(T t) : Storage(t) {}
+
+    constexpr const T& GetData() const { return Storage::Data(); }
+};
+
+template <typename T, typename U>
+struct BinaryOp : private Util::CompressedPair<T, U> {
+private:
+    using Storage = Util::CompressedPair<T, U>;
+
+public:
+    static_assert(!(std::is_rvalue_reference_v<T> ||
+                    std::is_rvalue_reference_v<U>),
+                  "Rvalue references cannot be stored");
+    static constexpr bool hasData =
+        HasDataTrait<T>::value || HasDataTrait<U>::value;
+    using IsBinaryOp = void;
+    using LhsType = T;
+    using RhsType = U;
+
+    BinaryOp() = default;
+    constexpr BinaryOp(T t, U u) : Storage(t, u) {}
+
+    constexpr const T& GetLhs() const { return Storage::First(); }
+    constexpr const U& GetRhs() const { return Storage::Second(); }
+};
+
+namespace Detail {
+
+template <typename T, typename = void>
+struct LocalVarCollector {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::enable_if_t<IsLocalVar_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::void_t<typename T::IsBinaryOp>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename LocalVarCollector<typename T::LhsType>::Type,
+        typename LocalVarCollector<typename T::RhsType>::Type>;
+};
+
+template <typename T, typename = void>
+struct ParamCollector {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct ParamCollector<T, std::enable_if_t<IsParam_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct ParamCollector<T, std::void_t<typename T::IsBinaryOp>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename ParamCollector<typename T::LhsType>::Type,
+        typename ParamCollector<typename T::RhsType>::Type>;
+};
+
+} // namespace Detail
+
+template <typename T>
+struct LocalVars {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::LocalVarCollector<T>::Type>;
+
+private:
+    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
+
+    template <typename U>
+    struct InRange
+        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
+    static_assert(Util::TMP::Check_v<InRange, Type>,
+                  "LocalVars must be numbered sequentially from 1");
+};
+
+template <typename T>
+using LocalVars_t = typename LocalVars<T>::Type;
+
+template <typename T>
+struct Params {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+
+private:
+    static constexpr std::size_t size = Util::TMP::Size_v<Type>;
+
+    template <typename U>
+    struct InRange
+        : std::bool_constant<(U::number > 0 && U::number <= size)> {};
+    static_assert(Util::TMP::Check_v<InRange, Type>,
+                  "Params must be numbered sequentially from 1");
+};
+
+template <typename T>
+using Params_t = typename Params<T>::Type;
+
+template <typename T>
+struct InParams {
+    template <typename U>
+    struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
+                                        U::usage == ParamUsage::in_out> {};
+    using Type = Util::TMP::Filter_t<IsInVar, Params_t<T>>;
+};
+
+template <typename T>
+using InParams_t = typename InParams<T>::Type;
+
+template <typename T>
+struct OutParams {
+    template <typename U>
+    struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
+                                         U::usage == ParamUsage::in_out> {};
+    using Type = Util::TMP::Filter_t<IsOutVar, Params_t<T>>;
+};
+
+template <typename T>
+using OutParams_t = typename OutParams<T>::Type;
+
+template <typename T>
+struct OpCopyInParam : UnaryOp<T> {
+    OpCopyInParam() = default;
+    constexpr OpCopyInParam(T t) : UnaryOp<T>(t) {}
+};
+
+template <typename T>
+[[nodiscard]] constexpr auto CopyIn(Expression<T> t)
+{
+    static_assert(IsParam_v<T>, "Only a Param supports CopyIn");
+    static_assert(
+        T::usage == ParamUsage::in || T::usage == ParamUsage::in_out,
+        "Param usage must be in or in_out");
+    return Expression<OpCopyInParam<T>>{{t.data}};
+}
+
+template <typename T>
+struct OpCopyOutParam : UnaryOp<T> {
+    OpCopyOutParam() = default;
+    constexpr OpCopyOutParam(T t) : UnaryOp<T>(t) {}
+};
+
+template <typename T>
+[[nodiscard]] constexpr auto CopyOut(Expression<T> t)
+{
+    static_assert(IsParam_v<T>, "Only a Param supports CopyOut");
+    static_assert(
+        T::usage == ParamUsage::out || T::usage == ParamUsage::in_out,
+        "Param usage must be out or in_out");
+    return Expression<OpCopyOutParam<T>>{{t.data}};
+}
+
+template <typename T, typename U>
+struct OpAssign : BinaryOp<T, U> {
+    OpAssign() = default;
+    constexpr OpAssign(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T>
+template <typename U>
+[[nodiscard]] constexpr auto Expression<T>::operator=(Expression<U> u)
+{
+    static_assert(
+        (IsParam_v<T> || IsLocalVar_v<T> || std::is_lvalue_reference_v<T>),
+        "Only a Param, LocalVar, or reference can appear on the left side "
+        "of assignment");
+    return Expression<OpAssign<T, U>>{{data, u.data}};
+}
+
+template <typename T, typename U>
+struct OpAndThen : BinaryOp<T, U> {
+    OpAndThen() = default;
+    constexpr OpAndThen(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
+{
+    return Expression<OpAndThen<T, U>>{{t.data, u.data}};
+}
+
+// Disallow dangerous expressions like (Expression{2}, 3)
+template <typename T, typename U>
+constexpr auto operator,(Expression<T>t, U&& u) = delete;
+
+template <typename T, typename U>
+struct OpAdd : BinaryOp<T, U> {
+    OpAdd() = default;
+    constexpr OpAdd(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(Expression<T> lhs, Expression<U> rhs)
+{
+    return Expression<OpAdd<T, U>>{{lhs.data, rhs.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(Expression<T> lhs, U&& rhs)
+{
+    return Expression<OpAdd<T, U>>{{lhs.data, std::forward<U>(rhs)}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator+(T&& lhs, Expression<U> rhs)
+{
+    return Expression<OpAdd<T, U>>{{std::forward<T>(lhs), rhs.data}};
+}
+
+template <typename T, typename U>
+struct OpSubtract : BinaryOp<T, U> {
+    OpSubtract() = default;
+    constexpr OpSubtract(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator-(Expression<T> lhs, Expression<U> rhs)
+{
+    return Expression<OpSubtract<T, U>>{{lhs.data, rhs.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator-(Expression<T> lhs, U&& rhs)
+{
+    return Expression<OpSubtract<T, U>>{{lhs.data, std::forward<U>(rhs)}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator-(T&& lhs, Expression<U> rhs)
+{
+    return Expression<OpSubtract<T, U>>{{std::forward<T>(lhs), rhs.data}};
+}
+
+template <typename T, typename U>
+struct OpCopyInData : BinaryOp<T, U> {
+    OpCopyInData() = default;
+    constexpr OpCopyInData(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+struct OpCopyOutData : BinaryOp<T, U> {
+    OpCopyOutData() = default;
+    constexpr OpCopyOutData(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto CopyInData(Expression<T> dst,
+                                        Expression<U> src)
+{
+    static_assert(IsLocalVar_v<T>,
+                  "Only a LocalVar can be the destination of CopyIn");
+    return Expression<OpCopyInData<T, U>>{{dst.data, src.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto CopyOutData(Expression<T> src,
+                                         Expression<U> dst)
+{
+    static_assert(
+        IsParam_v<U> || std::is_lvalue_reference_v<U>,
+        "Only a Param or reference can be the destination of CopyOut");
+    return Expression<OpCopyOutData<T, U>>{{src.data, dst.data}};
+}
+
+// Base class to express that a class is a maker of calculation expression template
+class Maker {};
+
+} // namespace ExprTmpl
+
+// NOLINTEND(misc-unconventional-assign-operator)
+// NOLINTEND(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
+
+#endif // EXPR_TMPL_H
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
new file mode 100644
index 000000000..86c5535a7
--- /dev/null
+++ b/best_practices/expression_template/util.h
@@ -0,0 +1,505 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+/* Utilities */
+
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace Util {
+
+template <typename T>
+struct AlwaysFalse : std::false_type {};
+
+template <typename T>
+inline constexpr bool AlwaysFalse_v = AlwaysFalse<T>::value;
+
+template <template <typename...> class T, typename U>
+struct IsSpecializationOf : std::false_type {};
+
+template <template <typename...> class T, typename... Us>
+struct IsSpecializationOf<T, T<Us...>> : std::true_type {};
+
+template <template <typename...> class T, typename U>
+inline constexpr bool IsSpecializationOf_v = IsSpecializationOf<T, U>::value;
+
+template <typename T, typename = void>
+struct HasClear : std::false_type {};
+
+template <typename T>
+struct HasClear<T, std::void_t<decltype(std::declval<T&>().Clear())>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool HasClear_v = HasClear<T>::value;
+
+template <
+    typename Tuple, typename Func,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
+                     int> = 0>
+void ForEach(Tuple&& tuple, Func&& func)
+{
+    std::apply(
+        [&func](auto&&... args) {
+            (std::forward<Func>(func)(std::forward<decltype(args)>(args)),
+             ...);
+        },
+        std::forward<Tuple>(tuple));
+}
+
+namespace Detail {
+
+// Storage implementations for different compression scenarios
+template <typename T, bool Compress>
+struct CompressedDataStorage;
+
+// Case 1: Not compressed
+template <typename T>
+struct CompressedDataStorage<T, false> {
+    template <typename U,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
+    explicit CompressedDataStorage(U&& u) : data_(std::forward<U>(u))
+    {
+    }
+
+    CompressedDataStorage() = default;
+
+    T& Data() { return data_; }
+    const T& Data() const { return data_; }
+
+private:
+    T data_;
+};
+
+// Case 2: Compressed
+template <typename T>
+struct CompressedDataStorage<T, true> : private T {
+    template <typename U,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
+    explicit CompressedDataStorage(U&& u) : T(std::forward<U>(u))
+    {
+    }
+
+    CompressedDataStorage() = default;
+
+    T& Data() { return static_cast<T&>(*this); }
+    const T& Data() const { return static_cast<const T&>(*this); }
+};
+
+// Storage implementations for different compression scenarios
+template <typename T1, typename T2, bool CompressFirst, bool CompressSecond>
+struct CompressedPairStorage;
+
+// Case 1: Neither can be compressed
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, false, false> {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : first_(std::forward<U1>(f)), second_(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return first_; }
+    const T1& First() const { return first_; }
+    T2& Second() { return second_; }
+    const T2& Second() const { return second_; }
+
+private:
+    T1 first_;
+    T2 second_;
+};
+
+// Case 2: Only first can be compressed
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, true, false> : private T1 {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : T1(std::forward<U1>(f)), second_(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return static_cast<T1&>(*this); }
+    const T1& First() const { return static_cast<const T1&>(*this); }
+    T2& Second() { return second_; }
+    const T2& Second() const { return second_; }
+
+private:
+    T2 second_;
+};
+
+// Case 3: Only second can be compressed
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, false, true> : private T2 {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : T2(std::forward<U2>(s)), first_(std::forward<U1>(f))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return first_; }
+    const T1& First() const { return first_; }
+    T2& Second() { return static_cast<T2&>(*this); }
+    const T2& Second() const { return static_cast<const T2&>(*this); }
+
+private:
+    T1 first_;
+};
+
+// Case 4: Both can be compressed, different types
+template <typename T1, typename T2>
+struct CompressedPairStorage<T1, T2, true, true> : private T1, private T2 {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&& s)
+        : T1(std::forward<U1>(f)), T2(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T1& First() { return static_cast<T1&>(*this); }
+    const T1& First() const { return static_cast<const T1&>(*this); }
+    T2& Second() { return static_cast<T2&>(*this); }
+    const T2& Second() const { return static_cast<const T2&>(*this); }
+};
+
+// Case 5: Both can be compressed, same type
+template <typename T>
+struct CompressedPairStorage<T, T, true, true> : private T {
+    template <typename U1, typename U2>
+    CompressedPairStorage(U1&& f, U2&&) : T(std::forward<U1>(f))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    T& First() { return static_cast<T&>(*this); }
+    const T& First() const { return static_cast<const T&>(*this); }
+    T& Second() { return static_cast<T&>(*this); }
+    const T& Second() const { return static_cast<const T&>(*this); }
+};
+
+} // namespace Detail
+
+template <typename T>
+class CompressedData : private Detail::CompressedDataStorage<
+                           T, std::is_empty_v<T> && !std::is_final_v<T>> {
+    using Storage = Detail::CompressedDataStorage<
+        T, std::is_empty_v<T> && !std::is_final_v<T>>;
+
+public:
+    using Type = T;
+
+    // Default constructor
+    CompressedData() = default;
+
+    // Perfect forwarding constructor
+    template <typename U,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<U>, CompressedData>>>
+    explicit CompressedData(U&& u) : Storage(std::forward<U>(u))
+    {
+    }
+
+    // Accessors for data
+    T& Data() { return Storage::Data(); }
+    const T& Data() const { return Storage::Data(); }
+
+    // Swap
+    void swap(CompressedData& other) noexcept
+    {
+        using std::swap;
+        swap(Data(), other.Data());
+    }
+};
+
+// Swap function
+template <typename T>
+void swap(CompressedData<T>& lhs, CompressedData<T>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+// Equality comparison operators
+template <typename T>
+bool operator==(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
+{
+    return lhs.Data() == rhs.Data();
+}
+
+template <typename T>
+bool operator!=(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template <typename T1, typename T2>
+class CompressedPair
+    : private Detail::CompressedPairStorage<
+          T1, T2,
+          std::is_empty_v<T1> && !std::is_final_v<T1>,
+          std::is_empty_v<T2> && !std::is_final_v<T2>> {
+    using Storage = Detail::CompressedPairStorage<
+        T1, T2,
+        std::is_empty_v<T1> && !std::is_final_v<T1>,
+        std::is_empty_v<T2> && !std::is_final_v<T2>>;
+
+public:
+    using FirstType = T1;
+    using SecondType = T2;
+
+    // Default constructor
+    CompressedPair() = default;
+
+    // Perfect forwarding constructor
+    template<typename U1, typename U2>
+    CompressedPair(U1&& f, U2&& s)
+        : Storage(std::forward<U1>(f), std::forward<U2>(s)) {}
+
+    // Accessors for first element
+    T1& First() { return Storage::First(); }
+    const T1& First() const { return Storage::First(); }
+
+    // Accessors for second element
+    T2& Second() { return Storage::Second(); }
+    const T2& Second() const { return Storage::Second(); }
+
+    // Swap
+    void swap(CompressedPair& other) noexcept
+    {
+        using std::swap;
+        swap(First(), other.First());
+        swap(Second(), other.Second());
+    }
+};
+
+// Deduction guide
+template <typename T1, typename T2>
+CompressedPair(T1&& f, T2&& s)
+    -> CompressedPair<std::decay_t<T1>, std::decay_t<T2>>;
+
+// Swap function
+template <typename T1, typename T2>
+void swap(CompressedPair<T1, T2>& lhs, CompressedPair<T1, T2>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+// Equality comparison operators
+template <typename T1, typename T2>
+bool operator==(const CompressedPair<T1, T2>& lhs,
+                const CompressedPair<T1, T2>& rhs)
+{
+    return lhs.First() == rhs.First() && lhs.Second() == rhs.Second();
+}
+
+template <typename T1, typename T2>
+bool operator!=(const CompressedPair<T1, T2>& lhs,
+                const CompressedPair<T1, T2>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+namespace TMP {
+
+template <typename... Ts>
+struct TypeList {};
+
+template <typename List>
+struct First;
+
+template <typename Head, typename... Tail>
+struct First<TypeList<Head, Tail...>> {
+    using Type = Head;
+};
+
+template <typename List>
+using First_t = typename First<List>::Type;
+
+template <typename List>
+struct Size;
+
+template <typename... Ts>
+struct Size<TypeList<Ts...>> {
+    static constexpr std::size_t value = sizeof...(Ts);
+};
+
+template <typename List>
+inline constexpr std::size_t Size_v = Size<List>::value;
+
+template <typename T, typename List>
+struct Prepend;
+
+template <typename T, typename... Ts>
+struct Prepend<T, TypeList<Ts...>> {
+    using Type = TypeList<T, Ts...>;
+};
+
+template <typename T, typename List>
+using Prepend_t = typename Prepend<T, List>::Type;
+
+template <typename... Lists>
+struct Concatenate;
+
+template <>
+struct Concatenate<> {
+    using Type = TypeList<>;
+};
+
+template <typename... Ts>
+struct Concatenate<TypeList<Ts...>> {
+    using Type = TypeList<Ts...>;
+};
+
+template <typename... Ts, typename... Us>
+struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
+    using Type = TypeList<Ts..., Us...>;
+};
+
+template <typename List1, typename List2, typename List3, typename... Lists>
+struct Concatenate<List1, List2, List3, Lists...> {
+    using Type =
+        typename Concatenate<typename Concatenate<List1, List2>::Type,
+                             List3, Lists...>::Type;
+};
+
+template <typename... Lists>
+using Concatenate_t = typename Concatenate<Lists...>::Type;
+
+template <template <typename> class Pred, typename List>
+struct Check;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Check<Pred, TypeList<Head, Tail...>> {
+    static constexpr bool value =
+        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
+};
+
+template <template <typename> class Pred>
+struct Check<Pred, TypeList<>> {
+    static constexpr bool value = true;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr bool Check_v = Check<Pred, List>::value;
+
+template <template <typename> class Pred, typename List>
+struct Filter;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Filter<Pred, TypeList<Head, Tail...>> {
+    using Type = typename std::conditional_t<
+        Pred<Head>::value,
+        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
+        typename Filter<Pred, TypeList<Tail...>>::Type>;
+};
+
+template <template <typename> class Pred>
+struct Filter<Pred, TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <template <typename> class Pred, typename List>
+using Filter_t = typename Filter<Pred, List>::Type;
+
+template <template <typename> class Pred, typename List, typename = void>
+struct Find;
+
+template <template <typename> class Pred>
+struct Find<Pred, TypeList<>> {
+    static constexpr std::size_t value = 0;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<Pred<Head>::value>> {
+    static constexpr std::size_t value = 0;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct Find<Pred, TypeList<Head, Tail...>,
+            std::enable_if_t<!Pred<Head>::value>> {
+    static constexpr std::size_t value =
+        Find<Pred, TypeList<Tail...>>::value + 1;
+};
+
+template <template <typename> class Pred, typename List>
+inline constexpr std::size_t Find_v = Find<Pred, List>::value;
+
+template <typename List, std::size_t N>
+struct Get;
+
+template <typename Head, typename... Tail, std::size_t N>
+struct Get<TypeList<Head, Tail...>, N> {
+    using Type = typename Get<TypeList<Tail...>, N - 1>::Type;
+};
+
+template <typename Head, typename... Tail>
+struct Get<TypeList<Head, Tail...>, 0> {
+    using Type = Head;
+};
+
+template <std::size_t N>
+struct Get<TypeList<>, N> {
+    static_assert(N < 0, "Index out of bounds in Get");
+};
+
+template <typename List, std::size_t N>
+using Get_t = typename Get<List, N>::Type;
+
+template <typename List>
+struct Unique;
+
+template <typename Head, typename... Tail>
+struct Unique<TypeList<Head, Tail...>> {
+    template <typename T>
+    struct IsNotHead : std::bool_constant<!std::is_same_v<T, Head>> {};
+
+    using Type = Prepend_t<
+        Head,
+        typename Unique<Filter_t<IsNotHead, TypeList<Tail...>>>::Type>;
+};
+
+template <>
+struct Unique<TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <typename List>
+using Unique_t = typename Unique<List>::Type;
+
+template <template <typename> class Pred, typename List>
+struct FindUnique {
+    using ResultList = Filter_t<Pred, List>;
+    static_assert(Size_v<ResultList> != 0, "Cannot find the specified element");
+    static_assert(Size_v<ResultList> == 1, "A unique result is expected");
+    using Type = First_t<ResultList>;
+};
+
+template <template <typename> class Pred, typename List>
+using FindUnique_t = typename FindUnique<Pred, List>::Type;
+
+} // namespace TMP
+
+} // namespace Util
+
+
+// For testing only
+
+template <typename T>
+struct type_displayer;
+
+#define CONCAT(x, y) x ## y
+#define PASTE(x, y) CONCAT(x, y)
+#define TYPE_DISPLAY(x) type_displayer<decltype(x)> PASTE(type_, __LINE__)
+
+#endif // UTIL_H
-- 
Gitee


From ecb72744d67a2e02c4f095e70e13619efaf4178e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 18:05:15 +0800
Subject: [PATCH 057/116] Prepare for BlockEmulation2

---
 .../{block_emulation.h => block_emulation1.h}        | 12 ++++++------
 .../expression_template/expr_template_demo.cpp       |  7 ++-----
 2 files changed, 8 insertions(+), 11 deletions(-)
 rename best_practices/expression_template/{block_emulation.h => block_emulation1.h} (98%)

diff --git a/best_practices/expression_template/block_emulation.h b/best_practices/expression_template/block_emulation1.h
similarity index 98%
rename from best_practices/expression_template/block_emulation.h
rename to best_practices/expression_template/block_emulation1.h
index 98fc5f551..5043c16bd 100644
--- a/best_practices/expression_template/block_emulation.h
+++ b/best_practices/expression_template/block_emulation1.h
@@ -1,7 +1,7 @@
-#ifndef BLOCK_EMULATION_H
-#define BLOCK_EMULATION_H
+#ifndef BLOCK_EMULATION1_H
+#define BLOCK_EMULATION1_H
 
-/* Block Emulation */
+/* Block Emulation 1 */
 
 #include <cstddef>
 #include <tuple>
@@ -13,7 +13,7 @@
 #include "tensor.h"
 #include "util.h"
 
-namespace BlockEmulation {
+namespace BlockEmulation1 {
 
 using namespace Demo;
 using namespace DemoEval;
@@ -290,6 +290,6 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     });
 }
 
-} // namespace BlockEmulation
+} // namespace BlockEmulation1
 
-#endif // BLOCK_EMULATION_H
+#endif // BLOCK_EMULATION1_H
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index e163788bc..5782a9040 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -3,7 +3,7 @@
 #include <iostream>
 #include <type_traits>
 #include <vector>
-#include "block_emulation.h"
+#include "block_emulation1.h"
 #include "demo_eval.h"
 #include "emulation.h"
 #include "expr_tmpl.h"
@@ -11,9 +11,6 @@
 #include "tensor.h"
 #include "util.h" // IWYU pragma: keep
 
-
-/* Test */
-
 template <typename T>
 struct MyAddOp : ExprTmpl::Maker {
     template <template <typename> class VectorType>
@@ -129,7 +126,7 @@ int main() // NOLINT(bugprone-exception-escape)
     GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
     GlobalTensor<float> t4(v4.data(), 300, make_layout(300));
     GlobalTensor<float> t5(v5.data(), 300, make_layout(300));
-    BlockEmulation::DoElementwise(MyAddOp<float>{}, t1, t2, t3, t4, t5);
+    BlockEmulation1::DoElementwise(MyAddOp<float>{}, t1, t2, t3, t4, t5);
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
 }
-- 
Gitee


From e56c520c696e3d9efd6dce1bfa8782276e4d6966 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 22 Oct 2025 20:47:05 +0800
Subject: [PATCH 058/116] Add code that demos manual CopyIn/CopyOut

---
 .../expression_template/block_emulation1.h    |   6 +-
 .../expression_template/block_emulation2.h    | 607 ++++++++++++++++++
 .../expr_template_demo.cpp                    |  38 +-
 3 files changed, 642 insertions(+), 9 deletions(-)
 create mode 100644 best_practices/expression_template/block_emulation2.h

diff --git a/best_practices/expression_template/block_emulation1.h b/best_practices/expression_template/block_emulation1.h
index 5043c16bd..2b54dbd50 100644
--- a/best_practices/expression_template/block_emulation1.h
+++ b/best_practices/expression_template/block_emulation1.h
@@ -203,14 +203,14 @@ void CopyOut(OutParamTup& outParams, ArgTup& args, std::size_t len)
                                    std::make_index_sequence<size>{});
 }
 
-constexpr std::size_t blockSize = 32;
+constexpr std::size_t blockSize = 32; // Demo only
 
 template <typename T>
 using BlockTensor =
-    DemoEval::Tensor<T, Layout<FixedRankExtents<std::size_t, 1>>>;
+    Demo::Tensor<T, Layout<FixedRankExtents<std::size_t, 1>>>;
 
 template <typename T>
-using SimpleTensor = DemoEval::Tensor<T>;
+using SimpleTensor = Demo::Tensor<T>;
 
 template <typename ExprMaker, typename... Args,
           typename = std::enable_if_t<
diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
new file mode 100644
index 000000000..ba0e1f814
--- /dev/null
+++ b/best_practices/expression_template/block_emulation2.h
@@ -0,0 +1,607 @@
+#ifndef BLOCK_EMULATION2_H
+#define BLOCK_EMULATION2_H
+
+/* Block Emulation 2 */
+
+#include <cstddef>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "expr_tmpl.h"
+#include "layout.h"
+#include "tensor.h"
+#include "util.h"
+
+namespace BlockEmulation2 {
+
+using namespace Demo;
+using namespace ExprTmpl;
+
+using Util::TMP::FindUnique_t;
+using Util::TMP::Size_v;
+
+// Primary template
+template <typename T>
+struct Evaluator {
+    using Type = T;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    decltype(auto) operator()(const T& value,
+                              OrgArgTup& /*orgArgs*/,
+                              ConvArgTup& /*convArgs*/,
+                              LocalVarTup& /*localVars*/,
+                              std::size_t /*size*/) const
+    {
+        return value;
+    }
+};
+
+template <std::size_t N, typename T>
+constexpr auto DefineAutoLocalVar(const Expression<T>& /*expr*/)
+{
+    using ResultType = typename Evaluator<T>::Type;
+    return Expression<LocalVar<N, ResultType>>{};
+}
+
+namespace Detail {
+
+template <typename Params, std::size_t... Ints>
+constexpr auto GetParamTupleImpl(std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              Params>::Type{}...);
+}
+
+template <typename LocalVars, std::size_t... Ints>
+constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
+{
+    return std::make_tuple(
+        typename FindUnique_t<CheckVarNum<Ints + 1>::template Checker,
+                              LocalVars>::Type{}...);
+}
+
+template <typename T>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename T, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<T, L>& src)
+{
+    dst.SetSize(src.GetSize());
+}
+
+template <typename L, typename T, typename ArgTup>
+void MakeAlikeOneLocalVar(T& localVar, const ArgTup& args)
+{
+    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
+    if constexpr (!std::is_same_v<typename L::Like, void>) {
+        MakeAlikeDatum(localVar, std::get<L::Like::number>(args));
+    }
+}
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup,
+          std::size_t... Ints>
+void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
+                            std::index_sequence<Ints...>)
+{
+    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
+         std::get<Ints>(localVars), args),
+     ...);
+}
+
+} // namespace Detail
+
+template <typename Params>
+constexpr auto GetParamTuple()
+{
+    constexpr auto paramCount = Size_v<Params>;
+    return Detail::GetParamTupleImpl<Params>(
+        std::make_index_sequence<paramCount>{});
+};
+
+template <typename LocalVars>
+constexpr auto GetLocalVarTuple()
+{
+    constexpr auto localVarCount = Size_v<LocalVars>;
+    return Detail::GetLocalVarTupleImpl<LocalVars>(
+        std::make_index_sequence<localVarCount>{});
+};
+
+template <typename LocalVars, typename LocalVarTup, typename ArgTup>
+void MakeAlikeLocalVars(LocalVarTup& localVars, const ArgTup& args)
+{
+    Detail::MakeAlikeLocalVarsImpl<LocalVars>(
+        localVars, args,
+        std::make_index_sequence<std::tuple_size_v<LocalVarTup>>{});
+}
+
+namespace Detail {
+
+template <typename ParamType, typename... Arg>
+constexpr auto ConstructParam(Arg... arg)
+{
+    // decay_t is very important here.  If ParamType::Type were a
+    // reference type and decaying did not happen, the expression below
+    // would become a reinterpret_cast: disasters would follow then.
+    return typename std::decay_t<typename ParamType::Type>(arg...);
+}
+
+template <typename Params, std::size_t... Ints, typename... Arg>
+constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
+{
+    return std::make_tuple(
+        ConstructParam<
+            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
+            arg...)...);
+}
+
+template <typename Params, std::size_t Index, typename ParamTup,
+          typename ArgTup>
+constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
+{
+    constexpr auto pos =
+        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
+    if constexpr (pos < Util::TMP::Size_v<Params>) {
+        return std::get<pos>(params);
+    } else {
+        return std::get<Index>(args);
+    }
+}
+
+template <typename Params, typename ParamTup, typename ArgTup,
+          std::size_t... Ints>
+constexpr auto ConvertArgsImpl(ParamTup& params, ArgTup& args,
+                               std::index_sequence<Ints...>)
+{
+    return std::make_tuple(ConvertOneArg<Params, Ints>(params, args)...);
+}
+
+template <typename Params, std::size_t Index, ParamUsage... usages,
+          typename ParamTup>
+constexpr auto GetOneParam(ParamTup& params)
+{
+    using Param = Util::TMP::Get_t<Params, Index>;
+    if constexpr (((Param::usage == usages) || ...)) {
+        return std::forward_as_tuple(std::get<Index>(params));
+    } else {
+        return std::tuple<>{};
+    }
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetInParamsImpl(ParamTup& params,
+                               std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::in, ParamUsage::in_out>(
+            params)...);
+}
+
+template <typename Params, typename ParamTup, std::size_t... Ints>
+constexpr auto GetOutParamsImpl(ParamTup& params,
+                                std::index_sequence<Ints...>)
+{
+    return std::tuple_cat(
+        GetOneParam<Params, Ints, ParamUsage::out, ParamUsage::in_out>(
+            params)...);
+}
+
+} // namespace Detail
+
+template <typename Params, typename... Arg>
+auto PrepareParams(Arg... arg)
+{
+    return Detail::PrepareParamsImpl<Params>(
+        std::make_index_sequence<Size_v<Params>>{}, arg...);
+}
+
+template <typename Params, typename ParamTup, typename ArgTup>
+auto ConvertArgs(ParamTup& params, ArgTup& args)
+{
+    return Detail::ConvertArgsImpl<Params>(
+        params, args,
+        std::make_index_sequence<std::tuple_size_v<ArgTup>>{});
+}
+
+template <typename LocalVars, typename ArgTup>
+auto PrepareLocalVars(ArgTup& args)
+{
+    auto localVars = GetLocalVarTuple<LocalVars>();
+    MakeAlikeLocalVars<LocalVars>(localVars, args);
+    return localVars;
+}
+
+template <typename Params, typename ParamTup>
+auto GetInParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetInParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+template <typename Params, typename ParamTup>
+auto GetOutParams(ParamTup& params)
+{
+    constexpr auto size = Size_v<Params>;
+    static_assert(size == std::tuple_size_v<ParamTup>);
+    return Detail::GetOutParamsImpl<Params>(
+        params, std::make_index_sequence<size>{});
+}
+
+
+template <typename Param, typename T, typename ArgTup>
+void CopyInParam(T& param, ArgTup& args, std::size_t len)
+{
+    if constexpr (Util::IsSpecializationOf_v<
+                      Tensor, std::decay_t<typename Param::Type>>) {
+        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
+        if constexpr (Util::IsSpecializationOf_v<
+                          GlobalTensor, std::decay_t<SourceType>>) {
+            std::get<Param::number - 1>(args).CopyTo(param, len);
+        } else {
+            static_assert(Util::AlwaysFalse_v<T>,
+                          "I do not know how to copy in on this type");
+        }
+    }
+}
+
+template <typename Param, typename T, typename ArgTup>
+void CopyOutParam(T& param, ArgTup& args, std::size_t len)
+{
+    if constexpr (Util::IsSpecializationOf_v<
+                      Tensor, std::decay_t<typename Param::Type>>) {
+        using SourceType = std::tuple_element_t<Param::number - 1, ArgTup>;
+        if constexpr (Util::IsSpecializationOf_v<
+                          GlobalTensor, std::decay_t<SourceType>>) {
+            std::get<Param::number - 1>(args).CopyFrom(param, len);
+        } else {
+            static_assert(Util::AlwaysFalse_v<T>,
+                          "I do not know how to copy out on this type");
+        }
+    }
+}
+
+// Treat Evaluator<Expression<T>> as Evaluator<T>
+template <typename T>
+struct Evaluator<Expression<T>> : Evaluator<T> {};
+
+// Partial specialization for LocalVar
+template <std::size_t N, typename T, typename L>
+struct Evaluator<LocalVar<N, T, L>> {
+    using Type = T&;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              OrgArgTup& /*orgArgs*/,
+                              ConvArgTup& /*convArgs*/,
+                              LocalVarTup& localVars,
+                              std::size_t /*size*/) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return std::get<N - 1>(localVars);
+    }
+};
+
+// Partial specialization for Param
+template <std::size_t N, typename T, ParamUsage U>
+struct Evaluator<Param<N, T, U>> {
+    using Type = T;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+                              OrgArgTup& /*orgArgs*/,
+                              ConvArgTup& convArgs,
+                              LocalVarTup& /*localVars*/,
+                              std::size_t /*size*/) const
+    {
+        static_assert(N > 0, "Param number starts from 1");
+        constexpr auto index = N - 1;
+        using NthType =
+            std::tuple_element_t<index, std::remove_reference_t<ConvArgTup>>;
+        if constexpr (std::is_same_v<T, NthType> ||
+                      std::is_same_v<T&, NthType> ||
+                      std::is_same_v<T&&, NthType>) {
+            return std::get<index>(convArgs);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(std::get<index>(convArgs));
+        }
+    }
+};
+
+template <typename T, typename U>
+void Assign(T& dst, const U& src)
+{
+    dst = src;
+}
+
+// Partial specializtion for E_y = E_x
+template <typename T, typename U>
+struct Evaluator<OpAssign<T, U>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, U>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        return Assign(
+            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
+            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
+    }
+};
+
+// Partial specializtion for E_x, E_y
+template <typename T, typename U>
+struct Evaluator<OpAndThen<T, U>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    auto operator()(const OpAndThen<T, U>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        // operator, evaluates sequentially
+        return Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
+               Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size);
+    }
+};
+
+template <typename T, typename U>
+auto Add(const T& src1, const U& src2)
+{
+    return src1 + src2;
+}
+
+template <typename T, typename U>
+auto Subtract(const T& src1, const U& src2)
+{
+    return src1 - src2;
+}
+
+template <typename T, typename U, typename V>
+void AddAssign(T& dst, const U& src1, const V& src2)
+{
+    dst = src1 + src2;
+}
+
+template <typename T>
+void AddAssign(std::vector<T>& dst,
+               const std::vector<T>& src1,
+               const std::vector<T>& src2)
+{
+    if (src1.size() != src2.size()) {
+        throw std::logic_error("vector sizes do not match");
+    }
+    if (src1.size() != dst.size()) {
+        throw std::logic_error("Destination vector should be like source");
+    }
+    for (std::size_t i = 0, size = dst.size(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+template <typename T, typename L>
+void AddAssign(Tensor<T, L>& dst,
+               const Tensor<T, L>& src1,
+               const Tensor<T, L>& src2)
+{
+    if (src1.GetSize() != src2.GetSize()) {
+        throw std::logic_error("Tensor sizes do not match");
+    }
+    if (src1.GetSize() != dst.GetSize()) {
+        throw std::logic_error("Destination tensor should be like source");
+    }
+    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+        dst[i] = src1[i] + src2[i];
+    }
+}
+
+template <typename T>
+void CopyIn(Tensor<T>& dst, const Tensor<T>& src)
+{
+    if (src.GetSize() > dst.GetSize()) {
+        throw std::logic_error("Source tensor is too big");
+    }
+    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
+        dst[i] = src[i];
+    }
+}
+
+template <typename T>
+void CopyOut(const Tensor<T>& src, Tensor<T>& dst)
+{
+    if (dst.GetSize() < src.GetSize()) {
+        throw std::logic_error("Destination tensor is too small");
+    }
+    for (std::size_t i = 0, size = src.GetSize(); i != size; ++i) {
+        dst[i] = src[i];
+    }
+}
+
+// Partial specializtion for E_x + E_y
+template <typename T, typename U>
+struct Evaluator<OpAdd<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    auto operator()(const OpAdd<T, U>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        return Add(
+            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
+            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars,
+                           size));
+    }
+};
+
+// Partial specializtion for E_x - E_y
+template <typename T, typename U>
+struct Evaluator<OpSubtract<T, U>> {
+    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
+                              std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    auto operator()(const OpSubtract<T, U>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        return Subtract(
+            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
+            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars,
+                           size));
+    }
+};
+
+// Partial specializtion for E_z = E_x + E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        return AddAssign(
+            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
+            Evaluator<U>{}(op.GetRhs().GetLhs(), orgArgs, convArgs,
+                           localVars, size),
+            Evaluator<V>{}(op.GetRhs().GetRhs(), orgArgs, convArgs,
+                           localVars, size));
+    }
+};
+
+// Partial specialization for CopyIn(E)
+template <typename T>
+struct Evaluator<OpCopyInParam<T>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    void operator()(const OpCopyInParam<T>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
+                                   localVars, size);
+        CopyInParam<T>(obj, orgArgs, size);
+    }
+};
+
+// Partial specialization for CopyOut(E)
+template <typename T>
+struct Evaluator<OpCopyOutParam<T>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    void operator()(const OpCopyOutParam<T>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
+                                   localVars, size);
+        CopyOutParam<T>(obj, orgArgs, size);
+    }
+};
+
+constexpr std::size_t blockSize = 32; // Demo only
+
+template <typename T>
+using BlockTensor =
+    Demo::Tensor<T, Layout<FixedRankExtents<std::size_t, 1>>>;
+
+template <typename T>
+using SimpleTensor = Demo::Tensor<T>;
+
+template <typename ExprMaker, typename... Args>
+void DoElementwise(const ExprMaker& maker, Args&&... args)
+{
+    auto expr = maker.template Get<BlockTensor>();
+    using Expr = typename decltype(expr)::Type;
+    static_assert(
+        !Expr::hasData,
+        "This expression template is not supposed to contain data");
+
+    auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
+
+    using Params = Params_t<Expr>;
+    using InParams = InParams_t<Expr>;
+
+    // tuple of values
+    auto params = PrepareParams<Params>(blockSize);
+
+    // tuple of references
+    auto convertedArgs = ConvertArgs<Params>(params, argTuple);
+
+    // tuple of values
+    using LocalVars = LocalVars_t<Expr>;
+    auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
+
+    static_assert(Util::TMP::Size_v<InParams> != 0);
+    const std::size_t len =
+        std::get<Util::TMP::Get_t<InParams, 0>::number>(argTuple).size();
+    const std::size_t lenWholeBlock = len / blockSize * blockSize;
+    std::size_t i = 0;
+    for (; i < lenWholeBlock; i += blockSize) {
+        Evaluator<Expr>{}(expr.data, argTuple, convertedArgs, localVars,
+                          blockSize);
+    }
+    if (i < len) {
+        std::size_t sizeTB = len - i;  // tail-block size
+        auto exprTB = maker.template Get<SimpleTensor>();
+        using ExprTB = typename decltype(exprTB)::Type;
+        using ParamsTB = Params_t<ExprTB>;
+
+        auto paramsTB = PrepareParams<ParamsTB>();
+        paramsTB = params;  // Reuse allocated Tensor storage
+
+        auto convertedArgsTB = ConvertArgs<ParamsTB>(paramsTB, argTuple);
+
+        using LocalVarsTB = LocalVars_t<ExprTB>;
+        auto localVarsTB = GetLocalVarTuple<LocalVarsTB>();
+        localVarsTB = localVars;  // Reuse allocated Tensor storage
+
+
+        Evaluator<ExprTB>{}(exprTB.data, argTuple, convertedArgsTB,
+                            localVarsTB, sizeTB);
+    }
+
+    Util::ForEach(params, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+    Util::ForEach(localVars, [](auto& arg) {
+        if constexpr (Util::HasClear_v<decltype(arg)>) {
+            arg.Clear();
+        }
+    });
+}
+
+} // namespace BlockEmulation2
+
+#endif // BLOCK_EMULATION2_H
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 5782a9040..33b2fede6 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -4,6 +4,7 @@
 #include <type_traits>
 #include <vector>
 #include "block_emulation1.h"
+#include "block_emulation2.h"
 #include "demo_eval.h"
 #include "emulation.h"
 #include "expr_tmpl.h"
@@ -28,6 +29,19 @@ struct MyAddOp : ExprTmpl::Maker {
     }
 };
 
+template <typename T>
+struct AddOpWithManualCopy {
+    template <template <typename> class VectorType>
+    constexpr auto Get() const
+    {
+        using namespace ExprTmpl;
+        auto _1 = DefineParam<1, VectorType<T>>();
+        auto _2 = DefineParam<2, VectorType<T>>();
+        auto _3 = DefineParam<3, VectorType<T>, ParamUsage::out>();
+        return (CopyIn(_1), CopyIn(_2), _3 = _1 + _2, CopyOut(_3));
+    }
+};
+
 int main() // NOLINT(bugprone-exception-escape)
 {
     using namespace ExprTmpl;
@@ -121,12 +135,24 @@ int main() // NOLINT(bugprone-exception-escape)
               << '\n';
 
     std::fill(v5.begin(), v5.end(), 0.0F);
-    GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
-    GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
-    GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
-    GlobalTensor<float> t4(v4.data(), 300, make_layout(300));
-    GlobalTensor<float> t5(v5.data(), 300, make_layout(300));
-    BlockEmulation1::DoElementwise(MyAddOp<float>{}, t1, t2, t3, t4, t5);
+    {
+        GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
+        GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
+        GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
+        GlobalTensor<float> t4(v4.data(), 300, make_layout(300));
+        GlobalTensor<float> t5(v5.data(), 300, make_layout(300));
+        BlockEmulation1::DoElementwise(MyAddOp<float>{}, t1, t2, t3, t4, t5);
+    }
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
+
+    std::fill(v3.begin(), v3.end(), 0.0F);
+    {
+        GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
+        GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
+        GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
+        BlockEmulation2::DoElementwise(AddOpWithManualCopy<float>{}, t1, t2, t3);
+    }
+    std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
+              << '\n';
 }
-- 
Gitee


From f78dda0dd037418d10fd9268c70e41600c52e460 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 23 Oct 2025 16:48:48 +0800
Subject: [PATCH 059/116] Bug fix: Params and params may be in different order

---
 best_practices/expression_template/block_emulation1.h | 4 +---
 best_practices/expression_template/block_emulation2.h | 4 +---
 best_practices/expression_template/emulation.h        | 4 +---
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/best_practices/expression_template/block_emulation1.h b/best_practices/expression_template/block_emulation1.h
index 2b54dbd50..cfe091c3e 100644
--- a/best_practices/expression_template/block_emulation1.h
+++ b/best_practices/expression_template/block_emulation1.h
@@ -33,9 +33,7 @@ template <typename Params, std::size_t... Ints, typename... Arg>
 constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
 {
     return std::make_tuple(
-        ConstructParam<
-            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
-            arg...)...);
+        ConstructParam<Util::TMP::Get_t<Params, Ints>>(arg...)...);
 }
 
 template <typename Params, std::size_t Index, typename ParamTup,
diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index ba0e1f814..8f4b53b3b 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -135,9 +135,7 @@ template <typename Params, std::size_t... Ints, typename... Arg>
 constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
 {
     return std::make_tuple(
-        ConstructParam<
-            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
-            arg...)...);
+        ConstructParam<Util::TMP::Get_t<Params, Ints>>(arg...)...);
 }
 
 template <typename Params, std::size_t Index, typename ParamTup,
diff --git a/best_practices/expression_template/emulation.h b/best_practices/expression_template/emulation.h
index fe08db926..839d9cfbb 100644
--- a/best_practices/expression_template/emulation.h
+++ b/best_practices/expression_template/emulation.h
@@ -32,9 +32,7 @@ template <typename Params, typename ArgTup, std::size_t... Ints>
 constexpr auto PrepareParamsImpl(ArgTup& args, std::index_sequence<Ints...>)
 {
     return std::make_tuple(
-        ConstructParam<
-            FindUnique_t<CheckVarNum<Ints + 1>::template Checker, Params>>(
-            args)...);
+        ConstructParam<Util::TMP::Get_t<Params, Ints>>(args)...);
 }
 
 template <typename Params, std::size_t Index, typename ParamTup,
-- 
Gitee


From 017dac1b4fc4807e2cd97707d5ef22447842fa0e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 24 Oct 2025 11:01:49 +0800
Subject: [PATCH 060/116] Make only ExprTmpl::Params check for param count

---
 best_practices/expression_template/expr_tmpl.h | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index cb27f9795..586ee3d8b 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -214,6 +214,12 @@ struct ParamCollector<T, std::void_t<typename T::IsBinaryOp>> {
         typename ParamCollector<typename T::RhsType>::Type>;
 };
 
+template <typename T>
+struct UniqueParams {
+    using Type =
+        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+};
+
 } // namespace Detail
 
 template <typename T>
@@ -236,8 +242,7 @@ using LocalVars_t = typename LocalVars<T>::Type;
 
 template <typename T>
 struct Params {
-    using Type =
-        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+    using Type = typename Detail::UniqueParams<T>::Type;
 
 private:
     static constexpr std::size_t size = Util::TMP::Size_v<Type>;
@@ -257,7 +262,9 @@ struct InParams {
     template <typename U>
     struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
                                         U::usage == ParamUsage::in_out> {};
-    using Type = Util::TMP::Filter_t<IsInVar, Params_t<T>>;
+    using Type =
+        Util::TMP::Filter_t<IsInVar,
+                            typename Detail::UniqueParams<T>::Type>;
 };
 
 template <typename T>
@@ -268,7 +275,9 @@ struct OutParams {
     template <typename U>
     struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
                                          U::usage == ParamUsage::in_out> {};
-    using Type = Util::TMP::Filter_t<IsOutVar, Params_t<T>>;
+    using Type =
+        Util::TMP::Filter_t<IsOutVar,
+                            typename Detail::UniqueParams<T>::Type>;
 };
 
 template <typename T>
-- 
Gitee


From dc9339118c3f09de63ba6f8a339ad6efe4cc4cf8 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 24 Oct 2025 14:46:52 +0800
Subject: [PATCH 061/116] Add new TMP utilities

---
 best_practices/expression_template/util.h | 86 +++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 86c5535a7..6db4c9307 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -311,6 +311,11 @@ bool operator!=(const CompressedPair<T1, T2>& lhs,
 
 namespace TMP {
 
+template <typename T>
+struct TypeWrapper {
+    using Type = T;
+};
+
 template <typename... Ts>
 struct TypeList {};
 
@@ -336,6 +341,17 @@ struct Size<TypeList<Ts...>> {
 template <typename List>
 inline constexpr std::size_t Size_v = Size<List>::value;
 
+template <typename List, typename T>
+struct Append;
+
+template <typename... Ts, typename T>
+struct Append<TypeList<Ts...>, T> {
+    using Type = TypeList<Ts..., T>;
+};
+
+template <typename List, typename T>
+using Append_t = typename Append<List, T>::Type;
+
 template <typename T, typename List>
 struct Prepend;
 
@@ -456,6 +472,22 @@ struct Get<TypeList<>, N> {
 template <typename List, std::size_t N>
 using Get_t = typename Get<List, N>::Type;
 
+template <typename List>
+struct Reverse;
+
+template <>
+struct Reverse<TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <typename Head, typename... Tail>
+struct Reverse<TypeList<Head, Tail...>> {
+    using Type = Append_t<typename Reverse<TypeList<Tail...>>::Type, Head>;
+};
+
+template <typename List>
+using Reverse_t = typename Reverse<List>::Type;
+
 template <typename List>
 struct Unique;
 
@@ -488,6 +520,60 @@ struct FindUnique {
 template <template <typename> class Pred, typename List>
 using FindUnique_t = typename FindUnique<Pred, List>::Type;
 
+template <typename List, typename T>
+struct Contains;
+
+template <typename T>
+struct Contains<TypeList<>, T> : std::false_type {};
+
+template <typename... Tail, typename T>
+struct Contains<TypeList<T, Tail...>, T> : std::true_type {};
+
+template <typename Head, typename... Tail, typename T>
+struct Contains<TypeList<Head, Tail...>, T> {
+    static constexpr bool value = Contains<TypeList<Tail...>, T>::value;
+};
+
+template <typename List, typename T>
+inline constexpr bool Contains_v = Contains<List, T>::value;
+
+template <typename List1, typename List2>
+struct Intersection {
+    template <typename T>
+    struct IsInList2 : Contains<List2, T> {};
+
+    using Type = Filter_t<IsInList2, List1>;
+};
+
+template <typename List1, typename List2>
+using Intersection_t = typename Intersection<List1, List2>::Type;
+
+template <typename List1, typename List2>
+struct Difference {
+    template <typename T>
+    struct IsNotInList2 {
+        static constexpr bool value = !Contains_v<List2, T>;
+    };
+
+    using Type = Filter_t<IsNotInList2, List1>;
+};
+
+template <typename List1, typename List2>
+using Difference_t = typename Difference<List1, List2>::Type;
+
+template <typename Func, typename Data>
+auto ForEach(TypeList<>, Func&& /*func*/, Data data)
+{
+    return data;
+}
+
+template <typename Head, typename... Tail, typename Func, typename Data>
+auto ForEach(TypeList<Head, Tail...>, Func&& func, Data data)
+{
+    return ForEach(TypeList<Tail...>{}, std::forward<Func>(func),
+                   std::forward<Func>(func)(TypeWrapper<Head>{}, data));
+}
+
 } // namespace TMP
 
 } // namespace Util
-- 
Gitee


From cb10b874614411ac0102a55bd8254b6f87d929e4 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 24 Oct 2025 15:41:11 +0800
Subject: [PATCH 062/116] Support copy-on-demand

---
 .../expression_template/block_emulation2.h    | 145 +++++++++++++++++-
 .../expr_template_demo.cpp                    |  41 ++++-
 2 files changed, 182 insertions(+), 4 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 8f4b53b3b..33f7f628f 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -19,7 +19,12 @@ namespace BlockEmulation2 {
 using namespace Demo;
 using namespace ExprTmpl;
 
+using Util::TMP::Append_t;
+using Util::TMP::Concatenate_t;
+using Util::TMP::Difference_t;
 using Util::TMP::FindUnique_t;
+using Util::TMP::Intersection_t;
+using Util::TMP::Reverse_t;
 using Util::TMP::Size_v;
 
 // Primary template
@@ -535,10 +540,143 @@ using BlockTensor =
 template <typename T>
 using SimpleTensor = Demo::Tensor<T>;
 
-template <typename ExprMaker, typename... Args>
+template <typename T>
+constexpr auto FlattenAtOpAndThen(Expression<T>)
+{
+    return TypeList<T>{};
+}
+
+template <typename T, typename U>
+constexpr auto FlattenAtOpAndThen(Expression<OpAndThen<T, U>>)
+{
+    return Concatenate_t<decltype(FlattenAtOpAndThen(Expression<T>{})),
+                         decltype(FlattenAtOpAndThen(Expression<U>{}))>{};
+}
+
+template <typename T>
+constexpr auto BuildExpressionHelper(Expression<T>, TypeList<>)
+{
+    return Expression<T>{};
+}
+
+template <typename T, typename U, typename... Rest>
+constexpr auto BuildExpressionHelper(Expression<T>, TypeList<U, Rest...>)
+{
+    return BuildExpressionHelper(Expression<OpAndThen<T, U>>{},
+                                 TypeList<Rest...>{});
+}
+
+template <typename T>
+constexpr auto BuildExpression(TypeList<T>)
+{
+    return Expression<T>{};
+}
+
+template <typename T, typename U, typename... Rest>
+constexpr auto BuildExpression(TypeList<T, U, Rest...>)
+{
+    return BuildExpressionHelper(Expression<T>{}, TypeList<U, Rest...>{});
+}
+
+template <typename T, typename U = TypeList<>>
+struct ProcessData {
+    using UnusedInParams = T;
+    using Result = U;
+};
+
+struct CopyInInserter {
+    template <typename T, typename Data>
+    constexpr auto operator()(T, Data) const
+    {
+        using Param = typename T::Type;
+        return OpAndThen<OpCopyInParam<Param>, Data>{};
+    }
+};
+
+template <typename Expr, typename Params>
+constexpr auto InsertCopyIn(Expr, Params)
+{
+    // Reversing Params is for more natural copy order
+    return ForEach(Reverse_t<Params>{}, CopyInInserter{}, Expr{});
+}
+
+struct CopyOutInserter {
+    template <typename T, typename Data>
+    constexpr auto operator()(T, Data) const
+    {
+        using Param = typename T::Type;
+        return OpAndThen<Data, OpCopyOutParam<Param>>{};
+    }
+};
+
+template <typename Expr, typename Params>
+constexpr auto InsertCopyOut(Expr, Params)
+{
+    if constexpr (IsParam_v<Expr>) {
+        return Expr{}; // Do not copy out on a no-op
+    } else {
+        // Reversing Params is for more natural copy order
+        return ForEach(Reverse_t<Params>{}, CopyOutInserter{}, Expr{});
+    }
+}
+
+struct SubexpressionProcessor {
+    template <typename T, typename Data>
+    constexpr auto operator()(T, Data)
+    {
+        using Expr = typename T::Type;
+        using InParams = ExprTmpl::InParams_t<Expr>;
+        using OutParams = ExprTmpl::OutParams_t<Expr>;
+
+        using ParamsToCopyIn =
+            Intersection_t<InParams, typename Data::UnusedInParams>;
+        using Result1 = decltype(InsertCopyIn(Expr{}, ParamsToCopyIn{}));
+
+        using OutOnlyParams = Difference_t<OutParams, InParams>;
+        using Result2 = decltype(InsertCopyOut(Result1{}, OutOnlyParams{}));
+
+        return ProcessData<
+            Difference_t<typename Data::UnusedInParams, ParamsToCopyIn>,
+            Append_t<typename Data::Result, Result2>>{};
+    }
+};
+
+enum class CopyOnDemand { no, yes };
+
+template <CopyOnDemand CopyFlag = CopyOnDemand::yes, typename T>
+constexpr auto AddCopyOnDemand(Expression<T> expr)
+{
+    if constexpr (CopyFlag == CopyOnDemand::yes) {
+        using Expr = typename decltype(expr)::Type;
+        using InParams = ExprTmpl::InParams_t<Expr>;
+
+        auto subexpressionList = FlattenAtOpAndThen(expr);
+        auto processed =
+            ForEach(subexpressionList, SubexpressionProcessor{},
+                    ProcessData<InParams>{});
+
+        using OutParams = ExprTmpl::OutParams_t<Expr>;
+        using InOutParams = Intersection_t<InParams, OutParams>;
+        auto addedFinalCopyOut = ForEach(
+            InOutParams{},
+            [](auto t, auto data) {
+                using Param = typename decltype(t)::Type;
+                return Append_t<decltype(data), OpCopyOutParam<Param>>{};
+            },
+            processed);
+        return BuildExpression(
+            typename decltype(addedFinalCopyOut)::Result{});
+    } else {
+        return expr;
+    }
+}
+
+template <CopyOnDemand CopyFlag = CopyOnDemand::yes, typename ExprMaker,
+          typename... Args>
 void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
-    auto expr = maker.template Get<BlockTensor>();
+    auto expr =
+        AddCopyOnDemand<CopyFlag>(maker.template Get<BlockTensor>());
     using Expr = typename decltype(expr)::Type;
     static_assert(
         !Expr::hasData,
@@ -570,7 +708,8 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     }
     if (i < len) {
         std::size_t sizeTB = len - i;  // tail-block size
-        auto exprTB = maker.template Get<SimpleTensor>();
+        auto exprTB =
+            AddCopyOnDemand<CopyFlag>(maker.template Get<SimpleTensor>());
         using ExprTB = typename decltype(exprTB)::Type;
         using ParamsTB = Params_t<ExprTB>;
 
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 33b2fede6..0df01abfe 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -42,6 +42,19 @@ struct AddOpWithManualCopy {
     }
 };
 
+template <typename T>
+struct AddOpWithCopyOnDemand {
+    template <template <typename> class VectorType>
+    constexpr auto Get() const
+    {
+        using namespace ExprTmpl;
+        auto _1 = DefineParam<1, VectorType<T>>();
+        auto _2 = DefineParam<2, VectorType<T>>();
+        auto _3 = DefineParam<3, VectorType<T>, ParamUsage::out>();
+        return (_3 = _1 + _2);
+    }
+};
+
 int main() // NOLINT(bugprone-exception-escape)
 {
     using namespace ExprTmpl;
@@ -146,12 +159,38 @@ int main() // NOLINT(bugprone-exception-escape)
     std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
               << '\n';
 
+    std::fill(v5.begin(), v5.end(), 0.0F);
+    {
+        GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
+        GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
+        GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
+        GlobalTensor<float> t4(v4.data(), 300, make_layout(300));
+        GlobalTensor<float> t5(v5.data(), 300, make_layout(300));
+        BlockEmulation2::DoElementwise(MyAddOp<float>{}, t1, t2, t3, t4, t5);
+    }
+    std::cout << v5[0] << ' ' << v5[1] << ' ' << v5[2] << " ... " << v5[299]
+              << '\n';
+
+    std::fill(v3.begin(), v3.end(), 0.0F);
+    {
+        using namespace BlockEmulation2;
+        GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
+        GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
+        GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
+        DoElementwise<CopyOnDemand::no>(AddOpWithManualCopy<float>{},
+                                        t1, t2, t3);
+    }
+    std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
+              << '\n';
+
     std::fill(v3.begin(), v3.end(), 0.0F);
     {
+        using namespace BlockEmulation2;
         GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
         GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
         GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
-        BlockEmulation2::DoElementwise(AddOpWithManualCopy<float>{}, t1, t2, t3);
+        DoElementwise<CopyOnDemand::yes>(AddOpWithCopyOnDemand<float>{},
+                                         t1, t2, t3);
     }
     std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
               << '\n';
-- 
Gitee


From d40fdca143d8f6ed3349a2784d9ec889746d3cd6 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 24 Oct 2025 16:14:49 +0800
Subject: [PATCH 063/116] Make LocalVar and Param collectors support unary ops

---
 .../expression_template/expr_tmpl.h           | 32 +++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 586ee3d8b..5a24ae7fc 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -156,6 +156,15 @@ public:
     constexpr const T& GetData() const { return Storage::Data(); }
 };
 
+template <typename T, typename = void>
+struct IsUnaryOp : std::false_type {};
+
+template <typename T>
+struct IsUnaryOp<T, std::void_t<typename T::IsUnaryOp>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsUnaryOp_v = IsUnaryOp<T>::value;
+
 template <typename T, typename U>
 struct BinaryOp : private Util::CompressedPair<T, U> {
 private:
@@ -178,6 +187,15 @@ public:
     constexpr const U& GetRhs() const { return Storage::Second(); }
 };
 
+template <typename T, typename = void>
+struct IsBinaryOp : std::false_type {};
+
+template <typename T>
+struct IsBinaryOp<T, std::void_t<typename T::IsBinaryOp>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsBinaryOp_v = IsBinaryOp<T>::value;
+
 namespace Detail {
 
 template <typename T, typename = void>
@@ -191,7 +209,12 @@ struct LocalVarCollector<T, std::enable_if_t<IsLocalVar_v<T>>> {
 };
 
 template <typename T>
-struct LocalVarCollector<T, std::void_t<typename T::IsBinaryOp>> {
+struct LocalVarCollector<T, std::enable_if_t<IsUnaryOp_v<T>>> {
+    using Type = typename LocalVarCollector<typename T::DataType>::Type;
+};
+
+template <typename T>
+struct LocalVarCollector<T, std::enable_if_t<IsBinaryOp_v<T>>> {
     using Type = Util::TMP::Concatenate_t<
         typename LocalVarCollector<typename T::LhsType>::Type,
         typename LocalVarCollector<typename T::RhsType>::Type>;
@@ -208,7 +231,12 @@ struct ParamCollector<T, std::enable_if_t<IsParam_v<T>>> {
 };
 
 template <typename T>
-struct ParamCollector<T, std::void_t<typename T::IsBinaryOp>> {
+struct ParamCollector<T, std::enable_if_t<IsUnaryOp_v<T>>> {
+    using Type = typename ParamCollector<typename T::DataType>::Type;
+};
+
+template <typename T>
+struct ParamCollector<T, std::enable_if_t<IsBinaryOp_v<T>>> {
     using Type = Util::TMP::Concatenate_t<
         typename ParamCollector<typename T::LhsType>::Type,
         typename ParamCollector<typename T::RhsType>::Type>;
-- 
Gitee


From ab773e0dde68e0d4430cc932a979209593ad8249 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 24 Oct 2025 17:22:34 +0800
Subject: [PATCH 064/116] Rename for consistency

---
 best_practices/expression_template/expr_tmpl.h | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 5a24ae7fc..f108b051d 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -288,10 +288,11 @@ using Params_t = typename Params<T>::Type;
 template <typename T>
 struct InParams {
     template <typename U>
-    struct IsInVar : std::bool_constant<U::usage == ParamUsage::in ||
-                                        U::usage == ParamUsage::in_out> {};
+    struct IsInParam : std::bool_constant<U::usage == ParamUsage::in ||
+                                          U::usage == ParamUsage::in_out> {
+    };
     using Type =
-        Util::TMP::Filter_t<IsInVar,
+        Util::TMP::Filter_t<IsInParam,
                             typename Detail::UniqueParams<T>::Type>;
 };
 
@@ -301,10 +302,11 @@ using InParams_t = typename InParams<T>::Type;
 template <typename T>
 struct OutParams {
     template <typename U>
-    struct IsOutVar : std::bool_constant<U::usage == ParamUsage::out ||
-                                         U::usage == ParamUsage::in_out> {};
+    struct IsOutParam : std::bool_constant<U::usage == ParamUsage::out ||
+                                           U::usage == ParamUsage::in_out> {
+    };
     using Type =
-        Util::TMP::Filter_t<IsOutVar,
+        Util::TMP::Filter_t<IsOutParam,
                             typename Detail::UniqueParams<T>::Type>;
 };
 
-- 
Gitee


From bb1b484440dce3d2a9012c4d5512caa73e433b1f Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 31 Oct 2025 10:51:48 +0800
Subject: [PATCH 065/116] Add explicit Cast

---
 .../expression_template/demo_eval.h           | 22 +++++++++++++++++++
 .../expr_template_demo.cpp                    |  5 +++--
 .../expression_template/expr_tmpl.h           | 12 ++++++++++
 3 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index 1d8dc5408..9f6d68698 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -262,6 +262,28 @@ struct Evaluator<OpAndThen<T, U>> {
     }
 };
 
+template <typename T, typename U>
+void CastAssign(T& dst, const U& src)
+{
+    dst = static_cast<T>(src);
+}
+
+// Partial specialization for E_y = Cast(E_x)
+template <typename T, typename U>
+struct Evaluator<OpAssign<T, OpCast<U>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpAssign<T, OpCast<U>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return CastAssign(
+            Evaluator<T>{}(op.GetLhs(), args, localVars),
+            Evaluator<U>{}(op.GetRhs().GetData(), args, localVars));
+    }
+};
+
 template <typename T, typename U>
 auto Add(const T& src1, const U& src2)
 {
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 0df01abfe..785f9cc6c 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -78,11 +78,12 @@ int main() // NOLINT(bugprone-exception-escape)
 
     auto outVar = Expression{out};
 
-    auto tmp1 = DefineLocalVar<1, int>();
+    auto tmp1 = DefineLocalVar<1, float>();
     auto tmp2 = DefineAutoLocalVar<2>(tmp1 + tmp1);
     auto result5 = (tmp1 = _1 + _2,
                     tmp2 = tmp1 + tmp1,
-                    outVar = tmp2,
+                    tmp2 = tmp2 + 0.5,
+                    outVar = Cast(tmp2),
                     tmp2);
     std::cout << "sizeof result5 is " << sizeof result5 << '\n';
     std::cout << Evaluate(result5, 1, 2) << '\n';
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index f108b051d..052faa138 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -345,6 +345,18 @@ template <typename T>
     return Expression<OpCopyOutParam<T>>{{t.data}};
 }
 
+template <typename T>
+struct OpCast : UnaryOp<T> {
+    OpCast() = default;
+    constexpr OpCast(T t) : UnaryOp<T>(t) {}
+};
+
+template <typename T>
+[[nodiscard]] constexpr auto Cast(Expression<T> t)
+{
+    return Expression<OpCast<T>>{{t.data}};
+}
+
 template <typename T, typename U>
 struct OpAssign : BinaryOp<T, U> {
     OpAssign() = default;
-- 
Gitee


From daa22df0b68c108183db1c37ba4763a549791fcb Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 31 Oct 2025 11:17:21 +0800
Subject: [PATCH 066/116] Change Cast implementation and add rounding support

---
 .../expression_template/demo_eval.h           | 48 ++++++++++---------
 .../expr_template_demo.cpp                    |  2 +-
 .../expression_template/expr_tmpl.h           |  8 ++--
 3 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index 9f6d68698..1597e1b40 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -3,6 +3,7 @@
 
 /* Demo Evaluation */
 
+#include <cmath>
 #include <cstddef>
 #include <stdexcept>
 #include <tuple>
@@ -225,6 +226,31 @@ struct Evaluator<Param<N, T, U>> {
     }
 };
 
+template <typename Dest, CastMode Mode, typename T>
+auto Cast(const T& src)
+{
+    if constexpr (Mode == CastMode::round) {
+        return static_cast<Dest>(std::round(src));
+    } else {
+        return static_cast<Dest>(src);
+    }
+}
+
+// Partial specialization for Cast<T>(E_x)
+template <typename Dest, CastMode Mode, typename T>
+struct Evaluator<OpCast<Dest, Mode, T>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    auto operator()(const OpCast<Dest, Mode, T>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Cast<Dest, Mode>(
+            Evaluator<T>{}(op.GetData(), args, localVars));
+    }
+};
+
 template <typename T, typename U>
 void Assign(T& dst, const U& src)
 {
@@ -262,28 +288,6 @@ struct Evaluator<OpAndThen<T, U>> {
     }
 };
 
-template <typename T, typename U>
-void CastAssign(T& dst, const U& src)
-{
-    dst = static_cast<T>(src);
-}
-
-// Partial specialization for E_y = Cast(E_x)
-template <typename T, typename U>
-struct Evaluator<OpAssign<T, OpCast<U>>> {
-    using Type = void;
-
-    template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpCast<U>>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
-    {
-        return CastAssign(
-            Evaluator<T>{}(op.GetLhs(), args, localVars),
-            Evaluator<U>{}(op.GetRhs().GetData(), args, localVars));
-    }
-};
-
 template <typename T, typename U>
 auto Add(const T& src1, const U& src2)
 {
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 785f9cc6c..6e580aefd 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -83,7 +83,7 @@ int main() // NOLINT(bugprone-exception-escape)
     auto result5 = (tmp1 = _1 + _2,
                     tmp2 = tmp1 + tmp1,
                     tmp2 = tmp2 + 0.5,
-                    outVar = Cast(tmp2),
+                    outVar = Cast<int, CastMode::round>(tmp2),
                     tmp2);
     std::cout << "sizeof result5 is " << sizeof result5 << '\n';
     std::cout << Evaluate(result5, 1, 2) << '\n';
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 052faa138..445c6028a 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -345,16 +345,18 @@ template <typename T>
     return Expression<OpCopyOutParam<T>>{{t.data}};
 }
 
-template <typename T>
+enum class CastMode { normal, round };
+
+template <typename Dest, CastMode Mode, typename T>
 struct OpCast : UnaryOp<T> {
     OpCast() = default;
     constexpr OpCast(T t) : UnaryOp<T>(t) {}
 };
 
-template <typename T>
+template <typename Dest, CastMode Mode = CastMode::normal, typename T>
 [[nodiscard]] constexpr auto Cast(Expression<T> t)
 {
-    return Expression<OpCast<T>>{{t.data}};
+    return Expression<OpCast<Dest, Mode, T>>{{t.data}};
 }
 
 template <typename T, typename U>
-- 
Gitee


From 2f27e5af85210f6e69528a1ecea4cd21d8c24568 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 3 Nov 2025 21:45:01 +0800
Subject: [PATCH 067/116] Fix: CompressedPair may have ambiguous bases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When FirstType and SecondType are both empty and one is a base class of
another, the previous implementation would have ambiguity. E.g.

```
CompressedPairStorage<Item, OpCast<int, Item>, true, true>
├─ Item (direct base)
└─ OpCast<int, Item>
   └─ UnaryOp<Item>
      └─ CompressedData<Item>
         └─ CompressedDataStorage<Item, true>
            └─ Item (indirect base)
```

The solution is not to compress when such ambiguity is detected.
(Compressing only one of them does not really help, so it is not done at
all.)
---
 best_practices/expression_template/util.h | 35 ++++++++++++++++++-----
 1 file changed, 28 insertions(+), 7 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 6db4c9307..31db1f2dc 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -51,6 +51,28 @@ void ForEach(Tuple&& tuple, Func&& func)
 
 namespace Detail {
 
+// Check if compression would cause ambiguity
+template <typename T1, typename T2>
+inline constexpr bool WouldCauseAmbiguity_v =
+    std::is_same_v<T1, T2> ||
+    std::is_base_of_v<T1, T2> ||
+    std::is_base_of_v<T2, T1>;
+
+// Helper to determine if a type can be compressed
+template <typename T>
+inline constexpr bool CanCompress_v =
+    std::is_empty_v<T> && !std::is_final_v<T>;
+
+// Helpers to determine compression flags, accounting for ambiguity
+template <typename T1, typename T2>
+inline constexpr bool CompressFirst_v =
+    CanCompress_v<T1> &&
+    (!CanCompress_v<T2> || !WouldCauseAmbiguity_v<T1, T2>);
+template <typename T1, typename T2>
+inline constexpr bool CompressSecond_v =
+    CanCompress_v<T2> &&
+    (!CanCompress_v<T1> || !WouldCauseAmbiguity_v<T1, T2>);
+
 // Storage implementations for different compression scenarios
 template <typename T, bool Compress>
 struct CompressedDataStorage;
@@ -243,15 +265,14 @@ bool operator!=(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
 }
 
 template <typename T1, typename T2>
-class CompressedPair
-    : private Detail::CompressedPairStorage<
-          T1, T2,
-          std::is_empty_v<T1> && !std::is_final_v<T1>,
-          std::is_empty_v<T2> && !std::is_final_v<T2>> {
+class CompressedPair : private Detail::CompressedPairStorage<
+                           T1, T2,
+                           Detail::CompressFirst_v<T1, T2>,
+                           Detail::CompressSecond_v<T1, T2>> {
     using Storage = Detail::CompressedPairStorage<
         T1, T2,
-        std::is_empty_v<T1> && !std::is_final_v<T1>,
-        std::is_empty_v<T2> && !std::is_final_v<T2>>;
+        Detail::CompressFirst_v<T1, T2>,
+        Detail::CompressSecond_v<T1, T2>>;
 
 public:
     using FirstType = T1;
-- 
Gitee


From 654d1f8e67ebd8d03af7a055b99da353a3aa80bb Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 10 Nov 2025 11:38:06 +0800
Subject: [PATCH 068/116] Add support for ternary ops

---
 .../expression_template/demo_eval.h           | 17 ++++++
 .../expr_template_demo.cpp                    |  3 +-
 .../expression_template/expr_tmpl.h           | 54 +++++++++++++++++++
 3 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index 1597e1b40..e22bf8eef 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -440,6 +440,23 @@ struct Evaluator<OpCopyOutData<T, U>> {
     }
 };
 
+// Partial specializtion for If(E_if, E_then, E_else)
+template <typename T, typename U, typename V>
+struct Evaluator<OpIfThenElse<T, U, V>> {
+    using Type = std::common_type_t<typename Evaluator<U>::Type,
+                                    typename Evaluator<V>::Type>;
+
+    template <typename ArgTup, typename LocalVarTup>
+    Type operator()(const OpIfThenElse<T, U, V>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Evaluator<T>{}(op.GetFirst(), args, localVars)
+            ? Evaluator<U>{}(op.GetSecond(), args, localVars)
+            : Evaluator<V>{}(op.GetThird(), args, localVars);
+    }
+};
+
 } // namespace DemoEval
 
 #endif // DEMO_EVAL_H
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 6e580aefd..59f025ac9 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -64,13 +64,14 @@ int main() // NOLINT(bugprone-exception-escape)
     auto _1 = DefineParam<1, int>();
     auto _2 = DefineParam<2, int>();
     [[maybe_unused]] auto result1 = _1 + _2;
-    [[maybe_unused]] auto result2 = _1 + Expression{3};
+    [[maybe_unused]] auto result2 = _1 + If(_2, _2, Expression{'0'});
     [[maybe_unused]] auto result3 = 42 + _1;
     auto result4 = (Expression<Param<2, int&, ParamUsage::out>>{} = result3);
     std::cout << "sizeof result1 is " << sizeof result1 << '\n';
     std::cout << "sizeof result2 is " << sizeof result2 << '\n';
     std::cout << "sizeof result3 is " << sizeof result3 << '\n';
     std::cout << "sizeof result4 is " << sizeof result4 << '\n';
+    std::cout << Evaluate(result2, 3, 8) << "\n";
     //TYPE_DISPLAY(OutParams_t<decltype(result4)::Type>{});
     int out{};
     Evaluate(result4, 1, out);
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 445c6028a..4c0528fbb 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -196,6 +196,46 @@ struct IsBinaryOp<T, std::void_t<typename T::IsBinaryOp>> : std::true_type {};
 template <typename T>
 inline constexpr bool IsBinaryOp_v = IsBinaryOp<T>::value;
 
+template <typename T, typename U, typename V>
+struct TernaryOp
+    : private Util::CompressedPair<T, Util::CompressedPair<U, V>> {
+private:
+    using Storage = Util::CompressedPair<T, Util::CompressedPair<U, V>>;
+
+public:
+    static_assert(!(std::is_rvalue_reference_v<T> ||
+                    std::is_rvalue_reference_v<U> ||
+                    std::is_rvalue_reference_v<V>),
+                  "Rvalue references cannot be stored");
+    static constexpr bool hasData =
+        (HasDataTrait<T>::value ||
+         HasDataTrait<U>::value ||
+         HasDataTrait<V>::value);
+    using IsTernaryOp = void;
+    using FirstType = T;
+    using SecondType = U;
+    using ThirdType = V;
+
+    TernaryOp() = default;
+    constexpr TernaryOp(T t, U u, V v)
+        : Storage(t, Util::CompressedPair<U, V>(u, v))
+    {
+    }
+
+    constexpr const T& GetFirst() const { return Storage::First(); }
+    constexpr const U& GetSecond() const { return Storage::Second().First(); }
+    constexpr const V& GetThird() const { return Storage::Second().Second(); }
+};
+
+template <typename T, typename = void>
+struct IsTernaryOp : std::false_type {};
+
+template <typename T>
+struct IsTernaryOp<T, std::void_t<typename T::IsTernaryOp>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsTernaryOp_v = IsTernaryOp<T>::value;
+
 namespace Detail {
 
 template <typename T, typename = void>
@@ -471,6 +511,20 @@ template <typename T, typename U>
     return Expression<OpCopyOutData<T, U>>{{src.data, dst.data}};
 }
 
+template <typename T, typename U, typename V>
+struct OpIfThenElse : TernaryOp<T, U, V> {
+    OpIfThenElse() = default;
+    constexpr OpIfThenElse(T t, U u, V v) : TernaryOp<T, U, V>(t, u, v) {}
+};
+
+template <typename T, typename U, typename V>
+[[nodiscard]] constexpr auto If(Expression<T> t,
+                                Expression<U> u,
+                                Expression<V> v)
+{
+    return Expression<OpIfThenElse<T, U, V>>{{t.data, u.data, v.data}};
+}
+
 // Base class to express that a class is a maker of calculation expression template
 class Maker {};
 
-- 
Gitee


From 7be053b561be8b934215e08756f9efab73a1ab40 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 10 Nov 2025 14:48:36 +0800
Subject: [PATCH 069/116] Remove direct computing support

as it is not very useful and can make type calculation complicated.
---
 best_practices/expression_template/demo_eval.h        | 10 +++-------
 .../expression_template/expr_template_demo.cpp        | 11 -----------
 2 files changed, 3 insertions(+), 18 deletions(-)

diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index e22bf8eef..53101df8e 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -29,14 +29,10 @@ struct Evaluator {
 
     template <typename ArgTup, typename LocalVarTup>
     decltype(auto) operator()(const T& value,
-                              ArgTup& args,
-                              LocalVarTup& localVars) const
+                              ArgTup& /*args*/,
+                              LocalVarTup& /*localVars*/) const
     {
-        if constexpr (std::is_invocable_v<T, ArgTup&, LocalVarTup&>) {
-            return value(args, localVars);
-        } else {
-            return value;
-        }
+        return value;
     }
 };
 
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 59f025ac9..fcfe6d315 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -91,17 +91,6 @@ int main() // NOLINT(bugprone-exception-escape)
     //TYPE_DISPLAY(LocalVars_t<decltype(result5)::Type>{});
     std::cout << out << '\n';
 
-    // Hack for direct computing
-    auto compute = [](auto& args, auto& /*localVars*/) {
-        return std::get<0>(args) + std::get<1>(args);
-    };
-    auto result6 = (_1, _2, Expression{compute});
-    //TYPE_DISPLAY(Params_t<decltype(result6)::Type>{});
-    static_assert(std::is_same_v<Params_t<decltype(result6)::Type>,
-                                 TypeList<Param<1, int>, Param<2, int>>>);
-    auto r = Evaluate(result6, 1, 2);
-    std::cout << r << '\n';
-
     // Test CopyIn and CopyOut operations
     auto srcParam = DefineParam<1, Tensor<float>>();
     auto dstParam = DefineParam<2, Tensor<float>, ParamUsage::out>();
-- 
Gitee


From 5bcba7694c371e8756281cfca158fc4ece8462e0 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 10 Nov 2025 15:31:55 +0800
Subject: [PATCH 070/116] Fix inconsistencies between claimed and actual types

Evaluation result type and Evaluator::Type were not consistent.
---
 .../expression_template/block_emulation2.h    | 17 +++++-----
 .../expression_template/demo_eval.h           | 31 ++++++++++---------
 .../expr_template_demo.cpp                    |  1 +
 3 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 33f7f628f..a240f43c8 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -338,7 +338,7 @@ struct Evaluator<OpAssign<T, U>> {
                     LocalVarTup& localVars,
                     std::size_t size) const
     {
-        return Assign(
+        Assign(
             Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
             Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
     }
@@ -347,10 +347,10 @@ struct Evaluator<OpAssign<T, U>> {
 // Partial specializtion for E_x, E_y
 template <typename T, typename U>
 struct Evaluator<OpAndThen<T, U>> {
-    using Type = void;
+    using Type = typename Evaluator<U>::Type;
 
     template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    auto operator()(const OpAndThen<T, U>& op,
+    Type operator()(const OpAndThen<T, U>& op,
                     OrgArgTup& orgArgs,
                     ConvArgTup& convArgs,
                     LocalVarTup& localVars,
@@ -441,7 +441,7 @@ struct Evaluator<OpAdd<T, U>> {
                               std::declval<typename Evaluator<U>::Type>()));
 
     template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    auto operator()(const OpAdd<T, U>& op,
+    Type operator()(const OpAdd<T, U>& op,
                     OrgArgTup& orgArgs,
                     ConvArgTup& convArgs,
                     LocalVarTup& localVars,
@@ -449,8 +449,7 @@ struct Evaluator<OpAdd<T, U>> {
     {
         return Add(
             Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars,
-                           size));
+            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
     }
 };
 
@@ -461,7 +460,7 @@ struct Evaluator<OpSubtract<T, U>> {
                               std::declval<typename Evaluator<U>::Type>()));
 
     template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    auto operator()(const OpSubtract<T, U>& op,
+    Type operator()(const OpSubtract<T, U>& op,
                     OrgArgTup& orgArgs,
                     ConvArgTup& convArgs,
                     LocalVarTup& localVars,
@@ -480,13 +479,13 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     using Type = void;
 
     template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+    void operator()(const OpAssign<T, OpAdd<U, V>>& op,
                     OrgArgTup& orgArgs,
                     ConvArgTup& convArgs,
                     LocalVarTup& localVars,
                     std::size_t size) const
     {
-        return AddAssign(
+        AddAssign(
             Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
             Evaluator<U>{}(op.GetRhs().GetLhs(), orgArgs, convArgs,
                            localVars, size),
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index 53101df8e..d61ad3bbb 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -223,7 +223,7 @@ struct Evaluator<Param<N, T, U>> {
 };
 
 template <typename Dest, CastMode Mode, typename T>
-auto Cast(const T& src)
+Dest Cast(const T& src)
 {
     if constexpr (Mode == CastMode::round) {
         return static_cast<Dest>(std::round(src));
@@ -235,10 +235,10 @@ auto Cast(const T& src)
 // Partial specialization for Cast<T>(E_x)
 template <typename Dest, CastMode Mode, typename T>
 struct Evaluator<OpCast<Dest, Mode, T>> {
-    using Type = void;
+    using Type = Dest;
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpCast<Dest, Mode, T>& op,
+    Dest operator()(const OpCast<Dest, Mode, T>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -263,18 +263,18 @@ struct Evaluator<OpAssign<T, U>> {
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
-        return Assign(Evaluator<T>{}(op.GetLhs(), args, localVars),
-                      Evaluator<U>{}(op.GetRhs(), args, localVars));
+        Assign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+               Evaluator<U>{}(op.GetRhs(), args, localVars));
     }
 };
 
 // Partial specializtion for E_x, E_y
 template <typename T, typename U>
 struct Evaluator<OpAndThen<T, U>> {
-    using Type = void;
+    using Type = typename Evaluator<U>::Type;
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAndThen<T, U>& op,
+    Type operator()(const OpAndThen<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -363,7 +363,7 @@ struct Evaluator<OpAdd<T, U>> {
                               std::declval<typename Evaluator<U>::Type>()));
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAdd<T, U>& op,
+    Type operator()(const OpAdd<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -375,11 +375,12 @@ struct Evaluator<OpAdd<T, U>> {
 // Partial specializtion for E_x - E_y
 template <typename T, typename U>
 struct Evaluator<OpSubtract<T, U>> {
-    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
-                              std::declval<typename Evaluator<U>::Type>()));
+    using Type =
+        decltype(Subtract(std::declval<typename Evaluator<T>::Type>(),
+                          std::declval<typename Evaluator<U>::Type>()));
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpSubtract<T, U>& op,
+    Type operator()(const OpSubtract<T, U>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
@@ -394,13 +395,13 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     using Type = void;
 
     template <typename ArgTup, typename LocalVarTup>
-    auto operator()(const OpAssign<T, OpAdd<U, V>>& op,
+    void operator()(const OpAssign<T, OpAdd<U, V>>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
-        return AddAssign(Evaluator<T>{}(op.GetLhs(), args, localVars),
-                         Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
-                         Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
+        AddAssign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                  Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
+                  Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
     }
 };
 
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index fcfe6d315..812cea379 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -89,6 +89,7 @@ int main() // NOLINT(bugprone-exception-escape)
     std::cout << "sizeof result5 is " << sizeof result5 << '\n';
     std::cout << Evaluate(result5, 1, 2) << '\n';
     //TYPE_DISPLAY(LocalVars_t<decltype(result5)::Type>{});
+    //TYPE_DISPLAY(std::declval<Evaluator<decltype(result5)>::Type>());
     std::cout << out << '\n';
 
     // Test CopyIn and CopyOut operations
-- 
Gitee


From ebf8d6fdb822f91acaf14db974b326eab464c0cf Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 10 Nov 2025 15:47:23 +0800
Subject: [PATCH 071/116] Do not use references as evaluation result type

We use `Evaluator<>::Type` mainly in `DefineAutoLocalVar`, and we do not
need references there.
---
 best_practices/expression_template/block_emulation2.h | 2 +-
 best_practices/expression_template/demo_eval.h        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index a240f43c8..3a630d63a 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -277,7 +277,7 @@ struct Evaluator<Expression<T>> : Evaluator<T> {};
 // Partial specialization for LocalVar
 template <std::size_t N, typename T, typename L>
 struct Evaluator<LocalVar<N, T, L>> {
-    using Type = T&;
+    using Type = T;
 
     template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
     decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index d61ad3bbb..f3c8924e8 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -183,7 +183,7 @@ struct Evaluator<Expression<T>> : Evaluator<T> {};
 // Partial specialization for LocalVar
 template <std::size_t N, typename T, typename L>
 struct Evaluator<LocalVar<N, T, L>> {
-    using Type = T&;
+    using Type = T;
 
     template <typename ArgTup, typename LocalVarTup>
     decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
-- 
Gitee


From 9e30129e66dea202d8e1ab7ec63e80a2a0e1a770 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 10 Nov 2025 16:34:19 +0800
Subject: [PATCH 072/116] Fix bugs resulting from copy-and-paste

---
 best_practices/expression_template/block_emulation2.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 3a630d63a..bd8e1783f 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -456,8 +456,9 @@ struct Evaluator<OpAdd<T, U>> {
 // Partial specializtion for E_x - E_y
 template <typename T, typename U>
 struct Evaluator<OpSubtract<T, U>> {
-    using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
-                              std::declval<typename Evaluator<U>::Type>()));
+    using Type =
+        decltype(Subtract(std::declval<typename Evaluator<T>::Type>(),
+                          std::declval<typename Evaluator<U>::Type>()));
 
     template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
     Type operator()(const OpSubtract<T, U>& op,
@@ -468,8 +469,7 @@ struct Evaluator<OpSubtract<T, U>> {
     {
         return Subtract(
             Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars,
-                           size));
+            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
     }
 };
 
-- 
Gitee


From e16799e468729dcc6a8061990c7dd91f125d1fa4 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 10 Nov 2025 16:35:08 +0800
Subject: [PATCH 073/116] Make LocalVar and Param collectors support ternary
 ops

---
 best_practices/expression_template/expr_tmpl.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 4c0528fbb..b00cc4ba8 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -260,6 +260,14 @@ struct LocalVarCollector<T, std::enable_if_t<IsBinaryOp_v<T>>> {
         typename LocalVarCollector<typename T::RhsType>::Type>;
 };
 
+template <typename T>
+struct LocalVarCollector<T, std::enable_if_t<IsTernaryOp_v<T>>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename LocalVarCollector<typename T::FirstType>::Type,
+        typename LocalVarCollector<typename T::SecondType>::Type,
+        typename LocalVarCollector<typename T::ThirdType>::Type>;
+};
+
 template <typename T, typename = void>
 struct ParamCollector {
     using Type = TypeList<>;
@@ -282,6 +290,14 @@ struct ParamCollector<T, std::enable_if_t<IsBinaryOp_v<T>>> {
         typename ParamCollector<typename T::RhsType>::Type>;
 };
 
+template <typename T>
+struct ParamCollector<T, std::enable_if_t<IsTernaryOp_v<T>>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename ParamCollector<typename T::FirstType>::Type,
+        typename ParamCollector<typename T::SecondType>::Type,
+        typename ParamCollector<typename T::ThirdType>::Type>;
+};
+
 template <typename T>
 struct UniqueParams {
     using Type =
-- 
Gitee


From 5fd8ef21b8dfd619c16954f836196b96cf171537 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 11 Nov 2025 15:04:28 +0800
Subject: [PATCH 074/116] Fix: Util::TMP::ForEach should be marked constexpr

---
 best_practices/expression_template/util.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 31db1f2dc..af9a8cac7 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -583,13 +583,13 @@ template <typename List1, typename List2>
 using Difference_t = typename Difference<List1, List2>::Type;
 
 template <typename Func, typename Data>
-auto ForEach(TypeList<>, Func&& /*func*/, Data data)
+constexpr auto ForEach(TypeList<>, Func&& /*func*/, Data data)
 {
     return data;
 }
 
 template <typename Head, typename... Tail, typename Func, typename Data>
-auto ForEach(TypeList<Head, Tail...>, Func&& func, Data data)
+constexpr auto ForEach(TypeList<Head, Tail...>, Func&& func, Data data)
 {
     return ForEach(TypeList<Tail...>{}, std::forward<Func>(func),
                    std::forward<Func>(func)(TypeWrapper<Head>{}, data));
-- 
Gitee


From 483807e7fa83de0a1f217b3696ef0291a209c055 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 11 Nov 2025 15:22:56 +0800
Subject: [PATCH 075/116] Implement Util::TMP::FindLast

---
 best_practices/expression_template/util.h | 31 +++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index af9a8cac7..f135f32a8 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -472,6 +472,37 @@ struct Find<Pred, TypeList<Head, Tail...>,
 template <template <typename> class Pred, typename List>
 inline constexpr std::size_t Find_v = Find<Pred, List>::value;
 
+namespace Detail {
+
+template <template <typename> class Pred, typename List,
+          std::size_t Current, std::size_t Last>
+struct FindLastImpl;
+
+template <template <typename> class Pred,
+          std::size_t Current, std::size_t Last>
+struct FindLastImpl<Pred, TypeList<>, Current, Last> {
+    static constexpr std::size_t value =
+        (Last == static_cast<std::size_t>(-1)) ? Current : Last;
+};
+
+template <template <typename> class Pred, typename Head, typename... Tail,
+          std::size_t Current, std::size_t Last>
+struct FindLastImpl<Pred, TypeList<Head, Tail...>, Current, Last> {
+    static constexpr std::size_t value = std::conditional_t<
+        Pred<Head>::value,
+        FindLastImpl<Pred, TypeList<Tail...>, Current + 1, Current>,
+        FindLastImpl<Pred, TypeList<Tail...>, Current + 1, Last>>::value;
+};
+
+} // namespace Detail
+
+template <template <typename> class Pred, typename List>
+struct FindLast
+    : Detail::FindLastImpl<Pred, List, 0, static_cast<std::size_t>(-1)> {};
+
+template <template <typename> class Pred, typename List>
+inline constexpr std::size_t FindLast_v = FindLast<Pred, List>::value;
+
 template <typename List, std::size_t N>
 struct Get;
 
-- 
Gitee


From 8e38226bd07b99e37bf47d5bf2d15132815566dc Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 11 Nov 2025 15:23:44 +0800
Subject: [PATCH 076/116] Add some TMP tests

---
 .../expression_template/util_test.cpp         | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 best_practices/expression_template/util_test.cpp

diff --git a/best_practices/expression_template/util_test.cpp b/best_practices/expression_template/util_test.cpp
new file mode 100644
index 000000000..fec925e87
--- /dev/null
+++ b/best_practices/expression_template/util_test.cpp
@@ -0,0 +1,52 @@
+#include "util.h"
+#include <iostream>
+#include <type_traits>
+#include <boost/type_index.hpp>
+
+using namespace Util::TMP;
+using boost::typeindex::type_id;
+
+struct A {};
+struct B {};
+struct C {};
+struct D {};
+
+template<typename T>
+struct Is {
+    template <typename U>
+    struct Type : std::is_same<T, U> {};
+};
+
+int main()
+{
+    {
+        using L1 = TypeList<A, B>;
+        using L2 = TypeList<A, C, D>;
+        using Result = Concatenate_t<L1, L2>;
+        std::cout << type_id<Result>().pretty_name() << '\n';
+        std::cout << type_id<Unique_t<Result>>().pretty_name() << '\n';
+    }
+    {
+        using L1 = TypeList<A, B>;
+        using L2 = TypeList<C, A, B>;
+        using L3 = TypeList<B, C, D>;
+        std::cout << type_id<Intersection_t<L1, L2>>().pretty_name() << '\n';
+        std::cout << type_id<Intersection_t<L2, L3>>().pretty_name() << '\n';
+        std::cout << type_id<Difference_t<L1, L2>>().pretty_name() << '\n';
+        std::cout << type_id<Difference_t<L2, L1>>().pretty_name() << '\n';
+        std::cout << type_id<Difference_t<L2, L3>>().pretty_name() << '\n';
+
+        std::cout << type_id<Reverse_t<L3>>().pretty_name() << '\n';
+    }
+    {
+        using List = TypeList<A, B, A, A, D>;
+        std::cout << Find_v<Is<A>::Type, List> << '\n';
+        std::cout << Find_v<Is<B>::Type, List> << '\n';
+        std::cout << Find_v<Is<C>::Type, List> << '\n';
+        std::cout << Find_v<Is<D>::Type, List> << '\n';
+        std::cout << FindLast_v<Is<A>::Type, List> << '\n';
+        std::cout << FindLast_v<Is<B>::Type, List> << '\n';
+        std::cout << FindLast_v<Is<C>::Type, List> << '\n';
+        std::cout << FindLast_v<Is<D>::Type, List> << '\n';
+    }
+}
-- 
Gitee


From 2867ad106483c14487a2aa7a287b3982beff34af Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 09:44:03 +0800
Subject: [PATCH 077/116] Implement Util::TMP::Map

---
 best_practices/expression_template/util.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index f135f32a8..a2320a9d0 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -524,6 +524,23 @@ struct Get<TypeList<>, N> {
 template <typename List, std::size_t N>
 using Get_t = typename Get<List, N>::Type;
 
+template <template <typename> class Proc, typename List>
+struct Map;
+
+template <template <typename> class Proc, typename Head, typename... Tail>
+struct Map<Proc, TypeList<Head, Tail...>> {
+    using Type = Prepend_t<typename Proc<Head>::Type,
+                           typename Map<Proc, TypeList<Tail...>>::Type>;
+};
+
+template <template <typename> class Proc>
+struct Map<Proc, TypeList<>> {
+    using Type = TypeList<>;
+};
+
+template <template <typename> class Proc, typename List>
+using Map_t = typename Map<Proc, List>::Type;
+
 template <typename List>
 struct Reverse;
 
-- 
Gitee


From bc453621fae4f9d4083c06746a852a3c4ad616ad Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 14:59:13 +0800
Subject: [PATCH 078/116] Implement Map in a simpler and more efficient way

---
 best_practices/expression_template/util.h | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index a2320a9d0..90a5b6369 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -527,15 +527,9 @@ using Get_t = typename Get<List, N>::Type;
 template <template <typename> class Proc, typename List>
 struct Map;
 
-template <template <typename> class Proc, typename Head, typename... Tail>
-struct Map<Proc, TypeList<Head, Tail...>> {
-    using Type = Prepend_t<typename Proc<Head>::Type,
-                           typename Map<Proc, TypeList<Tail...>>::Type>;
-};
-
-template <template <typename> class Proc>
-struct Map<Proc, TypeList<>> {
-    using Type = TypeList<>;
+template <template <typename> class Proc, typename... Ts>
+struct Map<Proc, TypeList<Ts...>> {
+    using Type = TypeList<typename Proc<Ts>::Type...>;
 };
 
 template <template <typename> class Proc, typename List>
-- 
Gitee


From 2539bf5e3b86426c164809d0797b4924bdf00e51 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 15:37:29 +0800
Subject: [PATCH 079/116] Implement Util::TMP::Set

---
 best_practices/expression_template/util.h     | 25 +++++++++++++++++++
 .../expression_template/util_test.cpp         |  9 +++++++
 2 files changed, 34 insertions(+)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 90a5b6369..80ef0d7bb 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -518,6 +518,7 @@ struct Get<TypeList<Head, Tail...>, 0> {
 
 template <std::size_t N>
 struct Get<TypeList<>, N> {
+    // Always false if matched here
     static_assert(N < 0, "Index out of bounds in Get");
 };
 
@@ -551,6 +552,30 @@ struct Reverse<TypeList<Head, Tail...>> {
 template <typename List>
 using Reverse_t = typename Reverse<List>::Type;
 
+template <typename List, std::size_t N, typename NewItem>
+struct Set;
+
+template <typename Head, typename... Tail, std::size_t N, typename NewItem>
+struct Set<TypeList<Head, Tail...>, N, NewItem> {
+    using Type =
+        Prepend_t<Head,
+                  typename Set<TypeList<Tail...>, N - 1, NewItem>::Type>;
+};
+
+template <typename Head, typename... Tail, typename NewItem>
+struct Set<TypeList<Head, Tail...>, 0, NewItem> {
+    using Type = TypeList<NewItem, Tail...>;
+};
+
+template <std::size_t N, typename NewItem>
+struct Set<TypeList<>, N, NewItem> {
+    // Always false if matched here
+    static_assert(N < 0, "Index out of bounds in Set");
+};
+
+template <typename List, std::size_t N, typename NewItem>
+using Set_t = typename Set<List, N, NewItem>::Type;
+
 template <typename List>
 struct Unique;
 
diff --git a/best_practices/expression_template/util_test.cpp b/best_practices/expression_template/util_test.cpp
index fec925e87..031a43a9f 100644
--- a/best_practices/expression_template/util_test.cpp
+++ b/best_practices/expression_template/util_test.cpp
@@ -49,4 +49,13 @@ int main()
         std::cout << FindLast_v<Is<C>::Type, List> << '\n';
         std::cout << FindLast_v<Is<D>::Type, List> << '\n';
     }
+    {
+        using List = TypeList<A, B, A, A, D>;
+        static_assert(std::is_same_v<Get_t<List, 0>, A>);
+        static_assert(std::is_same_v<Get_t<List, 1>, B>);
+        static_assert(std::is_same_v<Get_t<List, 4>, D>);
+
+        using NewList = Set_t<List, 3, C>;
+        static_assert(std::is_same_v<NewList, TypeList<A, B, A, C, D>>);
+    }
 }
-- 
Gitee


From 9c232d18cd57a24c5eed61a73ae6c7edda0772da Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 16:51:45 +0800
Subject: [PATCH 080/116] Implement on-demand copy and memory management

---
 .../expression_template/block_emulation2.h    | 254 ++++++++++++------
 .../expression_template/expr_tmpl.h           |  41 +++
 2 files changed, 206 insertions(+), 89 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index bd8e1783f..c1ca42615 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -237,7 +237,6 @@ auto GetOutParams(ParamTup& params)
         params, std::make_index_sequence<size>{});
 }
 
-
 template <typename Param, typename T, typename ArgTup>
 void CopyInParam(T& param, ArgTup& args, std::size_t len)
 {
@@ -494,6 +493,44 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     }
 };
 
+// Partial specialization for Alloc(E)
+template <typename T>
+struct Evaluator<OpAlloc<T>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    void operator()(const OpAlloc<T>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
+                                   localVars, size);
+        // Do nothing for now
+        (void)obj;
+    }
+};
+
+// Partial specialization for Free(E)
+template <typename T>
+struct Evaluator<OpFree<T>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    void operator()(const OpFree<T>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
+                                   localVars, size);
+        // Do nothing for now
+        (void)obj;
+    }
+};
+
 // Partial specialization for CopyIn(E)
 template <typename T>
 struct Evaluator<OpCopyInParam<T>> {
@@ -540,103 +577,127 @@ template <typename T>
 using SimpleTensor = Demo::Tensor<T>;
 
 template <typename T>
-constexpr auto FlattenAtOpAndThen(Expression<T>)
-{
-    return TypeList<T>{};
-}
+struct FlattenAtOpAndThen {
+    using Type = TypeList<T>;
+};
 
 template <typename T, typename U>
-constexpr auto FlattenAtOpAndThen(Expression<OpAndThen<T, U>>)
-{
-    return Concatenate_t<decltype(FlattenAtOpAndThen(Expression<T>{})),
-                         decltype(FlattenAtOpAndThen(Expression<U>{}))>{};
-}
+struct FlattenAtOpAndThen<OpAndThen<T, U>> {
+    using Type = Concatenate_t<typename FlattenAtOpAndThen<T>::Type,
+                               typename FlattenAtOpAndThen<U>::Type>;
+};
+
+namespace Detail {
+
+template <typename Expr, typename List>
+struct BuildExpressionHelper;
 
 template <typename T>
-constexpr auto BuildExpressionHelper(Expression<T>, TypeList<>)
-{
-    return Expression<T>{};
-}
+struct BuildExpressionHelper<Expression<T>, TypeList<>> {
+    using Type = Expression<T>;
+};
 
 template <typename T, typename U, typename... Rest>
-constexpr auto BuildExpressionHelper(Expression<T>, TypeList<U, Rest...>)
-{
-    return BuildExpressionHelper(Expression<OpAndThen<T, U>>{},
-                                 TypeList<Rest...>{});
-}
+struct BuildExpressionHelper<Expression<T>, TypeList<U, Rest...>> {
+    using Type = typename BuildExpressionHelper<Expression<OpAndThen<T, U>>,
+                                                TypeList<Rest...>>::Type;
+};
+
+} // namespace Detail
+
+template <typename List>
+struct BuildExpression;
 
 template <typename T>
-constexpr auto BuildExpression(TypeList<T>)
-{
-    return Expression<T>{};
-}
+struct BuildExpression<TypeList<T>> {
+    using Type = Expression<T>;
+};
 
 template <typename T, typename U, typename... Rest>
-constexpr auto BuildExpression(TypeList<T, U, Rest...>)
+struct BuildExpression<TypeList<T, U, Rest...>>
 {
-    return BuildExpressionHelper(Expression<T>{}, TypeList<U, Rest...>{});
-}
+    using Type =
+        typename Detail::BuildExpressionHelper<Expression<T>,
+                                               TypeList<U, Rest...>>::Type;
+};
 
-template <typename T, typename U = TypeList<>>
-struct ProcessData {
-    using UnusedInParams = T;
-    using Result = U;
+template <typename  ExprList, typename Param>
+struct FirstAndLastUse {
+    static constexpr std::size_t firstUse =
+        Util::TMP::Find_v<HasParamNChecker<Param::number>::template Type,
+                          ExprList>;
+    static constexpr std::size_t lastUse = Util::TMP::FindLast_v<
+        HasParamNChecker<Param::number>::template Type, ExprList>;
+    using Type = TypeList<Param,
+                          std::integral_constant<std::size_t, firstUse>,
+                          std::integral_constant<std::size_t, lastUse>>;
+};
+
+template <typename ExprList>
+struct FirstAndLastUseFinder {
+    template <typename Param>
+    using Type = FirstAndLastUse<ExprList, Param>;
 };
 
 struct CopyInInserter {
-    template <typename T, typename Data>
-    constexpr auto operator()(T, Data) const
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) const
     {
-        using Param = typename T::Type;
-        return OpAndThen<OpCopyInParam<Param>, Data>{};
+        using ParamUse = typename T::Type;
+        using Param = Util::TMP::Get_t<ParamUse, 0>;
+        constexpr auto firstUse = Util::TMP::Get_t<ParamUse, 1>::value;
+        if constexpr (Param::usage == ParamUsage::in ||
+                      Param::usage == ParamUsage::in_out) {
+            using OldItem = Util::TMP::Get_t<ExprList, firstUse>;
+            using NewItem = OpAndThen<OpCopyInParam<Param>, OldItem>;
+            return Util::TMP::Set_t<ExprList, firstUse, NewItem>{};
+        } else {
+            return ExprList{};
+        }
     }
 };
 
-template <typename Expr, typename Params>
-constexpr auto InsertCopyIn(Expr, Params)
-{
-    // Reversing Params is for more natural copy order
-    return ForEach(Reverse_t<Params>{}, CopyInInserter{}, Expr{});
-}
-
 struct CopyOutInserter {
-    template <typename T, typename Data>
-    constexpr auto operator()(T, Data) const
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) const
     {
-        using Param = typename T::Type;
-        return OpAndThen<Data, OpCopyOutParam<Param>>{};
+        using ParamUse = typename T::Type;
+        using Param = Util::TMP::Get_t<ParamUse, 0>;
+        constexpr auto lastUse = Util::TMP::Get_t<ParamUse, 2>::value;
+        if constexpr (Param::usage == ParamUsage::out ||
+                      Param::usage == ParamUsage::in_out) {
+            using OldItem = Util::TMP::Get_t<ExprList, lastUse>;
+            using NewItem = OpAndThen<OldItem, OpCopyOutParam<Param>>;
+            return Util::TMP::Set_t<ExprList, lastUse, NewItem>{};
+        } else {
+            return ExprList{};
+        }
     }
 };
 
-template <typename Expr, typename Params>
-constexpr auto InsertCopyOut(Expr, Params)
-{
-    if constexpr (IsParam_v<Expr>) {
-        return Expr{}; // Do not copy out on a no-op
-    } else {
-        // Reversing Params is for more natural copy order
-        return ForEach(Reverse_t<Params>{}, CopyOutInserter{}, Expr{});
+struct AllocInserter {
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) const
+    {
+        using ParamUse = typename T::Type;
+        using Param = Util::TMP::Get_t<ParamUse, 0>;
+        constexpr auto firstUse = Util::TMP::Get_t<ParamUse, 1>::value;
+        using OldItem = Util::TMP::Get_t<ExprList, firstUse>;
+        using NewItem = OpAndThen<OpAlloc<Param>, OldItem>;
+        return Util::TMP::Set_t<ExprList, firstUse, NewItem>{};
     }
-}
+};
 
-struct SubexpressionProcessor {
-    template <typename T, typename Data>
-    constexpr auto operator()(T, Data)
+struct FreeInserter {
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) const
     {
-        using Expr = typename T::Type;
-        using InParams = ExprTmpl::InParams_t<Expr>;
-        using OutParams = ExprTmpl::OutParams_t<Expr>;
-
-        using ParamsToCopyIn =
-            Intersection_t<InParams, typename Data::UnusedInParams>;
-        using Result1 = decltype(InsertCopyIn(Expr{}, ParamsToCopyIn{}));
-
-        using OutOnlyParams = Difference_t<OutParams, InParams>;
-        using Result2 = decltype(InsertCopyOut(Result1{}, OutOnlyParams{}));
-
-        return ProcessData<
-            Difference_t<typename Data::UnusedInParams, ParamsToCopyIn>,
-            Append_t<typename Data::Result, Result2>>{};
+        using ParamUse = typename T::Type;
+        using Param = Util::TMP::Get_t<ParamUse, 0>;
+        constexpr auto lastUse = Util::TMP::Get_t<ParamUse, 2>::value;
+        using OldItem = Util::TMP::Get_t<ExprList, lastUse>;
+        using NewItem = OpAndThen<OldItem, OpFree<Param>>;
+        return Util::TMP::Set_t<ExprList, lastUse, NewItem>{};
     }
 };
 
@@ -647,24 +708,39 @@ constexpr auto AddCopyOnDemand(Expression<T> expr)
 {
     if constexpr (CopyFlag == CopyOnDemand::yes) {
         using Expr = typename decltype(expr)::Type;
-        using InParams = ExprTmpl::InParams_t<Expr>;
-
-        auto subexpressionList = FlattenAtOpAndThen(expr);
-        auto processed =
-            ForEach(subexpressionList, SubexpressionProcessor{},
-                    ProcessData<InParams>{});
-
-        using OutParams = ExprTmpl::OutParams_t<Expr>;
-        using InOutParams = Intersection_t<InParams, OutParams>;
-        auto addedFinalCopyOut = ForEach(
-            InOutParams{},
-            [](auto t, auto data) {
-                using Param = typename decltype(t)::Type;
-                return Append_t<decltype(data), OpCopyOutParam<Param>>{};
-            },
-            processed);
-        return BuildExpression(
-            typename decltype(addedFinalCopyOut)::Result{});
+        using ExprList = typename FlattenAtOpAndThen<Expr>::Type;
+
+        // 1. Collect all parameters used
+        using Params = ExprTmpl::Params_t<Expr>;
+
+        // 2. Get a type list of type lists of three items:
+        //      (Param, FirstUseConst, LastUseConst)
+        using ParamUseList =
+            Util::TMP::Map_t<FirstAndLastUseFinder<ExprList>::template Type,
+                             Params>;
+
+        // 3. For each input Param in ParamUseList, add an OpCopyInParam
+        //    before its first use.
+        auto result1 =
+            Util::TMP::ForEach(ParamUseList{}, CopyInInserter{}, ExprList{});
+
+        // 4. For each output Param in ParamUseList, add an OpCopyOutParam
+        //    after its last use.
+        auto result2 =
+            Util::TMP::ForEach(ParamUseList{}, CopyOutInserter{}, result1);
+
+        // 5. For each Param in ParamUseList, add an OpAlloc before its first use.
+        auto result3 =
+            Util::TMP::ForEach(ParamUseList{}, AllocInserter{}, result2);
+
+        // 6. For each Param in ParamUseList, add an OpFree after its first
+        // use.
+        auto result4 =
+            Util::TMP::ForEach(ParamUseList{}, FreeInserter{}, result3);
+
+        using Result = typename BuildExpression<decltype(result4)>::Type;
+        return Result{};
+        ;
     } else {
         return expr;
     }
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index b00cc4ba8..2e7a2a8ef 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -306,6 +306,35 @@ struct UniqueParams {
 
 } // namespace Detail
 
+template <typename T, std::size_t N>
+struct IsParamN : std::false_type {};
+
+template <std::size_t N, typename T, ExprTmpl::ParamUsage U>
+struct IsParamN<ExprTmpl::Param<N, T, U>, N> : std::true_type {};
+
+template <std::size_t N>
+struct IsParamNChecker {
+    template <typename T>
+    using Type = IsParamN<T, N>;
+};
+
+template <typename T, std::size_t N>
+struct HasParamN {
+private:
+    using ParamsInT = typename ExprTmpl::Detail::UniqueParams<T>::Type;
+
+public:
+    static constexpr bool value =
+        Util::TMP::Find_v<IsParamNChecker<N>::template Type, ParamsInT> !=
+        Util::TMP::Size_v<ParamsInT>;
+};
+
+template <std::size_t N>
+struct HasParamNChecker {
+    template <typename T>
+    using Type = HasParamN<T, N>;
+};
+
 template <typename T>
 struct LocalVars {
     using Type =
@@ -369,6 +398,18 @@ struct OutParams {
 template <typename T>
 using OutParams_t = typename OutParams<T>::Type;
 
+template <typename T>
+struct OpAlloc : UnaryOp<T> {
+    OpAlloc() = default;
+    constexpr OpAlloc(T t) : UnaryOp<T>(t) {}
+};
+
+template <typename T>
+struct OpFree : UnaryOp<T> {
+    OpFree() = default;
+    constexpr OpFree(T t) : UnaryOp<T>(t) {}
+};
+
 template <typename T>
 struct OpCopyInParam : UnaryOp<T> {
     OpCopyInParam() = default;
-- 
Gitee


From 1f0878590832785b310855d94021bc663ba87788 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 17:36:37 +0800
Subject: [PATCH 081/116] Make minor adjustments

---
 .../expression_template/block_emulation2.h      | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index c1ca42615..1b9054218 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -720,21 +720,24 @@ constexpr auto AddCopyOnDemand(Expression<T> expr)
                              Params>;
 
         // 3. For each input Param in ParamUseList, add an OpCopyInParam
-        //    before its first use.
+        //    before its first use.  Reverse order makes the result "look"
+        //    better.
         auto result1 =
-            Util::TMP::ForEach(ParamUseList{}, CopyInInserter{}, ExprList{});
+            Util::TMP::ForEach(Util::TMP::Reverse_t<ParamUseList>{},
+                               CopyInInserter{}, ExprList{});
 
         // 4. For each output Param in ParamUseList, add an OpCopyOutParam
         //    after its last use.
         auto result2 =
             Util::TMP::ForEach(ParamUseList{}, CopyOutInserter{}, result1);
 
-        // 5. For each Param in ParamUseList, add an OpAlloc before its first use.
-        auto result3 =
-            Util::TMP::ForEach(ParamUseList{}, AllocInserter{}, result2);
+        // 5. For each Param in ParamUseList, add an OpAlloc before its
+        //    first use.  Reverse order makes the result "look" better.
+        auto result3 = Util::TMP::ForEach(
+            Util::TMP::Reverse_t<ParamUseList>{}, AllocInserter{}, result2);
 
-        // 6. For each Param in ParamUseList, add an OpFree after its first
-        // use.
+        // 6. For each Param in ParamUseList, add an OpFree after its last
+        //    use.
         auto result4 =
             Util::TMP::ForEach(ParamUseList{}, FreeInserter{}, result3);
 
-- 
Gitee


From d3d4644c1e87661aa9d64f6d33b2a857477ff571 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 17:43:03 +0800
Subject: [PATCH 082/116] Rename CopyOnDemand to AutoOpOnDemand

---
 .../expression_template/block_emulation2.h         | 14 +++++++-------
 .../expression_template/expr_template_demo.cpp     |  9 ++++-----
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 1b9054218..24241d9e9 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -701,12 +701,12 @@ struct FreeInserter {
     }
 };
 
-enum class CopyOnDemand { no, yes };
+enum class AutoOpOnDemand { no, yes };
 
-template <CopyOnDemand CopyFlag = CopyOnDemand::yes, typename T>
+template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes, typename T>
 constexpr auto AddCopyOnDemand(Expression<T> expr)
 {
-    if constexpr (CopyFlag == CopyOnDemand::yes) {
+    if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
         using Expr = typename decltype(expr)::Type;
         using ExprList = typename FlattenAtOpAndThen<Expr>::Type;
 
@@ -749,12 +749,12 @@ constexpr auto AddCopyOnDemand(Expression<T> expr)
     }
 }
 
-template <CopyOnDemand CopyFlag = CopyOnDemand::yes, typename ExprMaker,
-          typename... Args>
+template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes,
+          typename ExprMaker, typename... Args>
 void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
     auto expr =
-        AddCopyOnDemand<CopyFlag>(maker.template Get<BlockTensor>());
+        AddCopyOnDemand<AutoOpFlag>(maker.template Get<BlockTensor>());
     using Expr = typename decltype(expr)::Type;
     static_assert(
         !Expr::hasData,
@@ -787,7 +787,7 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     if (i < len) {
         std::size_t sizeTB = len - i;  // tail-block size
         auto exprTB =
-            AddCopyOnDemand<CopyFlag>(maker.template Get<SimpleTensor>());
+            AddCopyOnDemand<AutoOpFlag>(maker.template Get<SimpleTensor>());
         using ExprTB = typename decltype(exprTB)::Type;
         using ParamsTB = Params_t<ExprTB>;
 
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 812cea379..b1283ae5f 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -1,7 +1,6 @@
 #include <algorithm>
 #include <cstddef>
 #include <iostream>
-#include <type_traits>
 #include <vector>
 #include "block_emulation1.h"
 #include "block_emulation2.h"
@@ -169,8 +168,8 @@ int main() // NOLINT(bugprone-exception-escape)
         GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
         GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
         GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
-        DoElementwise<CopyOnDemand::no>(AddOpWithManualCopy<float>{},
-                                        t1, t2, t3);
+        DoElementwise<AutoOpOnDemand::no>(AddOpWithManualCopy<float>{}, t1,
+                                          t2, t3);
     }
     std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
               << '\n';
@@ -181,8 +180,8 @@ int main() // NOLINT(bugprone-exception-escape)
         GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
         GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
         GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
-        DoElementwise<CopyOnDemand::yes>(AddOpWithCopyOnDemand<float>{},
-                                         t1, t2, t3);
+        DoElementwise<AutoOpOnDemand::yes>(AddOpWithCopyOnDemand<float>{},
+                                           t1, t2, t3);
     }
     std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
               << '\n';
-- 
Gitee


From 3b9cfd24bea92f96d05bc659db54453897ab6358 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 12 Nov 2025 17:46:33 +0800
Subject: [PATCH 083/116] Rename AddCopyOnDemand to AddOpOnDemand

---
 best_practices/expression_template/block_emulation2.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 24241d9e9..65abff65e 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -704,7 +704,7 @@ struct FreeInserter {
 enum class AutoOpOnDemand { no, yes };
 
 template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes, typename T>
-constexpr auto AddCopyOnDemand(Expression<T> expr)
+constexpr auto AddOpOnDemand(Expression<T> expr)
 {
     if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
         using Expr = typename decltype(expr)::Type;
@@ -754,7 +754,7 @@ template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes,
 void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
     auto expr =
-        AddCopyOnDemand<AutoOpFlag>(maker.template Get<BlockTensor>());
+        AddOpOnDemand<AutoOpFlag>(maker.template Get<BlockTensor>());
     using Expr = typename decltype(expr)::Type;
     static_assert(
         !Expr::hasData,
@@ -787,7 +787,7 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     if (i < len) {
         std::size_t sizeTB = len - i;  // tail-block size
         auto exprTB =
-            AddCopyOnDemand<AutoOpFlag>(maker.template Get<SimpleTensor>());
+            AddOpOnDemand<AutoOpFlag>(maker.template Get<SimpleTensor>());
         using ExprTB = typename decltype(exprTB)::Type;
         using ParamsTB = Params_t<ExprTB>;
 
-- 
Gitee


From 63ee516a1634a90ebee523ef7277db2c7e91eabf Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 14 Nov 2025 11:57:40 +0800
Subject: [PATCH 084/116] Add debug print code

---
 .../expression_template/block_emulation2.h    |   3 +-
 best_practices/expression_template/dpopen.c   | 294 ++++++++++++++++++
 best_practices/expression_template/dpopen.h   |  33 ++
 .../expr_template_demo.cpp                    |  16 +
 .../expression_template/pipeline.cpp          |  90 ++++++
 best_practices/expression_template/pipeline.h |  20 ++
 .../expression_template/type_formatter.cpp    |  22 ++
 .../expression_template/type_formatter.h      |  34 ++
 8 files changed, 510 insertions(+), 2 deletions(-)
 create mode 100644 best_practices/expression_template/dpopen.c
 create mode 100644 best_practices/expression_template/dpopen.h
 create mode 100644 best_practices/expression_template/pipeline.cpp
 create mode 100644 best_practices/expression_template/pipeline.h
 create mode 100644 best_practices/expression_template/type_formatter.cpp
 create mode 100644 best_practices/expression_template/type_formatter.h

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 65abff65e..acf695173 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -707,7 +707,7 @@ template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes, typename T>
 constexpr auto AddOpOnDemand(Expression<T> expr)
 {
     if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
-        using Expr = typename decltype(expr)::Type;
+        using Expr = T;
         using ExprList = typename FlattenAtOpAndThen<Expr>::Type;
 
         // 1. Collect all parameters used
@@ -743,7 +743,6 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
 
         using Result = typename BuildExpression<decltype(result4)>::Type;
         return Result{};
-        ;
     } else {
         return expr;
     }
diff --git a/best_practices/expression_template/dpopen.c b/best_practices/expression_template/dpopen.c
new file mode 100644
index 000000000..83a1902e9
--- /dev/null
+++ b/best_practices/expression_template/dpopen.c
@@ -0,0 +1,294 @@
+// -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+// vim:tabstop=4:shiftwidth=4:expandtab:
+
+/**
+ * @file  dpopen.c
+ *
+ * Implementation of a duplex pipe stream.
+ *
+ * @date  2025-11-14
+ */
+
+#include "dpopen.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#ifdef _REENTRANT
+#include <pthread.h>
+static pthread_mutex_t chain_mtx = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+/** Struct to store duplex-pipe-specific information. */
+struct dpipe_chain {
+    int                fd;     ///< File descriptor of the duplex pipe
+    pid_t              pid;    ///< Process ID of the command
+    struct dpipe_chain *next;  ///< Pointer to the next one in chain
+};
+
+/** Typedef to make the struct easier to use. */
+typedef struct dpipe_chain dpipe_t;
+
+/** Header of the chain of opened duplex pipe streams. */
+static dpipe_t *chain_hdr;
+
+static void do_child(const char *command, int parent, int child)
+{
+    dpipe_t *chain;
+
+    /* Close the other end */
+    close(parent);
+
+    /* Duplicate to stdin and stdout */
+    if (child != STDIN_FILENO) {
+        if (dup2(child, STDIN_FILENO) < 0) {
+            _exit(126);
+        }
+    }
+    if (child != STDOUT_FILENO) {
+        if (dup2(child, STDOUT_FILENO) < 0) {
+            _exit(126);
+        }
+    }
+
+    /* Close this end too after it is duplicated to standard I/O */
+    close(child);
+
+    /* Close all previously opened pipe streams, as popen does */
+    for (chain = chain_hdr; chain != NULL; chain = chain->next) {
+        close(chain->fd);
+    }
+
+    /* Execute the command via sh */
+    execl("/bin/sh", "sh", "-c", command, NULL);
+}
+
+/**
+ * Initiates a duplex pipe from/to a process (raw fd version).
+ *
+ * Like \e popen, all previously opened pipe streams will be closed
+ * in the child process.
+ *
+ * @param command  the command to execute on \c sh
+ * @return         a file descriptor on successful completion; \c -1
+ *                 otherwise
+ */
+int dpopen_raw(const char *command)
+{
+    int     fd[2];
+    int     parent;
+    int     child;
+    pid_t   pid;
+    dpipe_t *chain;
+
+    /* Create a duplex pipe using the BSD socketpair call */
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0) {
+        return -1;
+    }
+    parent = fd[0];
+    child  = fd[1];
+
+#ifdef SO_NOSIGPIPE
+    /* Prevent SIGPIPE on write to closed socket */
+    {
+        int set = 1;
+        setsockopt(parent, SOL_SOCKET, SO_NOSIGPIPE, &set, sizeof(set));
+    }
+#endif
+
+    /* Fork the process and check whether it is successful */
+    if ((pid = fork()) < 0) {
+        close(parent);
+        close(child);
+        return -1;
+    }
+
+    if (pid == 0) {                         /* child */
+        /* Do things in the child process; it should not return */
+        do_child(command, parent, child);
+        /* Exit the child process if execl fails */
+        _exit(127);
+    } else {                                /* parent */
+        /* Close the other end */
+        close(child);
+        /* Allocate memory for the dpipe_t struct */
+        chain = (dpipe_t *)malloc(sizeof(dpipe_t));
+        if (chain == NULL) {
+            close(parent);
+            return -1;
+        }
+        /* Store necessary info for dpclose_raw, and adjust chain header */
+        chain->fd  = parent;
+        chain->pid = pid;
+#ifdef _REENTRANT
+        pthread_mutex_lock(&chain_mtx);
+#endif
+        chain->next = chain_hdr;
+        chain_hdr   = chain;
+#ifdef _REENTRANT
+        pthread_mutex_unlock(&chain_mtx);
+#endif
+        /* Successfully return here */
+        return parent;
+    }
+}
+
+/**
+ * Initiates a duplex pipe stream from/to a process.
+ *
+ * Like \e popen, all previously #dpopen'd pipe streams will be closed
+ * in the child process.
+ *
+ * @param command  the command to execute on \c sh
+ * @return         a pointer to an open stream on successful
+ *                 completion; \c NULL otherwise
+ */
+FILE *dpopen(const char *command)
+{
+    int  fd;
+    FILE *stream;
+
+    fd = dpopen_raw(command);
+    if (fd < 0) {
+        return NULL;
+    }
+    stream = fdopen(fd, "r+");
+    if (stream == NULL) {
+        dpclose_raw(fd);
+        return NULL;
+    }
+    return stream;
+}
+
+/**
+ * Closes a duplex pipe from/to a process (raw fd version).
+ *
+ * @param fd  file descriptor returned from a previous #dpopen_raw call
+ * @return    the wait status of the command if successful; \c -1 if an
+ *            error occurs
+ */
+int dpclose_raw(int fd)
+{
+    int     status;
+    pid_t   pid;
+    pid_t   wait_res;
+    dpipe_t *cur;
+    dpipe_t **ptr;
+
+    /* Search for the fd starting from chain header */
+#ifdef _REENTRANT
+    pthread_mutex_lock(&chain_mtx);
+#endif
+    ptr = &chain_hdr;
+    while ((cur = *ptr) != NULL) {          /* Not end of chain */
+        if (cur->fd == fd) {                /* fd found */
+            pid = cur->pid;
+            *ptr = cur->next;
+#ifdef _REENTRANT
+            pthread_mutex_unlock(&chain_mtx);
+#endif
+            free(cur);
+            close(fd);
+            do {
+                wait_res = waitpid(pid, &status, 0);
+            } while (wait_res == -1 && errno == EINTR);
+            if (wait_res == -1) {
+                return -1;
+            }
+            return status;
+        }
+        ptr = &cur->next;                   /* Check next */
+    }
+#ifdef _REENTRANT
+    pthread_mutex_unlock(&chain_mtx);
+#endif
+    errno = EBADF;              /* If the given stream is not found */
+    return -1;
+}
+
+/**
+ * Closes a duplex pipe stream from/to a process.
+ *
+ * @param stream  pointer to a pipe stream returned from a previous
+ *                #dpopen call
+ * @return        the wait status of the command if successful; \c -1
+ *                if an error occurs
+ */
+int dpclose(FILE *stream)
+{
+    int     fd;
+    int     status;
+    pid_t   pid;
+    pid_t   wait_res;
+    dpipe_t *cur;
+    dpipe_t **ptr;
+
+    fd = fileno(stream);
+
+    /* Search for the fd starting from chain header */
+#ifdef _REENTRANT
+    pthread_mutex_lock(&chain_mtx);
+#endif
+    ptr = &chain_hdr;
+    while ((cur = *ptr) != NULL) {          /* Not end of chain */
+        if (cur->fd == fd) {                /* fd found */
+            pid  = cur->pid;
+            *ptr = cur->next;
+#ifdef _REENTRANT
+            pthread_mutex_unlock(&chain_mtx);
+#endif
+            free(cur);
+            if (fclose(stream) != 0) {
+                return -1;
+            }
+            do {
+                wait_res = waitpid(pid, &status, 0);
+            } while (wait_res == -1 && errno == EINTR);
+            if (wait_res == -1) {
+                return -1;
+            }
+            return status;
+        }
+        ptr = &cur->next;                   /* Check next */
+    }
+#ifdef _REENTRANT
+    pthread_mutex_unlock(&chain_mtx);
+#endif
+    errno = EBADF;              /* If the given stream is not found */
+    return -1;
+}
+
+/**
+ * Sends \c EOF to the process at the other end of the duplex pipe (raw
+ * fd version).
+ *
+ * @param fd  file descriptor returned from a previous #dpopen_raw call
+ * @return    \c 0 if successful; \c -1 if an error occurs
+ */
+int dphalfclose_raw(int fd)
+{
+    return shutdown(fd, SHUT_WR);
+}
+
+/**
+ * Flushes the buffer and sends \c EOF to the process at the other end
+ * of the duplex pipe stream.
+ *
+ * @param stream  pointer to a pipe stream returned from a previous
+ *                #dpopen call
+ * @return        \c 0 if successful; \c -1 if an error occurs
+ */
+int dphalfclose(FILE *stream)
+{
+    /* Ensure all data are flushed */
+    if (fflush(stream) == EOF) {
+        return -1;
+    }
+    /* Close pipe for writing */
+    return dphalfclose_raw(fileno(stream));
+}
diff --git a/best_practices/expression_template/dpopen.h b/best_practices/expression_template/dpopen.h
new file mode 100644
index 000000000..a94a4e734
--- /dev/null
+++ b/best_practices/expression_template/dpopen.h
@@ -0,0 +1,33 @@
+// -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+// vim:tabstop=4:shiftwidth=4:expandtab:
+
+/**
+ * @file  dpopen.h
+ *
+ * Header file of a duplex pipe stream.
+ *
+ * @date  2025-11-14
+ */
+
+#ifndef DPOPEN_H
+#define DPOPEN_H
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int dpopen_raw(const char *command);
+int dpclose_raw(int fd);
+int dphalfclose_raw(int fd);
+
+FILE *dpopen(const char *command);
+int dpclose(FILE *stream);
+int dphalfclose(FILE *stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DPOPEN_H */
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index b1283ae5f..8081b90cc 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -11,6 +11,10 @@
 #include "tensor.h"
 #include "util.h" // IWYU pragma: keep
 
+#if DEBUG_PRINT_RESULT
+#include "type_formatter.h"
+#endif
+
 template <typename T>
 struct MyAddOp : ExprTmpl::Maker {
     template <template <typename> class VectorType>
@@ -54,6 +58,14 @@ struct AddOpWithCopyOnDemand {
     }
 };
 
+#if DEBUG_PRINT_RESULT
+#define PRINT_RESULT(x) \
+    std::cout << "Type of (" #x ") is '" \
+              << TypeFormatter::PrettyName<decltype(x)>() << "'\n"
+#else
+#define PRINT_RESULT(x) (void)0
+#endif
+
 int main() // NOLINT(bugprone-exception-escape)
 {
     using namespace ExprTmpl;
@@ -66,6 +78,10 @@ int main() // NOLINT(bugprone-exception-escape)
     [[maybe_unused]] auto result2 = _1 + If(_2, _2, Expression{'0'});
     [[maybe_unused]] auto result3 = 42 + _1;
     auto result4 = (Expression<Param<2, int&, ParamUsage::out>>{} = result3);
+    PRINT_RESULT(result1);
+    PRINT_RESULT(result2);
+    PRINT_RESULT(result3);
+    PRINT_RESULT(result4);
     std::cout << "sizeof result1 is " << sizeof result1 << '\n';
     std::cout << "sizeof result2 is " << sizeof result2 << '\n';
     std::cout << "sizeof result3 is " << sizeof result3 << '\n';
diff --git a/best_practices/expression_template/pipeline.cpp b/best_practices/expression_template/pipeline.cpp
new file mode 100644
index 000000000..180014ae4
--- /dev/null
+++ b/best_practices/expression_template/pipeline.cpp
@@ -0,0 +1,90 @@
+// -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+// vim:tabstop=4:shiftwidth=4:expandtab:
+
+/**
+ * @file  pipeline.cpp
+ *
+ * A C++17 wrapper for dpopen with a simple interface.
+ *
+ * @date  2025-11-14
+ */
+
+#include "pipeline.h"
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <thread>
+#include <errno.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include "dpopen.h"
+
+namespace {
+
+std::string wait_status_string(int status)
+{
+    if (WIFEXITED(status)) {
+        return std::string("command exited with status ") +
+               std::to_string(WEXITSTATUS(status));
+    }
+    if (WIFSIGNALED(status)) {
+        return std::string("command terminated by signal ") +
+               std::to_string(WTERMSIG(status));
+    }
+    return std::string("command stopped by signal ") +
+           std::to_string(WSTOPSIG(status));
+}
+
+} // unnamed namespace
+
+std::string pipeline(const char* command, std::string_view input)
+{
+    int fd = dpopen_raw(command);
+    if (fd < 0) {
+        throw std::system_error(errno, std::system_category(),
+                                "dpopen_raw failed");
+    }
+
+    std::string output;
+    std::thread reader{[fd, &output]() {
+        char    buffer[4096];
+        ssize_t n;
+        while ((n = read(fd, buffer, sizeof buffer)) > 0) {
+            output.append(buffer, n);
+        }
+    }};
+
+    size_t total_written = 0;
+    while (total_written < input.size()) {
+#ifdef MSG_NOSIGNAL
+        /* Prevent SIGPIPE on write to closed socket */
+        ssize_t n = send(fd, input.data() + total_written,
+                         input.size() - total_written, MSG_NOSIGNAL);
+#else
+        ssize_t n = write(fd, input.data() + total_written,
+                          input.size() - total_written);
+#endif
+        if (n <= 0) {
+            break;
+        }
+        total_written += n;
+    }
+    dphalfclose_raw(fd);
+
+    reader.join();
+
+    int status = dpclose_raw(fd);
+    if (status < 0) {
+        throw std::system_error(errno, std::system_category(),
+                                "dpclose_raw failed");
+    }
+    if (status != 0) {
+        throw std::runtime_error(wait_status_string(status));
+    }
+
+    return output;
+}
diff --git a/best_practices/expression_template/pipeline.h b/best_practices/expression_template/pipeline.h
new file mode 100644
index 000000000..63b0f3777
--- /dev/null
+++ b/best_practices/expression_template/pipeline.h
@@ -0,0 +1,20 @@
+// -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+// vim:tabstop=4:shiftwidth=4:expandtab:
+
+/**
+ * @file  pipeline.h
+ *
+ * A C++17 wrapper for dpopen with a simple interface.
+ *
+ * @date  2025-11-14
+ */
+
+#ifndef PIPELINE_H
+#define PIPELINE_H
+
+#include <string>
+#include <string_view>
+
+std::string pipeline(const char* command, std::string_view input);
+
+#endif // PIPELINE_H
diff --git a/best_practices/expression_template/type_formatter.cpp b/best_practices/expression_template/type_formatter.cpp
new file mode 100644
index 000000000..fb39fbc4a
--- /dev/null
+++ b/best_practices/expression_template/type_formatter.cpp
@@ -0,0 +1,22 @@
+#include "type_formatter.h"
+#include <regex>
+#include <stdexcept>
+#include <string_view>
+#include "pipeline.h"
+
+namespace TypeFormatter {
+
+const std::regex toRemove{R"(\b(ExprTmpl::|Util::TMP::))"};
+
+bool CheckClangFormat()
+{
+    try {
+        (void)pipeline("clang-format 2> /dev/null", "");
+    }
+    catch (const std::runtime_error&) {
+        return false;
+    }
+    return true;
+}
+
+} // namespace TypeFormatter
diff --git a/best_practices/expression_template/type_formatter.h b/best_practices/expression_template/type_formatter.h
new file mode 100644
index 000000000..d89d88fdb
--- /dev/null
+++ b/best_practices/expression_template/type_formatter.h
@@ -0,0 +1,34 @@
+#ifndef TYPE_FORMATTER_H
+#define TYPE_FORMATTER_H
+
+#include <cstddef>
+#include <regex>
+#include <string>
+#include <boost/type_index.hpp>
+#include "pipeline.h"
+
+namespace TypeFormatter {
+
+constexpr std::size_t clangFormatTriggerLength = 50;
+
+extern const std::regex toRemove;
+
+bool CheckClangFormat();
+
+template <typename T>
+inline std::string PrettyName()
+{
+    static const bool hasClangFormat = CheckClangFormat();
+
+    std::string name = boost::typeindex::type_id<T>().pretty_name();
+    name = std::regex_replace(name, toRemove, "");
+    if (hasClangFormat && name.size() > clangFormatTriggerLength) {
+        name = pipeline("clang-format", name);
+    }
+
+    return name;
+}
+
+} // namespace TypeFormatter
+
+#endif // TYPE_FORMATTER_H
-- 
Gitee


From 771d69db137ef41fdf334a14fb101f65ce309430 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 14 Nov 2025 14:02:17 +0800
Subject: [PATCH 085/116] Fix tensor test

---
 best_practices/expression_template/tensor_test.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/best_practices/expression_template/tensor_test.cpp b/best_practices/expression_template/tensor_test.cpp
index ad6f39a94..8c97f1cac 100644
--- a/best_practices/expression_template/tensor_test.cpp
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -3,8 +3,11 @@
 #include <cstddef>
 #include <iostream>
 #include <iterator>
+#include "demo_eval.h"
 #include "layout.h"
 
+using namespace Demo;
+
 int main()
 {
     using namespace DemoEval;
-- 
Gitee


From 65149b1f3a7a4f68779525c9e80edb23e285dccb Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 14 Nov 2025 14:35:03 +0800
Subject: [PATCH 086/116] Add CMakeLists.txt

---
 .../expression_template/CMakeLists.txt         | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 best_practices/expression_template/CMakeLists.txt

diff --git a/best_practices/expression_template/CMakeLists.txt b/best_practices/expression_template/CMakeLists.txt
new file mode 100644
index 000000000..cf96553d9
--- /dev/null
+++ b/best_practices/expression_template/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.10)
+project(expr_template_demo)
+
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(Boost)
+find_package(Threads)
+
+add_executable(expr_template_demo expr_template_demo.cpp)
+
+if(Boost_FOUND AND Threads_FOUND)
+    target_compile_definitions(expr_template_demo PRIVATE DEBUG_PRINT_RESULT)
+    target_compile_options(expr_template_demo PRIVATE "-pthread")
+    target_link_libraries(expr_template_demo PRIVATE Threads::Threads)
+    target_sources(expr_template_demo PRIVATE dpopen.c
+                                              pipeline.cpp
+                                              type_formatter.cpp)
+endif()
-- 
Gitee


From f5fe05d117a22b293f73faac33ca5f1c1a64a4e6 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 14 Nov 2025 14:45:48 +0800
Subject: [PATCH 087/116] Add a basic clang-format configuration

---
 .../expression_template/.clang-format         | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 best_practices/expression_template/.clang-format

diff --git a/best_practices/expression_template/.clang-format b/best_practices/expression_template/.clang-format
new file mode 100644
index 000000000..077c7228a
--- /dev/null
+++ b/best_practices/expression_template/.clang-format
@@ -0,0 +1,36 @@
+---
+BasedOnStyle: Google
+IndentWidth: 4
+ColumnLimit: 76
+AccessModifierOffset: -4
+AlignEscapedNewlines: DontAlign
+AlignOperands: false
+AlignTrailingComments: false
+AllowAllConstructorInitializersOnNextLine: true
+AllowShortFunctionsOnASingleLine: Inline
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterFunction: true
+  SplitEmptyFunction: true
+BreakConstructorInitializers: BeforeColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+FixNamespaceComments: true
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 2
+DerivePointerAlignment: false
+PointerAlignment: Left
+SpacesBeforeTrailingComments: 1
+
+SortIncludes: true
+IncludeBlocks: Preserve
+IncludeCategories: 
+  - Regex:           '^<.*/.*>$'
+    Priority:        3
+  - Regex:           '^<.*\.h>$'
+    Priority:        2
+  - Regex:           '^<'
+    Priority:        1
+  - Regex:           '.*'
+    Priority:        4
+...
-- 
Gitee


From 0ec48204c119e927dd07817060c549f7ce00c5ef Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 14 Nov 2025 16:35:56 +0800
Subject: [PATCH 088/116] Add sync point calculation logic

---
 .../expression_template/block_emulation2.h    | 31 +++++++++++++++++++
 best_practices/expression_template/util.h     | 18 +++++++++++
 2 files changed, 49 insertions(+)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index acf695173..6c57a3730 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -639,6 +639,26 @@ struct FirstAndLastUseFinder {
     using Type = FirstAndLastUse<ExprList, Param>;
 };
 
+template <typename List>
+struct HasCopyInOp;
+
+template <typename Param, typename FirstUse, typename LastUse>
+struct HasCopyInOp<TypeList<Param, FirstUse, LastUse>> {
+    using Type = std::conditional_t<(Param::usage == ParamUsage::in ||
+                                     Param::usage == ParamUsage::in_out),
+                                    FirstUse, TypeList<>>;
+};
+
+template <typename List>
+struct HasCopyOutOp;
+
+template <typename Param, typename FirstUse, typename LastUse>
+struct HasCopyOutOp<TypeList<Param, FirstUse, LastUse>> {
+    using Type = std::conditional_t<(Param::usage == ParamUsage::out ||
+                                     Param::usage == ParamUsage::in_out),
+                                    LastUse, TypeList<>>;
+};
+
 struct CopyInInserter {
     template <typename T, typename ExprList>
     constexpr auto operator()(T, ExprList) const
@@ -719,6 +739,17 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
             Util::TMP::Map_t<FirstAndLastUseFinder<ExprList>::template Type,
                              Params>;
 
+        // TODO: Insert sync.  Positions are calculated below.
+        using HasCopyInExprIndexList =
+            Util::TMP::Filter_t<Util::TMP::IsNotEmpty,
+                                Util::TMP::Unique_t<Util::TMP::Map_t<
+                                    HasCopyInOp, ParamUseList>>>;
+
+        using HasCopyOutExprIndexList =
+            Util::TMP::Filter_t<Util::TMP::IsNotEmpty,
+                                Util::TMP::Unique_t<Util::TMP::Map_t<
+                                    HasCopyOutOp, ParamUseList>>>;
+
         // 3. For each input Param in ParamUseList, add an OpCopyInParam
         //    before its first use.  Reverse order makes the result "look"
         //    better.
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 80ef0d7bb..be0430497 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -525,6 +525,24 @@ struct Get<TypeList<>, N> {
 template <typename List, std::size_t N>
 using Get_t = typename Get<List, N>::Type;
 
+template <typename List>
+struct IsEmpty : std::false_type {};
+
+template <>
+struct IsEmpty<TypeList<>> : std::true_type {};
+
+template <typename List>
+inline constexpr bool IsEmpty_v = IsEmpty<List>::value;
+
+template <typename List>
+struct IsNotEmpty : std::true_type {};
+
+template <>
+struct IsNotEmpty<TypeList<>> : std::false_type {};
+
+template <typename List>
+inline constexpr bool IsNotEmpty_v = IsNotEmpty<List>::value;
+
 template <template <typename> class Proc, typename List>
 struct Map;
 
-- 
Gitee


From d9ba0ac8f6a07079312e48f3d01a8e6c6dce1ca9 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Fri, 14 Nov 2025 16:57:32 +0800
Subject: [PATCH 089/116] Use using to simplify some code

---
 .../expression_template/block_emulation2.h    | 93 ++++++++++---------
 1 file changed, 47 insertions(+), 46 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 6c57a3730..12f65a78e 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -22,10 +22,18 @@ using namespace ExprTmpl;
 using Util::TMP::Append_t;
 using Util::TMP::Concatenate_t;
 using Util::TMP::Difference_t;
+using Util::TMP::Filter_t;
 using Util::TMP::FindUnique_t;
+using Util::TMP::Find_v;
+using Util::TMP::FindLast_v;
+using Util::TMP::Get_t;
+using Util::TMP::IsNotEmpty;
 using Util::TMP::Intersection_t;
+using Util::TMP::Map_t;
 using Util::TMP::Reverse_t;
+using Util::TMP::Set_t;
 using Util::TMP::Size_v;
+using Util::TMP::Unique_t;
 
 // Primary template
 template <typename T>
@@ -94,8 +102,8 @@ template <typename LocalVars, typename LocalVarTup, typename ArgTup,
 void MakeAlikeLocalVarsImpl(LocalVarTup& localVars, const ArgTup& args,
                             std::index_sequence<Ints...>)
 {
-    (MakeAlikeOneLocalVar<Util::TMP::Get_t<LocalVars, Ints>>(
-         std::get<Ints>(localVars), args),
+    (MakeAlikeOneLocalVar<Get_t<LocalVars, Ints>>(std::get<Ints>(localVars),
+                                                  args),
      ...);
 }
 
@@ -139,8 +147,7 @@ constexpr auto ConstructParam(Arg... arg)
 template <typename Params, std::size_t... Ints, typename... Arg>
 constexpr auto PrepareParamsImpl(std::index_sequence<Ints...>, Arg... arg)
 {
-    return std::make_tuple(
-        ConstructParam<Util::TMP::Get_t<Params, Ints>>(arg...)...);
+    return std::make_tuple(ConstructParam<Get_t<Params, Ints>>(arg...)...);
 }
 
 template <typename Params, std::size_t Index, typename ParamTup,
@@ -148,8 +155,8 @@ template <typename Params, std::size_t Index, typename ParamTup,
 constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
 {
     constexpr auto pos =
-        Util::TMP::Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
-    if constexpr (pos < Util::TMP::Size_v<Params>) {
+        Find_v<CheckVarNum<Index + 1>::template Checker, Params>;
+    if constexpr (pos < Size_v<Params>) {
         return std::get<pos>(params);
     } else {
         return std::get<Index>(args);
@@ -168,7 +175,7 @@ template <typename Params, std::size_t Index, ParamUsage... usages,
           typename ParamTup>
 constexpr auto GetOneParam(ParamTup& params)
 {
-    using Param = Util::TMP::Get_t<Params, Index>;
+    using Param = Get_t<Params, Index>;
     if constexpr (((Param::usage == usages) || ...)) {
         return std::forward_as_tuple(std::get<Index>(params));
     } else {
@@ -624,10 +631,10 @@ struct BuildExpression<TypeList<T, U, Rest...>>
 template <typename  ExprList, typename Param>
 struct FirstAndLastUse {
     static constexpr std::size_t firstUse =
-        Util::TMP::Find_v<HasParamNChecker<Param::number>::template Type,
-                          ExprList>;
-    static constexpr std::size_t lastUse = Util::TMP::FindLast_v<
-        HasParamNChecker<Param::number>::template Type, ExprList>;
+        Find_v<HasParamNChecker<Param::number>::template Type, ExprList>;
+    static constexpr std::size_t lastUse =
+        FindLast_v<HasParamNChecker<Param::number>::template Type,
+                   ExprList>;
     using Type = TypeList<Param,
                           std::integral_constant<std::size_t, firstUse>,
                           std::integral_constant<std::size_t, lastUse>>;
@@ -664,13 +671,13 @@ struct CopyInInserter {
     constexpr auto operator()(T, ExprList) const
     {
         using ParamUse = typename T::Type;
-        using Param = Util::TMP::Get_t<ParamUse, 0>;
-        constexpr auto firstUse = Util::TMP::Get_t<ParamUse, 1>::value;
+        using Param = Get_t<ParamUse, 0>;
+        constexpr auto firstUse = Get_t<ParamUse, 1>::value;
         if constexpr (Param::usage == ParamUsage::in ||
                       Param::usage == ParamUsage::in_out) {
-            using OldItem = Util::TMP::Get_t<ExprList, firstUse>;
+            using OldItem = Get_t<ExprList, firstUse>;
             using NewItem = OpAndThen<OpCopyInParam<Param>, OldItem>;
-            return Util::TMP::Set_t<ExprList, firstUse, NewItem>{};
+            return Set_t<ExprList, firstUse, NewItem>{};
         } else {
             return ExprList{};
         }
@@ -682,13 +689,13 @@ struct CopyOutInserter {
     constexpr auto operator()(T, ExprList) const
     {
         using ParamUse = typename T::Type;
-        using Param = Util::TMP::Get_t<ParamUse, 0>;
-        constexpr auto lastUse = Util::TMP::Get_t<ParamUse, 2>::value;
+        using Param = Get_t<ParamUse, 0>;
+        constexpr auto lastUse = Get_t<ParamUse, 2>::value;
         if constexpr (Param::usage == ParamUsage::out ||
                       Param::usage == ParamUsage::in_out) {
-            using OldItem = Util::TMP::Get_t<ExprList, lastUse>;
+            using OldItem = Get_t<ExprList, lastUse>;
             using NewItem = OpAndThen<OldItem, OpCopyOutParam<Param>>;
-            return Util::TMP::Set_t<ExprList, lastUse, NewItem>{};
+            return Set_t<ExprList, lastUse, NewItem>{};
         } else {
             return ExprList{};
         }
@@ -700,11 +707,11 @@ struct AllocInserter {
     constexpr auto operator()(T, ExprList) const
     {
         using ParamUse = typename T::Type;
-        using Param = Util::TMP::Get_t<ParamUse, 0>;
-        constexpr auto firstUse = Util::TMP::Get_t<ParamUse, 1>::value;
-        using OldItem = Util::TMP::Get_t<ExprList, firstUse>;
+        using Param = Get_t<ParamUse, 0>;
+        constexpr auto firstUse = Get_t<ParamUse, 1>::value;
+        using OldItem = Get_t<ExprList, firstUse>;
         using NewItem = OpAndThen<OpAlloc<Param>, OldItem>;
-        return Util::TMP::Set_t<ExprList, firstUse, NewItem>{};
+        return Set_t<ExprList, firstUse, NewItem>{};
     }
 };
 
@@ -713,11 +720,11 @@ struct FreeInserter {
     constexpr auto operator()(T, ExprList) const
     {
         using ParamUse = typename T::Type;
-        using Param = Util::TMP::Get_t<ParamUse, 0>;
-        constexpr auto lastUse = Util::TMP::Get_t<ParamUse, 2>::value;
-        using OldItem = Util::TMP::Get_t<ExprList, lastUse>;
+        using Param = Get_t<ParamUse, 0>;
+        constexpr auto lastUse = Get_t<ParamUse, 2>::value;
+        using OldItem = Get_t<ExprList, lastUse>;
         using NewItem = OpAndThen<OldItem, OpFree<Param>>;
-        return Util::TMP::Set_t<ExprList, lastUse, NewItem>{};
+        return Set_t<ExprList, lastUse, NewItem>{};
     }
 };
 
@@ -736,41 +743,35 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
         // 2. Get a type list of type lists of three items:
         //      (Param, FirstUseConst, LastUseConst)
         using ParamUseList =
-            Util::TMP::Map_t<FirstAndLastUseFinder<ExprList>::template Type,
-                             Params>;
+            Map_t<FirstAndLastUseFinder<ExprList>::template Type, Params>;
 
         // TODO: Insert sync.  Positions are calculated below.
         using HasCopyInExprIndexList =
-            Util::TMP::Filter_t<Util::TMP::IsNotEmpty,
-                                Util::TMP::Unique_t<Util::TMP::Map_t<
-                                    HasCopyInOp, ParamUseList>>>;
+            Filter_t<IsNotEmpty,
+                     Unique_t<Map_t<HasCopyInOp, ParamUseList>>>;
 
         using HasCopyOutExprIndexList =
-            Util::TMP::Filter_t<Util::TMP::IsNotEmpty,
-                                Util::TMP::Unique_t<Util::TMP::Map_t<
-                                    HasCopyOutOp, ParamUseList>>>;
+            Filter_t<IsNotEmpty,
+                     Unique_t<Map_t<HasCopyOutOp, ParamUseList>>>;
 
         // 3. For each input Param in ParamUseList, add an OpCopyInParam
         //    before its first use.  Reverse order makes the result "look"
         //    better.
-        auto result1 =
-            Util::TMP::ForEach(Util::TMP::Reverse_t<ParamUseList>{},
-                               CopyInInserter{}, ExprList{});
+        auto result1 = ForEach(Reverse_t<ParamUseList>{}, CopyInInserter{},
+                               ExprList{});
 
         // 4. For each output Param in ParamUseList, add an OpCopyOutParam
         //    after its last use.
-        auto result2 =
-            Util::TMP::ForEach(ParamUseList{}, CopyOutInserter{}, result1);
+        auto result2 = ForEach(ParamUseList{}, CopyOutInserter{}, result1);
 
         // 5. For each Param in ParamUseList, add an OpAlloc before its
         //    first use.  Reverse order makes the result "look" better.
-        auto result3 = Util::TMP::ForEach(
-            Util::TMP::Reverse_t<ParamUseList>{}, AllocInserter{}, result2);
+        auto result3 =
+            ForEach(Reverse_t<ParamUseList>{}, AllocInserter{}, result2);
 
         // 6. For each Param in ParamUseList, add an OpFree after its last
         //    use.
-        auto result4 =
-            Util::TMP::ForEach(ParamUseList{}, FreeInserter{}, result3);
+        auto result4 = ForEach(ParamUseList{}, FreeInserter{}, result3);
 
         using Result = typename BuildExpression<decltype(result4)>::Type;
         return Result{};
@@ -805,9 +806,9 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     using LocalVars = LocalVars_t<Expr>;
     auto localVars = PrepareLocalVars<LocalVars>(convertedArgs);
 
-    static_assert(Util::TMP::Size_v<InParams> != 0);
+    static_assert(Size_v<InParams> != 0);
     const std::size_t len =
-        std::get<Util::TMP::Get_t<InParams, 0>::number>(argTuple).size();
+        std::get<Get_t<InParams, 0>::number>(argTuple).size();
     const std::size_t lenWholeBlock = len / blockSize * blockSize;
     std::size_t i = 0;
     for (; i < lenWholeBlock; i += blockSize) {
-- 
Gitee


From bf9215c7c64d49c0ad58cc1529a2f9b67794b27b Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 27 Nov 2025 22:38:39 +0800
Subject: [PATCH 090/116] Fix Boost include path in some environments

---
 best_practices/expression_template/CMakeLists.txt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/best_practices/expression_template/CMakeLists.txt b/best_practices/expression_template/CMakeLists.txt
index cf96553d9..f7b70e576 100644
--- a/best_practices/expression_template/CMakeLists.txt
+++ b/best_practices/expression_template/CMakeLists.txt
@@ -11,8 +11,8 @@ add_executable(expr_template_demo expr_template_demo.cpp)
 if(Boost_FOUND AND Threads_FOUND)
     target_compile_definitions(expr_template_demo PRIVATE DEBUG_PRINT_RESULT)
     target_compile_options(expr_template_demo PRIVATE "-pthread")
-    target_link_libraries(expr_template_demo PRIVATE Threads::Threads)
-    target_sources(expr_template_demo PRIVATE dpopen.c
-                                              pipeline.cpp
-                                              type_formatter.cpp)
+    target_link_libraries(expr_template_demo PRIVATE
+                          Boost::boost Threads::Threads)
+    target_sources(expr_template_demo PRIVATE
+                   dpopen.c pipeline.cpp type_formatter.cpp)
 endif()
-- 
Gitee


From c4bc5a166a7d8c7a8e44929596cd5c73b390044e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Thu, 27 Nov 2025 22:51:58 +0800
Subject: [PATCH 091/116] Change some definitions slightly

---
 best_practices/expression_template/util.h | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index be0430497..0835b6445 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -355,9 +355,8 @@ template <typename List>
 struct Size;
 
 template <typename... Ts>
-struct Size<TypeList<Ts...>> {
-    static constexpr std::size_t value = sizeof...(Ts);
-};
+struct Size<TypeList<Ts...>>
+    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
 
 template <typename List>
 inline constexpr std::size_t Size_v = Size<List>::value;
@@ -416,15 +415,12 @@ template <template <typename> class Pred, typename List>
 struct Check;
 
 template <template <typename> class Pred, typename Head, typename... Tail>
-struct Check<Pred, TypeList<Head, Tail...>> {
-    static constexpr bool value =
-        Pred<Head>::value && Check<Pred, TypeList<Tail...>>::value;
-};
+struct Check<Pred, TypeList<Head, Tail...>>
+    : std::bool_constant<Pred<Head>::value &&
+                         Check<Pred, TypeList<Tail...>>::value> {};
 
 template <template <typename> class Pred>
-struct Check<Pred, TypeList<>> {
-    static constexpr bool value = true;
-};
+struct Check<Pred, TypeList<>> : std::true_type {};
 
 template <template <typename> class Pred, typename List>
 inline constexpr bool Check_v = Check<Pred, List>::value;
@@ -636,9 +632,8 @@ template <typename... Tail, typename T>
 struct Contains<TypeList<T, Tail...>, T> : std::true_type {};
 
 template <typename Head, typename... Tail, typename T>
-struct Contains<TypeList<Head, Tail...>, T> {
-    static constexpr bool value = Contains<TypeList<Tail...>, T>::value;
-};
+struct Contains<TypeList<Head, Tail...>, T>
+    : std::bool_constant<Contains<TypeList<Tail...>, T>::value> {};
 
 template <typename List, typename T>
 inline constexpr bool Contains_v = Contains<List, T>::value;
-- 
Gitee


From 1d10d00e0caf9241a11f86b3831028379a8854a9 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Sun, 30 Nov 2025 17:34:49 +0800
Subject: [PATCH 092/116] Improve implementation of Filter

---
 best_practices/expression_template/util.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 0835b6445..c5638e459 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -432,8 +432,8 @@ template <template <typename> class Pred, typename Head, typename... Tail>
 struct Filter<Pred, TypeList<Head, Tail...>> {
     using Type = typename std::conditional_t<
         Pred<Head>::value,
-        Prepend_t<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
-        typename Filter<Pred, TypeList<Tail...>>::Type>;
+        Prepend<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
+        Filter<Pred, TypeList<Tail...>>>::Type;
 };
 
 template <template <typename> class Pred>
-- 
Gitee


From 4ed905bd6fb6f2d3b8578ece1dca8470ce94cc52 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Sun, 30 Nov 2025 23:08:28 +0800
Subject: [PATCH 093/116] Simplify implementation of Concatenate

---
 best_practices/expression_template/util.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index c5638e459..40175bce9 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -401,11 +401,11 @@ struct Concatenate<TypeList<Ts...>, TypeList<Us...>> {
     using Type = TypeList<Ts..., Us...>;
 };
 
-template <typename List1, typename List2, typename List3, typename... Lists>
-struct Concatenate<List1, List2, List3, Lists...> {
+template <typename List1, typename List2, typename... Lists>
+struct Concatenate<List1, List2, Lists...> {
     using Type =
         typename Concatenate<typename Concatenate<List1, List2>::Type,
-                             List3, Lists...>::Type;
+                             Lists...>::Type;
 };
 
 template <typename... Lists>
-- 
Gitee


From 8379bfa5580702ce361eec509665c20ff9779957 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 1 Dec 2025 18:03:32 +0800
Subject: [PATCH 094/116] Remove an unnecessary "Detail::" prefix

---
 best_practices/expression_template/expr_tmpl.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 2e7a2a8ef..e9c4e40fb 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -300,8 +300,7 @@ struct ParamCollector<T, std::enable_if_t<IsTernaryOp_v<T>>> {
 
 template <typename T>
 struct UniqueParams {
-    using Type =
-        Util::TMP::Unique_t<typename Detail::ParamCollector<T>::Type>;
+    using Type = Util::TMP::Unique_t<typename ParamCollector<T>::Type>;
 };
 
 } // namespace Detail
-- 
Gitee


From 468198cfb8764aeca5a055c9f378c95dded2bbcd Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 1 Dec 2025 18:05:56 +0800
Subject: [PATCH 095/116] Remove some unnecessary prefixes

---
 best_practices/expression_template/expr_tmpl.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index e9c4e40fb..739d67d00 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -308,8 +308,8 @@ struct UniqueParams {
 template <typename T, std::size_t N>
 struct IsParamN : std::false_type {};
 
-template <std::size_t N, typename T, ExprTmpl::ParamUsage U>
-struct IsParamN<ExprTmpl::Param<N, T, U>, N> : std::true_type {};
+template <std::size_t N, typename T, ParamUsage U>
+struct IsParamN<Param<N, T, U>, N> : std::true_type {};
 
 template <std::size_t N>
 struct IsParamNChecker {
@@ -320,7 +320,7 @@ struct IsParamNChecker {
 template <typename T, std::size_t N>
 struct HasParamN {
 private:
-    using ParamsInT = typename ExprTmpl::Detail::UniqueParams<T>::Type;
+    using ParamsInT = typename Detail::UniqueParams<T>::Type;
 
 public:
     static constexpr bool value =
-- 
Gitee


From 7e73428eadb98566677fceecbe18da0f5f80b050 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 1 Dec 2025 18:24:37 +0800
Subject: [PATCH 096/116] Replace Check with All

---
 best_practices/expression_template/expr_tmpl.h |  4 ++--
 best_practices/expression_template/util.h      | 15 +++++++++++++++
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 739d67d00..d662631b4 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -345,7 +345,7 @@ private:
     template <typename U>
     struct InRange
         : std::bool_constant<(U::number > 0 && U::number <= size)> {};
-    static_assert(Util::TMP::Check_v<InRange, Type>,
+    static_assert(Util::TMP::All_v<InRange, Type>,
                   "LocalVars must be numbered sequentially from 1");
 };
 
@@ -362,7 +362,7 @@ private:
     template <typename U>
     struct InRange
         : std::bool_constant<(U::number > 0 && U::number <= size)> {};
-    static_assert(Util::TMP::Check_v<InRange, Type>,
+    static_assert(Util::TMP::All_v<InRange, Type>,
                   "Params must be numbered sequentially from 1");
 };
 
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 40175bce9..734b5f0e2 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -411,6 +411,21 @@ struct Concatenate<List1, List2, Lists...> {
 template <typename... Lists>
 using Concatenate_t = typename Concatenate<Lists...>::Type;
 
+template <template <typename> class Pred, typename List>
+struct All;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+struct All<Pred, TypeList<Head, Tail...>>
+    : std::conditional_t<!Pred<Head>::value, std::false_type,
+                         All<Pred, TypeList<Tail...>>> {};
+
+template <template <typename> class Pred>
+struct All<Pred, TypeList<>> : std::true_type {};
+
+template <template <typename> class Pred, typename List>
+inline constexpr bool All_v = All<Pred, List>::value;
+
+// Deprecated: not as generic as All and may not be efficient in some cases
 template <template <typename> class Pred, typename List>
 struct Check;
 
-- 
Gitee


From e59f327dbab5f1b81b08e978b12fb7c27007bc90 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 1 Dec 2025 19:08:28 +0800
Subject: [PATCH 097/116] Remove some unnecessary code

---
 best_practices/expression_template/block_emulation2.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 12f65a78e..9bd08d9dc 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -19,16 +19,13 @@ namespace BlockEmulation2 {
 using namespace Demo;
 using namespace ExprTmpl;
 
-using Util::TMP::Append_t;
 using Util::TMP::Concatenate_t;
-using Util::TMP::Difference_t;
 using Util::TMP::Filter_t;
 using Util::TMP::FindUnique_t;
 using Util::TMP::Find_v;
 using Util::TMP::FindLast_v;
 using Util::TMP::Get_t;
 using Util::TMP::IsNotEmpty;
-using Util::TMP::Intersection_t;
 using Util::TMP::Map_t;
 using Util::TMP::Reverse_t;
 using Util::TMP::Set_t;
@@ -141,7 +138,7 @@ constexpr auto ConstructParam(Arg... arg)
     // decay_t is very important here.  If ParamType::Type were a
     // reference type and decaying did not happen, the expression below
     // would become a reinterpret_cast: disasters would follow then.
-    return typename std::decay_t<typename ParamType::Type>(arg...);
+    return std::decay_t<typename ParamType::Type>(arg...);
 }
 
 template <typename Params, std::size_t... Ints, typename... Arg>
-- 
Gitee


From 0866b74b91d51855c1dc4bfc6cd38a185d5fbbd0 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 8 Dec 2025 14:26:37 +0800
Subject: [PATCH 098/116] Make a trivial format adjustment

---
 best_practices/expression_template/block_emulation2.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 9bd08d9dc..3d0620c8a 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -625,7 +625,7 @@ struct BuildExpression<TypeList<T, U, Rest...>>
                                                TypeList<U, Rest...>>::Type;
 };
 
-template <typename  ExprList, typename Param>
+template <typename ExprList, typename Param>
 struct FirstAndLastUse {
     static constexpr std::size_t firstUse =
         Find_v<HasParamNChecker<Param::number>::template Type, ExprList>;
-- 
Gitee


From be5953576ca0cdc250e9da6bd1b9d6e2779f21ed Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 9 Dec 2025 15:02:08 +0800
Subject: [PATCH 099/116] Add and test cast support

---
 .../expression_template/block_emulation2.h    | 62 +++++++++++++++++++
 .../expression_template/demo_eval.h           |  2 +-
 .../expr_template_demo.cpp                    | 12 ++--
 3 files changed, 70 insertions(+), 6 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 3d0620c8a..5fafff04e 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -3,6 +3,7 @@
 
 /* Block Emulation 2 */
 
+#include <cmath>
 #include <cstddef>
 #include <stdexcept>
 #include <tuple>
@@ -377,6 +378,16 @@ auto Subtract(const T& src1, const U& src2)
     return src1 - src2;
 }
 
+template <typename Dest, CastMode Mode, typename T>
+Dest Cast(const T& src)
+{
+    if constexpr (Mode == CastMode::round) {
+        return static_cast<Dest>(std::round(src));
+    } else {
+        return static_cast<Dest>(src);
+    }
+}
+
 template <typename T, typename U, typename V>
 void AddAssign(T& dst, const U& src1, const V& src2)
 {
@@ -415,6 +426,23 @@ void AddAssign(Tensor<T, L>& dst,
     }
 }
 
+template <typename Dest, CastMode Mode, typename T>
+void CastAssign(Dest& dst, const T& src)
+{
+    dst = Cast<Dest, Mode>(src);
+}
+
+template <typename Dest, CastMode Mode, typename T, typename L>
+void CastAssign(Tensor<Dest, L>& dst, const Tensor<T, L>& src)
+{
+    if (src.GetSize() != dst.GetSize()) {
+        throw std::logic_error("Destination tensor should be like source");
+    }
+    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+        dst[i] = Cast<Dest, Mode>(src[i]);
+    }
+}
+
 template <typename T>
 void CopyIn(Tensor<T>& dst, const Tensor<T>& src)
 {
@@ -476,6 +504,21 @@ struct Evaluator<OpSubtract<T, U>> {
     }
 };
 
+// Partial specialization for Cast<Dest>(E_x)
+template <typename Dest, CastMode Mode, typename T>
+struct Evaluator<OpCast<Dest, Mode, T>> {
+    using Type = Dest;
+
+    template <typename ArgTup, typename LocalVarTup>
+    Dest operator()(const OpCast<Dest, Mode, T>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Cast<Dest, Mode>(
+            Evaluator<T>{}(op.GetData(), args, localVars));
+    }
+};
+
 // Partial specializtion for E_z = E_x + E_y
 template <typename T, typename U, typename V>
 struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
@@ -497,6 +540,25 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     }
 };
 
+// Partial specializtion for E_y = Cast<Dest, Mode>(E_x)
+template <typename T, typename Dest, CastMode Mode, typename U>
+struct Evaluator<OpAssign<T, OpCast<Dest, Mode, U>>> {
+    using Type = void;
+
+    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, OpCast<Dest, Mode, U>>& op,
+                    OrgArgTup& orgArgs,
+                    ConvArgTup& convArgs,
+                    LocalVarTup& localVars,
+                    std::size_t size) const
+    {
+        CastAssign<Dest, Mode>(
+            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
+            Evaluator<U>{}(op.GetRhs().GetData(), orgArgs, convArgs,
+                           localVars, size));
+    }
+};
+
 // Partial specialization for Alloc(E)
 template <typename T>
 struct Evaluator<OpAlloc<T>> {
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index f3c8924e8..4fbb224f8 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -232,7 +232,7 @@ Dest Cast(const T& src)
     }
 }
 
-// Partial specialization for Cast<T>(E_x)
+// Partial specialization for Cast<Dest, Mode>(E_x)
 template <typename Dest, CastMode Mode, typename T>
 struct Evaluator<OpCast<Dest, Mode, T>> {
     using Type = Dest;
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 8081b90cc..8188121be 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -53,8 +53,9 @@ struct AddOpWithCopyOnDemand {
         using namespace ExprTmpl;
         auto _1 = DefineParam<1, VectorType<T>>();
         auto _2 = DefineParam<2, VectorType<T>>();
-        auto _3 = DefineParam<3, VectorType<T>, ParamUsage::out>();
-        return (_3 = _1 + _2);
+        auto _3 = DefineParam<3, VectorType<double>, ParamUsage::out>();
+        auto tmp = DefineLocalVarLike<1>(_1);
+        return (tmp = _1 + _2, _3 = Cast<double>(tmp));
     }
 };
 
@@ -190,15 +191,16 @@ int main() // NOLINT(bugprone-exception-escape)
     std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
               << '\n';
 
-    std::fill(v3.begin(), v3.end(), 0.0F);
+    //std::fill(v3.begin(), v3.end(), 0.0F);
+    std::vector<double> vd(300);
     {
         using namespace BlockEmulation2;
         GlobalTensor<float> t1(v1.data(), 300, make_layout(300));
         GlobalTensor<float> t2(v2.data(), 300, make_layout(300));
-        GlobalTensor<float> t3(v3.data(), 300, make_layout(300));
+        GlobalTensor<double> t3(vd.data(), 300, make_layout(300));
         DoElementwise<AutoOpOnDemand::yes>(AddOpWithCopyOnDemand<float>{},
                                            t1, t2, t3);
     }
-    std::cout << v3[0] << ' ' << v3[1] << ' ' << v3[2] << " ... " << v3[299]
+    std::cout << vd[0] << ' ' << vd[1] << ' ' << vd[2] << " ... " << vd[299]
               << '\n';
 }
-- 
Gitee


From bca484e66259cdbd94e2cf041c93124cb9a4de94 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 9 Dec 2025 15:41:48 +0800
Subject: [PATCH 100/116] Simplify argument passing with ContextData

---
 .../expression_template/block_emulation2.h    | 186 +++++++-----------
 1 file changed, 68 insertions(+), 118 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 5fafff04e..817652396 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -33,17 +33,25 @@ using Util::TMP::Set_t;
 using Util::TMP::Size_v;
 using Util::TMP::Unique_t;
 
+template <typename OriginalArgs, typename ConvertedArgs, typename LocalVars>
+struct ContextData {
+    OriginalArgs& orgArgs;
+    ConvertedArgs& convArgs;
+    LocalVars& localVars;
+    std::size_t blockSize;
+};
+
+template <typename OriginalArgs, typename ConvertedArgs, typename LocalVars>
+ContextData(OriginalArgs&, ConvertedArgs&, LocalVars&, std::size_t)
+    -> ContextData<OriginalArgs, ConvertedArgs, LocalVars>;
+
 // Primary template
 template <typename T>
 struct Evaluator {
     using Type = T;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    decltype(auto) operator()(const T& value,
-                              OrgArgTup& /*orgArgs*/,
-                              ConvArgTup& /*convArgs*/,
-                              LocalVarTup& /*localVars*/,
-                              std::size_t /*size*/) const
+    template <typename Context>
+    decltype(auto) operator()(const T& value, Context& /*context*/) const
     {
         return value;
     }
@@ -283,15 +291,12 @@ template <std::size_t N, typename T, typename L>
 struct Evaluator<LocalVar<N, T, L>> {
     using Type = T;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    template <typename Context>
     decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
-                              OrgArgTup& /*orgArgs*/,
-                              ConvArgTup& /*convArgs*/,
-                              LocalVarTup& localVars,
-                              std::size_t /*size*/) const
+                              Context& context) const
     {
         static_assert(N > 0, "LocalVar number starts from 1");
-        return std::get<N - 1>(localVars);
+        return std::get<N - 1>(context.localVars);
     }
 };
 
@@ -300,26 +305,24 @@ template <std::size_t N, typename T, ParamUsage U>
 struct Evaluator<Param<N, T, U>> {
     using Type = T;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    template <typename Context>
     decltype(auto) operator()(Param<N, T, U> /*unused*/,
-                              OrgArgTup& /*orgArgs*/,
-                              ConvArgTup& convArgs,
-                              LocalVarTup& /*localVars*/,
-                              std::size_t /*size*/) const
+                              Context& context) const
     {
         static_assert(N > 0, "Param number starts from 1");
         constexpr auto index = N - 1;
+        using ConvArgTup = decltype(context.convArgs);
         using NthType =
             std::tuple_element_t<index, std::remove_reference_t<ConvArgTup>>;
         if constexpr (std::is_same_v<T, NthType> ||
                       std::is_same_v<T&, NthType> ||
                       std::is_same_v<T&&, NthType>) {
-            return std::get<index>(convArgs);
+            return std::get<index>(context.convArgs);
         } else {
             static_assert(
                 U == ParamUsage::in,
                 "Only in-parameters allow implicit type conversions");
-            return static_cast<T>(std::get<index>(convArgs));
+            return static_cast<T>(std::get<index>(context.convArgs));
         }
     }
 };
@@ -335,16 +338,11 @@ template <typename T, typename U>
 struct Evaluator<OpAssign<T, U>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    void operator()(const OpAssign<T, U>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    void operator()(const OpAssign<T, U>& op, Context& context) const
     {
-        Assign(
-            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
+        Assign(Evaluator<T>{}(op.GetLhs(), context),
+               Evaluator<U>{}(op.GetRhs(), context));
     }
 };
 
@@ -353,16 +351,12 @@ template <typename T, typename U>
 struct Evaluator<OpAndThen<T, U>> {
     using Type = typename Evaluator<U>::Type;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    Type operator()(const OpAndThen<T, U>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    Type operator()(const OpAndThen<T, U>& op, Context& context) const
     {
         // operator, evaluates sequentially
-        return Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-               Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size);
+        return Evaluator<T>{}(op.GetLhs(), context),
+               Evaluator<U>{}(op.GetRhs(), context);
     }
 };
 
@@ -471,16 +465,11 @@ struct Evaluator<OpAdd<T, U>> {
     using Type = decltype(Add(std::declval<typename Evaluator<T>::Type>(),
                               std::declval<typename Evaluator<U>::Type>()));
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    Type operator()(const OpAdd<T, U>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    Type operator()(const OpAdd<T, U>& op, Context& context) const
     {
-        return Add(
-            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
+        return Add(Evaluator<T>{}(op.GetLhs(), context),
+                   Evaluator<U>{}(op.GetRhs(), context));
     }
 };
 
@@ -491,16 +480,11 @@ struct Evaluator<OpSubtract<T, U>> {
         decltype(Subtract(std::declval<typename Evaluator<T>::Type>(),
                           std::declval<typename Evaluator<U>::Type>()));
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    Type operator()(const OpSubtract<T, U>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    Type operator()(const OpSubtract<T, U>& op, Context& context) const
     {
-        return Subtract(
-            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs(), orgArgs, convArgs, localVars, size));
+        return Subtract(Evaluator<T>{}(op.GetLhs(), context),
+                        Evaluator<U>{}(op.GetRhs(), context));
     }
 };
 
@@ -509,13 +493,10 @@ template <typename Dest, CastMode Mode, typename T>
 struct Evaluator<OpCast<Dest, Mode, T>> {
     using Type = Dest;
 
-    template <typename ArgTup, typename LocalVarTup>
-    Dest operator()(const OpCast<Dest, Mode, T>& op,
-                    ArgTup& args,
-                    LocalVarTup& localVars) const
+    template <typename Context>
+    Dest operator()(const OpCast<Dest, Mode, T>& op, Context& context) const
     {
-        return Cast<Dest, Mode>(
-            Evaluator<T>{}(op.GetData(), args, localVars));
+        return Cast<Dest, Mode>(Evaluator<T>{}(op.GetData(), context));
     }
 };
 
@@ -524,19 +505,13 @@ template <typename T, typename U, typename V>
 struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    template <typename Context>
     void operator()(const OpAssign<T, OpAdd<U, V>>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+                    Context& context) const
     {
-        AddAssign(
-            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs().GetLhs(), orgArgs, convArgs,
-                           localVars, size),
-            Evaluator<V>{}(op.GetRhs().GetRhs(), orgArgs, convArgs,
-                           localVars, size));
+        AddAssign(Evaluator<T>{}(op.GetLhs(), context),
+                  Evaluator<U>{}(op.GetRhs().GetLhs(), context),
+                  Evaluator<V>{}(op.GetRhs().GetRhs(), context));
     }
 };
 
@@ -545,17 +520,13 @@ template <typename T, typename Dest, CastMode Mode, typename U>
 struct Evaluator<OpAssign<T, OpCast<Dest, Mode, U>>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
+    template <typename Context>
     void operator()(const OpAssign<T, OpCast<Dest, Mode, U>>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+                    Context& context) const
     {
         CastAssign<Dest, Mode>(
-            Evaluator<T>{}(op.GetLhs(), orgArgs, convArgs, localVars, size),
-            Evaluator<U>{}(op.GetRhs().GetData(), orgArgs, convArgs,
-                           localVars, size));
+            Evaluator<T>{}(op.GetLhs(), context),
+            Evaluator<U>{}(op.GetRhs().GetData(), context));
     }
 };
 
@@ -564,15 +535,10 @@ template <typename T>
 struct Evaluator<OpAlloc<T>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    void operator()(const OpAlloc<T>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    void operator()(const OpAlloc<T>& op, Context& context) const
     {
-        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
-                                   localVars, size);
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
         // Do nothing for now
         (void)obj;
     }
@@ -583,15 +549,10 @@ template <typename T>
 struct Evaluator<OpFree<T>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    void operator()(const OpFree<T>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    void operator()(const OpFree<T>& op, Context& context) const
     {
-        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
-                                   localVars, size);
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
         // Do nothing for now
         (void)obj;
     }
@@ -602,16 +563,11 @@ template <typename T>
 struct Evaluator<OpCopyInParam<T>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    void operator()(const OpCopyInParam<T>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    void operator()(const OpCopyInParam<T>& op, Context& context) const
     {
-        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
-                                   localVars, size);
-        CopyInParam<T>(obj, orgArgs, size);
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
+        CopyInParam<T>(obj, context.orgArgs, context.blockSize);
     }
 };
 
@@ -620,16 +576,11 @@ template <typename T>
 struct Evaluator<OpCopyOutParam<T>> {
     using Type = void;
 
-    template <typename OrgArgTup, typename ConvArgTup, typename LocalVarTup>
-    void operator()(const OpCopyOutParam<T>& op,
-                    OrgArgTup& orgArgs,
-                    ConvArgTup& convArgs,
-                    LocalVarTup& localVars,
-                    std::size_t size) const
+    template <typename Context>
+    void operator()(const OpCopyOutParam<T>& op, Context& context) const
     {
-        auto& obj = Evaluator<T>{}(op.GetData(), orgArgs, convArgs,
-                                   localVars, size);
-        CopyOutParam<T>(obj, orgArgs, size);
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
+        CopyOutParam<T>(obj, context.orgArgs, context.blockSize);
     }
 };
 
@@ -870,9 +821,9 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
         std::get<Get_t<InParams, 0>::number>(argTuple).size();
     const std::size_t lenWholeBlock = len / blockSize * blockSize;
     std::size_t i = 0;
+    ContextData context{argTuple, convertedArgs, localVars, blockSize};
     for (; i < lenWholeBlock; i += blockSize) {
-        Evaluator<Expr>{}(expr.data, argTuple, convertedArgs, localVars,
-                          blockSize);
+        Evaluator<Expr>{}(expr.data, context);
     }
     if (i < len) {
         std::size_t sizeTB = len - i;  // tail-block size
@@ -890,9 +841,8 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
         auto localVarsTB = GetLocalVarTuple<LocalVarsTB>();
         localVarsTB = localVars;  // Reuse allocated Tensor storage
 
-
-        Evaluator<ExprTB>{}(exprTB.data, argTuple, convertedArgsTB,
-                            localVarsTB, sizeTB);
+        ContextData context{argTuple, convertedArgsTB, localVarsTB, sizeTB};
+        Evaluator<ExprTB>{}(exprTB.data, context);
     }
 
     Util::ForEach(params, [](auto& arg) {
-- 
Gitee


From 5fd4edacb6d4be5cda6670e65a8943926b871c39 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 9 Dec 2025 16:48:45 +0800
Subject: [PATCH 101/116] Support specifying type when using DefineLocalVarLike

---
 best_practices/expression_template/expr_template_demo.cpp | 2 +-
 best_practices/expression_template/expr_tmpl.h            | 8 ++++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 8188121be..3160ea8dc 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -54,7 +54,7 @@ struct AddOpWithCopyOnDemand {
         auto _1 = DefineParam<1, VectorType<T>>();
         auto _2 = DefineParam<2, VectorType<T>>();
         auto _3 = DefineParam<3, VectorType<double>, ParamUsage::out>();
-        auto tmp = DefineLocalVarLike<1>(_1);
+        auto tmp = DefineLocalVarLike<1, VectorType<T>>(_1);
         return (tmp = _1 + _2, _3 = Cast<double>(tmp));
     }
 };
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index d662631b4..d0787ec45 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -117,11 +117,15 @@ constexpr auto DefineLocalVar()
     return Expression<LocalVar<N, T>>{};
 }
 
-template <std::size_t N, typename L>
+template <std::size_t N, typename T = void, typename L>
 constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
 {
     static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
-    return Expression<LocalVar<N, typename L::Type, L>>{};
+    if constexpr (std::is_void_v<T>) {
+        return Expression<LocalVar<N, typename L::Type, L>>{};
+    } else {
+        return Expression<LocalVar<N, T, L>>{};
+    }
 }
 
 template <std::size_t N, typename T, ParamUsage U = ParamUsage::in>
-- 
Gitee


From fa63c2cf94259bcf8e9cc6839c305670898a942d Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 9 Dec 2025 17:07:58 +0800
Subject: [PATCH 102/116] Commit changes missing in last commit

---
 best_practices/expression_template/block_emulation2.h | 8 ++++----
 best_practices/expression_template/demo_eval.h        | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 817652396..a2473ffa4 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -82,14 +82,14 @@ constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
                               LocalVars>::Type{}...);
 }
 
-template <typename T>
-void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+template <typename T, typename U>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<U>& src)
 {
     dst.resize(src.size());
 }
 
-template <typename T, typename L>
-void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<T, L>& src)
+template <typename T, typename U, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<U, L>& src)
 {
     dst.SetSize(src.GetSize());
 }
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index 4fbb224f8..efd5d9e72 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -61,14 +61,14 @@ constexpr auto GetLocalVarTupleImpl(std::index_sequence<Ints...>)
                               LocalVars>::Type{}...);
 }
 
-template <typename T>
-void MakeAlikeDatum(std::vector<T>& dst, const std::vector<T>& src)
+template <typename T, typename U>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<U>& src)
 {
     dst.resize(src.size());
 }
 
-template <typename T, typename L>
-void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<T, L>& src)
+template <typename T, typename U, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<U, L>& src)
 {
     dst.SetSize(src.GetSize());
 }
-- 
Gitee


From 0ff1d680055d6c0e8aa3d256a46a0dcb991dc4dd Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Dec 2025 10:26:46 +0800
Subject: [PATCH 103/116] Make LocalVar and Param collection support TypeList

---
 .../expression_template/expr_tmpl.h           | 46 +++++++++++++++----
 best_practices/expression_template/util.h     | 11 +++++
 2 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index d0787ec45..c3b598dfd 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -243,65 +243,91 @@ inline constexpr bool IsTernaryOp_v = IsTernaryOp<T>::value;
 namespace Detail {
 
 template <typename T, typename = void>
-struct LocalVarCollector {
+struct LocalVarCollectorHelper;
+
+template <typename T>
+using LocalVarCollector = LocalVarCollectorHelper<T>;
+
+template <typename T, typename>
+struct LocalVarCollectorHelper {
     using Type = TypeList<>;
 };
 
 template <typename T>
-struct LocalVarCollector<T, std::enable_if_t<IsLocalVar_v<T>>> {
+struct LocalVarCollectorHelper<T, std::enable_if_t<IsLocalVar_v<T>>> {
     using Type = TypeList<T>;
 };
 
 template <typename T>
-struct LocalVarCollector<T, std::enable_if_t<IsUnaryOp_v<T>>> {
+struct LocalVarCollectorHelper<T, std::enable_if_t<IsUnaryOp_v<T>>> {
     using Type = typename LocalVarCollector<typename T::DataType>::Type;
 };
 
 template <typename T>
-struct LocalVarCollector<T, std::enable_if_t<IsBinaryOp_v<T>>> {
+struct LocalVarCollectorHelper<T, std::enable_if_t<IsBinaryOp_v<T>>> {
     using Type = Util::TMP::Concatenate_t<
         typename LocalVarCollector<typename T::LhsType>::Type,
         typename LocalVarCollector<typename T::RhsType>::Type>;
 };
 
 template <typename T>
-struct LocalVarCollector<T, std::enable_if_t<IsTernaryOp_v<T>>> {
+struct LocalVarCollectorHelper<T, std::enable_if_t<IsTernaryOp_v<T>>> {
     using Type = Util::TMP::Concatenate_t<
         typename LocalVarCollector<typename T::FirstType>::Type,
         typename LocalVarCollector<typename T::SecondType>::Type,
         typename LocalVarCollector<typename T::ThirdType>::Type>;
 };
 
+template <typename... Ts>
+struct LocalVarCollectorHelper<Util::TMP::TypeList<Ts...>> {
+    using Type = Util::TMP::Apply_t<
+        Util::TMP::Concatenate,
+        Util::TMP::Map_t<LocalVarCollector, Util::TMP::TypeList<Ts...>>>;
+};
+
 template <typename T, typename = void>
-struct ParamCollector {
+struct ParamCollectorHelper;
+
+template <typename T>
+using ParamCollector = ParamCollectorHelper<T>;
+
+template <typename T, typename>
+struct ParamCollectorHelper {
     using Type = TypeList<>;
 };
 
 template <typename T>
-struct ParamCollector<T, std::enable_if_t<IsParam_v<T>>> {
+struct ParamCollectorHelper<T, std::enable_if_t<IsParam_v<T>>> {
     using Type = TypeList<T>;
 };
 
 template <typename T>
-struct ParamCollector<T, std::enable_if_t<IsUnaryOp_v<T>>> {
+struct ParamCollectorHelper<T, std::enable_if_t<IsUnaryOp_v<T>>> {
     using Type = typename ParamCollector<typename T::DataType>::Type;
 };
 
 template <typename T>
-struct ParamCollector<T, std::enable_if_t<IsBinaryOp_v<T>>> {
+struct ParamCollectorHelper<T, std::enable_if_t<IsBinaryOp_v<T>>> {
     using Type = Util::TMP::Concatenate_t<
         typename ParamCollector<typename T::LhsType>::Type,
         typename ParamCollector<typename T::RhsType>::Type>;
 };
 
 template <typename T>
-struct ParamCollector<T, std::enable_if_t<IsTernaryOp_v<T>>> {
+struct ParamCollectorHelper<T, std::enable_if_t<IsTernaryOp_v<T>>> {
     using Type = Util::TMP::Concatenate_t<
         typename ParamCollector<typename T::FirstType>::Type,
         typename ParamCollector<typename T::SecondType>::Type,
         typename ParamCollector<typename T::ThirdType>::Type>;
 };
 
+template <typename... Ts>
+struct ParamCollectorHelper<Util::TMP::TypeList<Ts...>> {
+    using Type = Util::TMP::Apply_t<
+        Util::TMP::Concatenate,
+        Util::TMP::Map_t<ParamCollector, Util::TMP::TypeList<Ts...>>>;
+};
+
 template <typename T>
 struct UniqueParams {
     using Type = Util::TMP::Unique_t<typename ParamCollector<T>::Type>;
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 734b5f0e2..9b4046ed4 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -554,6 +554,17 @@ struct IsNotEmpty<TypeList<>> : std::false_type {};
 template <typename List>
 inline constexpr bool IsNotEmpty_v = IsNotEmpty<List>::value;
 
+template <template <typename...> class Proc, typename List>
+struct Apply;
+
+template <template <typename...> class Proc, typename... Args>
+struct Apply<Proc, TypeList<Args...>> {
+    using Type = typename Proc<Args...>::Type;
+};
+
+template <template <typename...> class Proc, typename List>
+using Apply_t = typename Apply<Proc, List>::Type;
+
 template <template <typename> class Proc, typename List>
 struct Map;
 
-- 
Gitee


From 247d3aa0e9b9f9f9ec77576a5178566891469052 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Dec 2025 16:53:32 +0800
Subject: [PATCH 104/116] Mark constexpr where appropriate

---
 best_practices/expression_template/util.h | 143 ++++++++++++++--------
 1 file changed, 92 insertions(+), 51 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 9b4046ed4..c5590c32d 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -39,7 +39,7 @@ template <
     typename Tuple, typename Func,
     std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
                      int> = 0>
-void ForEach(Tuple&& tuple, Func&& func)
+constexpr void ForEach(Tuple&& tuple, Func&& func)
 {
     std::apply(
         [&func](auto&&... args) {
@@ -83,14 +83,14 @@ struct CompressedDataStorage<T, false> {
     template <typename U,
               typename = std::enable_if_t<
                   !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
-    explicit CompressedDataStorage(U&& u) : data_(std::forward<U>(u))
+    constexpr explicit CompressedDataStorage(U&& u) : data_(std::forward<U>(u))
     {
     }
 
     CompressedDataStorage() = default;
 
-    T& Data() { return data_; }
-    const T& Data() const { return data_; }
+    constexpr T& Data() { return data_; }
+    constexpr const T& Data() const { return data_; }
 
 private:
     T data_;
@@ -102,14 +102,14 @@ struct CompressedDataStorage<T, true> : private T {
     template <typename U,
               typename = std::enable_if_t<
                   !std::is_same_v<std::decay_t<U>, CompressedDataStorage>>>
-    explicit CompressedDataStorage(U&& u) : T(std::forward<U>(u))
+    constexpr explicit CompressedDataStorage(U&& u) : T(std::forward<U>(u))
     {
     }
 
     CompressedDataStorage() = default;
 
-    T& Data() { return static_cast<T&>(*this); }
-    const T& Data() const { return static_cast<const T&>(*this); }
+    constexpr T& Data() { return static_cast<T&>(*this); }
+    constexpr const T& Data() const { return static_cast<const T&>(*this); }
 };
 
 // Storage implementations for different compression scenarios
@@ -120,17 +120,17 @@ struct CompressedPairStorage;
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, false, false> {
     template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
         : first_(std::forward<U1>(f)), second_(std::forward<U2>(s))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T1& First() { return first_; }
-    const T1& First() const { return first_; }
-    T2& Second() { return second_; }
-    const T2& Second() const { return second_; }
+    constexpr T1& First() { return first_; }
+    constexpr const T1& First() const { return first_; }
+    constexpr T2& Second() { return second_; }
+    constexpr const T2& Second() const { return second_; }
 
 private:
     T1 first_;
@@ -141,17 +141,23 @@ private:
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, true, false> : private T1 {
     template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
         : T1(std::forward<U1>(f)), second_(std::forward<U2>(s))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T1& First() { return static_cast<T1&>(*this); }
-    const T1& First() const { return static_cast<const T1&>(*this); }
-    T2& Second() { return second_; }
-    const T2& Second() const { return second_; }
+    constexpr T1& First()
+    {
+        return static_cast<T1&>(*this);
+    }
+    constexpr const T1& First() const
+    {
+        return static_cast<const T1&>(*this);
+    }
+    constexpr T2& Second() { return second_; }
+    constexpr const T2& Second() const { return second_; }
 
 private:
     T2 second_;
@@ -161,17 +167,23 @@ private:
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, false, true> : private T2 {
     template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
         : T2(std::forward<U2>(s)), first_(std::forward<U1>(f))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T1& First() { return first_; }
-    const T1& First() const { return first_; }
-    T2& Second() { return static_cast<T2&>(*this); }
-    const T2& Second() const { return static_cast<const T2&>(*this); }
+    constexpr T1& First() { return first_; }
+    constexpr const T1& First() const { return first_; }
+    constexpr T2& Second()
+    {
+        return static_cast<T2&>(*this);
+    }
+    constexpr const T2& Second() const
+    {
+        return static_cast<const T2&>(*this);
+    }
 
 private:
     T1 first_;
@@ -181,33 +193,57 @@ private:
 template <typename T1, typename T2>
 struct CompressedPairStorage<T1, T2, true, true> : private T1, private T2 {
     template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&& s)
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
         : T1(std::forward<U1>(f)), T2(std::forward<U2>(s))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T1& First() { return static_cast<T1&>(*this); }
-    const T1& First() const { return static_cast<const T1&>(*this); }
-    T2& Second() { return static_cast<T2&>(*this); }
-    const T2& Second() const { return static_cast<const T2&>(*this); }
+    constexpr T1& First()
+    {
+        return static_cast<T1&>(*this);
+    }
+    constexpr const T1& First() const
+    {
+        return static_cast<const T1&>(*this);
+    }
+    constexpr T2& Second()
+    {
+        return static_cast<T2&>(*this);
+    }
+    constexpr const T2& Second() const
+    {
+        return static_cast<const T2&>(*this);
+    }
 };
 
 // Case 5: Both can be compressed, same type
 template <typename T>
 struct CompressedPairStorage<T, T, true, true> : private T {
     template <typename U1, typename U2>
-    CompressedPairStorage(U1&& f, U2&&) : T(std::forward<U1>(f))
+    constexpr CompressedPairStorage(U1&& f, U2&&) : T(std::forward<U1>(f))
     {
     }
 
     CompressedPairStorage() = default;
 
-    T& First() { return static_cast<T&>(*this); }
-    const T& First() const { return static_cast<const T&>(*this); }
-    T& Second() { return static_cast<T&>(*this); }
-    const T& Second() const { return static_cast<const T&>(*this); }
+    constexpr T& First()
+    {
+        return static_cast<T&>(*this);
+    }
+    constexpr const T& First() const
+    {
+        return static_cast<const T&>(*this);
+    }
+    constexpr T& Second()
+    {
+        return static_cast<T&>(*this);
+    }
+    constexpr const T& Second() const
+    {
+        return static_cast<const T&>(*this);
+    }
 };
 
 } // namespace Detail
@@ -228,13 +264,13 @@ public:
     template <typename U,
               typename = std::enable_if_t<
                   !std::is_same_v<std::decay_t<U>, CompressedData>>>
-    explicit CompressedData(U&& u) : Storage(std::forward<U>(u))
+    constexpr explicit CompressedData(U&& u) : Storage(std::forward<U>(u))
     {
     }
 
     // Accessors for data
-    T& Data() { return Storage::Data(); }
-    const T& Data() const { return Storage::Data(); }
+    constexpr T& Data() { return Storage::Data(); }
+    constexpr const T& Data() const { return Storage::Data(); }
 
     // Swap
     void swap(CompressedData& other) noexcept
@@ -246,20 +282,22 @@ public:
 
 // Swap function
 template <typename T>
-void swap(CompressedData<T>& lhs, CompressedData<T>& rhs) noexcept
+constexpr void swap(CompressedData<T>& lhs, CompressedData<T>& rhs) noexcept
 {
     lhs.swap(rhs);
 }
 
 // Equality comparison operators
 template <typename T>
-bool operator==(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
+constexpr bool operator==(const CompressedData<T>& lhs,
+                          const CompressedData<T>& rhs)
 {
     return lhs.Data() == rhs.Data();
 }
 
 template <typename T>
-bool operator!=(const CompressedData<T>& lhs, const CompressedData<T>& rhs)
+constexpr bool operator!=(const CompressedData<T>& lhs,
+                          const CompressedData<T>& rhs)
 {
     return !(lhs == rhs);
 }
@@ -282,20 +320,22 @@ public:
     CompressedPair() = default;
 
     // Perfect forwarding constructor
-    template<typename U1, typename U2>
-    CompressedPair(U1&& f, U2&& s)
-        : Storage(std::forward<U1>(f), std::forward<U2>(s)) {}
+    template <typename U1, typename U2>
+    constexpr CompressedPair(U1&& f, U2&& s)
+        : Storage(std::forward<U1>(f), std::forward<U2>(s))
+    {
+    }
 
     // Accessors for first element
-    T1& First() { return Storage::First(); }
-    const T1& First() const { return Storage::First(); }
+    constexpr T1& First() { return Storage::First(); }
+    constexpr const T1& First() const { return Storage::First(); }
 
     // Accessors for second element
-    T2& Second() { return Storage::Second(); }
-    const T2& Second() const { return Storage::Second(); }
+    constexpr T2& Second() { return Storage::Second(); }
+    constexpr const T2& Second() const { return Storage::Second(); }
 
     // Swap
-    void swap(CompressedPair& other) noexcept
+    constexpr void swap(CompressedPair& other) noexcept
     {
         using std::swap;
         swap(First(), other.First());
@@ -310,22 +350,23 @@ CompressedPair(T1&& f, T2&& s)
 
 // Swap function
 template <typename T1, typename T2>
-void swap(CompressedPair<T1, T2>& lhs, CompressedPair<T1, T2>& rhs) noexcept
+constexpr void swap(CompressedPair<T1, T2>& lhs,
+                    CompressedPair<T1, T2>& rhs) noexcept
 {
     lhs.swap(rhs);
 }
 
 // Equality comparison operators
 template <typename T1, typename T2>
-bool operator==(const CompressedPair<T1, T2>& lhs,
-                const CompressedPair<T1, T2>& rhs)
+constexpr bool operator==(const CompressedPair<T1, T2>& lhs,
+                          const CompressedPair<T1, T2>& rhs)
 {
     return lhs.First() == rhs.First() && lhs.Second() == rhs.Second();
 }
 
 template <typename T1, typename T2>
-bool operator!=(const CompressedPair<T1, T2>& lhs,
-                const CompressedPair<T1, T2>& rhs)
+constexpr bool operator!=(const CompressedPair<T1, T2>& lhs,
+                          const CompressedPair<T1, T2>& rhs)
 {
     return !(lhs == rhs);
 }
-- 
Gitee


From ca32dd985a87be41bb7c474cf857249e74ac7d8e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 10 Dec 2025 16:57:31 +0800
Subject: [PATCH 105/116] Add basic multiplication support

---
 .../expression_template/block_emulation2.h    | 27 +++++++
 .../expression_template/demo_eval.h           | 71 +++++++++++++++++++
 .../expression_template/expr_tmpl.h           | 24 +++++++
 3 files changed, 122 insertions(+)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index a2473ffa4..a7e9d36ea 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -420,6 +420,18 @@ void AddAssign(Tensor<T, L>& dst,
     }
 }
 
+template <typename T, typename L, typename U,
+          typename = std::enable_if_t<std::is_arithmetic_v<U>>>
+void MultiplyAssign(Tensor<T, L>& dst, const Tensor<T, L>& src, U value)
+{
+    if (src.GetSize() != dst.GetSize()) {
+        throw std::logic_error("Destination tensor should be like source");
+    }
+    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+        dst[i] = src[i] * value;
+    }
+}
+
 template <typename Dest, CastMode Mode, typename T>
 void CastAssign(Dest& dst, const T& src)
 {
@@ -515,6 +527,21 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     }
 };
 
+// Partial specializtion for E_z = E_x * E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpMultiply<U, V>>> {
+    using Type = void;
+
+    template <typename Context>
+    void operator()(const OpAssign<T, OpMultiply<U, V>>& op,
+                    Context& context) const
+    {
+        MultiplyAssign(Evaluator<T>{}(op.GetLhs(), context),
+                       Evaluator<U>{}(op.GetRhs().GetLhs(), context),
+                       Evaluator<V>{}(op.GetRhs().GetRhs(), context));
+    }
+};
+
 // Partial specializtion for E_y = Cast<Dest, Mode>(E_x)
 template <typename T, typename Dest, CastMode Mode, typename U>
 struct Evaluator<OpAssign<T, OpCast<Dest, Mode, U>>> {
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index efd5d9e72..b8c86558e 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -268,6 +268,48 @@ struct Evaluator<OpAssign<T, U>> {
     }
 };
 
+template <>
+struct Evaluator<TypeList<>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const TypeList<>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+    }
+};
+
+template <typename T>
+struct Evaluator<TypeList<T>> {
+    using Type = typename Evaluator<T>::Type;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const TypeList<T>& /*op*/,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        static_assert(!HasDataTrait<T>::value);
+        return Evaluator<T>{}(T{}, args, localVars);
+    }
+};
+
+template <typename T, typename... Ts>
+struct Evaluator<TypeList<T, Ts...>> {
+    using Type = typename Evaluator<Ts...>::Type;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const TypeList<T>& /*op*/,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        using U = TypeList<Ts...>;
+        static_assert(!HasDataTrait<T>::value);
+        return Evaluator<T>{}(T{}, args, localVars),
+               Evaluator<U>{}(U{}, args, localVars);
+    }
+};
+
 // Partial specializtion for E_x, E_y
 template <typename T, typename U>
 struct Evaluator<OpAndThen<T, U>> {
@@ -334,6 +376,18 @@ void AddAssign(Tensor<T, L>& dst,
     }
 }
 
+template <typename T, typename L, typename U,
+          typename = std::enable_if_t<std::is_arithmetic_v<U>>>
+void MultiplyAssign(Tensor<T, L>& dst, const Tensor<T, L>& src, U value)
+{
+    if (src.GetSize() != dst.GetSize()) {
+        throw std::logic_error("Destination tensor should be like source");
+    }
+    for (std::size_t i = 0, size = dst.GetSize(); i != size; ++i) {
+        dst[i] = src[i] * value;
+    }
+}
+
 template <typename T>
 void CopyIn(Tensor<T>& dst, const Tensor<T>& src)
 {
@@ -405,6 +459,23 @@ struct Evaluator<OpAssign<T, OpAdd<U, V>>> {
     }
 };
 
+// Partial specializtion for E_z = E_x * E_y
+template <typename T, typename U, typename V>
+struct Evaluator<OpAssign<T, OpMultiply<U, V>>> {
+    using Type = void;
+
+    template <typename ArgTup, typename LocalVarTup>
+    void operator()(const OpAssign<T, OpMultiply<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        MultiplyAssign(
+            Evaluator<T>{}(op.GetLhs(), args, localVars),
+            Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
+            Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
+    }
+};
+
 // Partial specialization for CopyIn(E_dst, E_src)
 template <typename T, typename U>
 struct Evaluator<OpCopyInData<T, U>> {
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index c3b598dfd..0cdcfd40c 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -566,6 +566,30 @@ template <typename T, typename U>
     return Expression<OpSubtract<T, U>>{{std::forward<T>(lhs), rhs.data}};
 }
 
+template <typename T, typename U>
+struct OpMultiply : BinaryOp<T, U> {
+    OpMultiply() = default;
+    constexpr OpMultiply(T t, U u) : BinaryOp<T, U>(t, u) {}
+};
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator*(Expression<T> lhs, Expression<U> rhs)
+{
+    return Expression<OpMultiply<T, U>>{{lhs.data, rhs.data}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator*(Expression<T> lhs, U&& rhs)
+{
+    return Expression<OpMultiply<T, U>>{{lhs.data, std::forward<U>(rhs)}};
+}
+
+template <typename T, typename U>
+[[nodiscard]] constexpr auto operator*(T&& lhs, Expression<U> rhs)
+{
+    return Expression<OpMultiply<T, U>>{{std::forward<T>(lhs), rhs.data}};
+}
+
 template <typename T, typename U>
 struct OpCopyInData : BinaryOp<T, U> {
     OpCopyInData() = default;
-- 
Gitee


From 2ccfd5fc031e996bdcfa36e0108999a3a665b217 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 22 Dec 2025 15:55:22 +0800
Subject: [PATCH 106/116] Add TupleSet

---
 best_practices/expression_template/util.h | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index c5590c32d..fc7726912 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -51,6 +51,39 @@ constexpr void ForEach(Tuple&& tuple, Func&& func)
 
 namespace Detail {
 
+template <std::size_t I, typename Tuple, typename NewValue,
+          std::size_t... Is>
+constexpr auto TupleSetImpl(Tuple&& t, NewValue&& newValue,
+                  std::index_sequence<Is...>)
+{
+    auto selector = [&](auto index_constant) -> decltype(auto) {
+        constexpr std::size_t idx = decltype(index_constant)::value;
+        if constexpr (idx == I) {
+            return std::forward<NewValue>(newValue);
+        } else {
+            return std::get<idx>(std::forward<Tuple>(t));
+        }
+    };
+
+    return std::make_tuple(
+        selector(std::integral_constant<std::size_t, Is>{})...);
+}
+
+} // namespace Detail 
+
+template <std::size_t I, typename Tuple, typename NewValue>
+constexpr auto TupleSet(Tuple&& t, NewValue&& newValue)
+{
+    constexpr auto size = std::tuple_size_v<std::remove_reference_t<Tuple>>;
+    static_assert(I < size, "TupleSet: Index out of bounds");
+
+    return Detail::TupleSetImpl<I>(std::forward<Tuple>(t),
+                                   std::forward<NewValue>(newValue),
+                                   std::make_index_sequence<size>{});
+}
+
+namespace Detail {
+
 // Check if compression would cause ambiguity
 template <typename T1, typename T2>
 inline constexpr bool WouldCauseAmbiguity_v =
-- 
Gitee


From 7e292b9222fd150f2ff8c76e39068186ea667aa4 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 22 Dec 2025 17:46:30 +0800
Subject: [PATCH 107/116] Allow passing constants in the expression template

by a major refactoring.  Tuples are used instead of TypeLists where data
may be passed.  Also, OpAndThen now uses tuple under the hood so that
the result looks more "flat".
---
 .../expression_template/block_emulation1.h    |   3 -
 .../expression_template/block_emulation2.h    | 117 +++++++-----------
 .../expression_template/demo_eval.h           |  26 ++--
 .../expression_template/emulation.h           |   3 -
 .../expr_template_demo.cpp                    |   3 +-
 .../expression_template/expr_tmpl.h           |  99 ++++++++++++++-
 6 files changed, 162 insertions(+), 89 deletions(-)

diff --git a/best_practices/expression_template/block_emulation1.h b/best_practices/expression_template/block_emulation1.h
index cfe091c3e..0268d745a 100644
--- a/best_practices/expression_template/block_emulation1.h
+++ b/best_practices/expression_template/block_emulation1.h
@@ -217,9 +217,6 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
     auto expr = maker.template Get<BlockTensor>();
     using Expr = typename decltype(expr)::Type;
-    static_assert(
-        !Expr::hasData,
-        "This expression template is not supposed to contain data");
 
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
 
diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index a7e9d36ea..437045f40 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -346,17 +346,27 @@ struct Evaluator<OpAssign<T, U>> {
     }
 };
 
-// Partial specializtion for E_x, E_y
-template <typename T, typename U>
-struct Evaluator<OpAndThen<T, U>> {
-    using Type = typename Evaluator<U>::Type;
+// Partial specializtion for E_x, E_y, ...
+template <typename T, typename... U>
+struct Evaluator<OpAndThen<T, U...>> {
+    using Type = typename Evaluator<OpAndThen<U...>>::Type;
 
     template <typename Context>
-    Type operator()(const OpAndThen<T, U>& op, Context& context) const
+    Type operator()(const OpAndThen<T, U...>& op, Context& context) const
     {
         // operator, evaluates sequentially
-        return Evaluator<T>{}(op.GetLhs(), context),
-               Evaluator<U>{}(op.GetRhs(), context);
+        return Evaluator<T>{}(op.GetFirst(), context),
+               Evaluator<OpAndThen<U...>>{}(op.GetRest(), context);
+    }
+};
+template <typename T>
+struct Evaluator<OpAndThen<T>> {
+    using Type = typename Evaluator<T>::Type;
+
+    template <typename Context>
+    Type operator()(const OpAndThen<T>& op, Context& context) const
+    {
+        return Evaluator<T>{}(op.GetFirst(), context);
     }
 };
 
@@ -625,44 +635,16 @@ struct FlattenAtOpAndThen {
     using Type = TypeList<T>;
 };
 
-template <typename T, typename U>
-struct FlattenAtOpAndThen<OpAndThen<T, U>> {
-    using Type = Concatenate_t<typename FlattenAtOpAndThen<T>::Type,
-                               typename FlattenAtOpAndThen<U>::Type>;
-};
-
-namespace Detail {
-
-template <typename Expr, typename List>
-struct BuildExpressionHelper;
-
-template <typename T>
-struct BuildExpressionHelper<Expression<T>, TypeList<>> {
-    using Type = Expression<T>;
-};
-
-template <typename T, typename U, typename... Rest>
-struct BuildExpressionHelper<Expression<T>, TypeList<U, Rest...>> {
-    using Type = typename BuildExpressionHelper<Expression<OpAndThen<T, U>>,
-                                                TypeList<Rest...>>::Type;
-};
-
-} // namespace Detail
-
-template <typename List>
-struct BuildExpression;
-
 template <typename T>
-struct BuildExpression<TypeList<T>> {
-    using Type = Expression<T>;
+struct FlattenAtOpAndThen<OpAndThen<T>> {
+    using Type = TypeList<T>;
 };
 
-template <typename T, typename U, typename... Rest>
-struct BuildExpression<TypeList<T, U, Rest...>>
-{
+template <typename T, typename... U>
+struct FlattenAtOpAndThen<OpAndThen<T, U...>> {
     using Type =
-        typename Detail::BuildExpressionHelper<Expression<T>,
-                                               TypeList<U, Rest...>>::Type;
+        Concatenate_t<typename FlattenAtOpAndThen<T>::Type,
+                      typename FlattenAtOpAndThen<OpAndThen<U...>>::Type>;
 };
 
 template <typename ExprList, typename Param>
@@ -704,64 +686,64 @@ struct HasCopyOutOp<TypeList<Param, FirstUse, LastUse>> {
 };
 
 struct CopyInInserter {
-    template <typename T, typename ExprList>
-    constexpr auto operator()(T, ExprList) const
+    template <typename T, typename Expr>
+    constexpr auto operator()(T, Expr expr) const
     {
         using ParamUse = typename T::Type;
         using Param = Get_t<ParamUse, 0>;
         constexpr auto firstUse = Get_t<ParamUse, 1>::value;
         if constexpr (Param::usage == ParamUsage::in ||
                       Param::usage == ParamUsage::in_out) {
-            using OldItem = Get_t<ExprList, firstUse>;
-            using NewItem = OpAndThen<OpCopyInParam<Param>, OldItem>;
-            return Set_t<ExprList, firstUse, NewItem>{};
+            auto oldItem = std::get<firstUse>(expr);
+            auto newItem = OpAndThen(OpCopyInParam<Param>{}, oldItem);
+            return Util::TupleSet<firstUse>(expr, newItem);
         } else {
-            return ExprList{};
+            return expr;
         }
     }
 };
 
 struct CopyOutInserter {
-    template <typename T, typename ExprList>
-    constexpr auto operator()(T, ExprList) const
+    template <typename T, typename Expr>
+    constexpr auto operator()(T, Expr expr) const
     {
         using ParamUse = typename T::Type;
         using Param = Get_t<ParamUse, 0>;
         constexpr auto lastUse = Get_t<ParamUse, 2>::value;
         if constexpr (Param::usage == ParamUsage::out ||
                       Param::usage == ParamUsage::in_out) {
-            using OldItem = Get_t<ExprList, lastUse>;
-            using NewItem = OpAndThen<OldItem, OpCopyOutParam<Param>>;
-            return Set_t<ExprList, lastUse, NewItem>{};
+            auto oldItem = std::get<lastUse>(expr);
+            auto newItem = OpAndThen(oldItem, OpCopyOutParam<Param>{});
+            return Util::TupleSet<lastUse>(expr, newItem);
         } else {
-            return ExprList{};
+            return expr;
         }
     }
 };
 
 struct AllocInserter {
-    template <typename T, typename ExprList>
-    constexpr auto operator()(T, ExprList) const
+    template <typename T, typename Expr>
+    constexpr auto operator()(T, Expr expr) const
     {
         using ParamUse = typename T::Type;
         using Param = Get_t<ParamUse, 0>;
         constexpr auto firstUse = Get_t<ParamUse, 1>::value;
-        using OldItem = Get_t<ExprList, firstUse>;
-        using NewItem = OpAndThen<OpAlloc<Param>, OldItem>;
-        return Set_t<ExprList, firstUse, NewItem>{};
+        auto oldItem = std::get<firstUse>(expr);
+        auto newItem = OpAndThen(OpAlloc<Param>{}, oldItem);
+        return Util::TupleSet<firstUse>(expr, newItem);
     }
 };
 
 struct FreeInserter {
-    template <typename T, typename ExprList>
-    constexpr auto operator()(T, ExprList) const
+    template <typename T, typename Expr>
+    constexpr auto operator()(T, Expr expr) const
     {
         using ParamUse = typename T::Type;
         using Param = Get_t<ParamUse, 0>;
         constexpr auto lastUse = Get_t<ParamUse, 2>::value;
-        using OldItem = Get_t<ExprList, lastUse>;
-        using NewItem = OpAndThen<OldItem, OpFree<Param>>;
-        return Set_t<ExprList, lastUse, NewItem>{};
+        auto oldItem = std::get<lastUse>(expr);
+        auto newItem = OpAndThen(oldItem, OpFree<Param>{});
+        return Util::TupleSet<lastUse>(expr, newItem);
     }
 };
 
@@ -771,6 +753,7 @@ template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes, typename T>
 constexpr auto AddOpOnDemand(Expression<T> expr)
 {
     if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
+        using Util::ForEach;
         using Expr = T;
         using ExprList = typename FlattenAtOpAndThen<Expr>::Type;
 
@@ -795,7 +778,7 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
         //    before its first use.  Reverse order makes the result "look"
         //    better.
         auto result1 = ForEach(Reverse_t<ParamUseList>{}, CopyInInserter{},
-                               ExprList{});
+                               expr.data.GetTuple());
 
         // 4. For each output Param in ParamUseList, add an OpCopyOutParam
         //    after its last use.
@@ -810,8 +793,7 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
         //    use.
         auto result4 = ForEach(ParamUseList{}, FreeInserter{}, result3);
 
-        using Result = typename BuildExpression<decltype(result4)>::Type;
-        return Result{};
+        return Expression{OpAndThen(ExprTmpl::fromTuple, result4)};
     } else {
         return expr;
     }
@@ -824,9 +806,6 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     auto expr =
         AddOpOnDemand<AutoOpFlag>(maker.template Get<BlockTensor>());
     using Expr = typename decltype(expr)::Type;
-    static_assert(
-        !Expr::hasData,
-        "This expression template is not supposed to contain data");
 
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
 
diff --git a/best_practices/expression_template/demo_eval.h b/best_practices/expression_template/demo_eval.h
index b8c86558e..c1adcfb8f 100644
--- a/best_practices/expression_template/demo_eval.h
+++ b/best_practices/expression_template/demo_eval.h
@@ -310,19 +310,31 @@ struct Evaluator<TypeList<T, Ts...>> {
     }
 };
 
-// Partial specializtion for E_x, E_y
-template <typename T, typename U>
-struct Evaluator<OpAndThen<T, U>> {
-    using Type = typename Evaluator<U>::Type;
+// Partial specializtion for E_x, E_y, ...
+template <typename T, typename... U>
+struct Evaluator<OpAndThen<T, U...>> {
+    using Type = typename Evaluator<OpAndThen<U...>>::Type;
 
     template <typename ArgTup, typename LocalVarTup>
-    Type operator()(const OpAndThen<T, U>& op,
+    Type operator()(const OpAndThen<T, U...>& op,
                     ArgTup& args,
                     LocalVarTup& localVars) const
     {
         // operator, evaluates sequentially
-        return Evaluator<T>{}(op.GetLhs(), args, localVars),
-               Evaluator<U>{}(op.GetRhs(), args, localVars);
+        return Evaluator<T>{}(op.GetFirst(), args, localVars),
+               Evaluator<OpAndThen<U...>>{}(op.GetRest(), args, localVars);
+    }
+};
+template <typename T>
+struct Evaluator<OpAndThen<T>> {
+    using Type = typename Evaluator<T>::Type;
+
+    template <typename ArgTup, typename LocalVarTup>
+    Type operator()(const OpAndThen<T>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        return Evaluator<T>{}(op.GetFirst(), args, localVars);
     }
 };
 
diff --git a/best_practices/expression_template/emulation.h b/best_practices/expression_template/emulation.h
index 839d9cfbb..40c3189d7 100644
--- a/best_practices/expression_template/emulation.h
+++ b/best_practices/expression_template/emulation.h
@@ -188,9 +188,6 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
     auto expr = maker.template Get<SimpleTensor>();
     using Expr = typename decltype(expr)::Type;
-    static_assert(
-        !Expr::hasData,
-        "This expression template is not supposed to contain data");
 
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
 
diff --git a/best_practices/expression_template/expr_template_demo.cpp b/best_practices/expression_template/expr_template_demo.cpp
index 3160ea8dc..3832568f2 100644
--- a/best_practices/expression_template/expr_template_demo.cpp
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -28,7 +28,8 @@ struct MyAddOp : ExprTmpl::Maker {
         auto _5 = DefineParam<5, VectorType<T>, ParamUsage::out>();
         auto tmp1 = DefineLocalVarLike<1>(_1);
         auto tmp2 = DefineLocalVarLike<2>(_3);
-        return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2);
+        return (tmp1 = _1 + _2, tmp2 = _3 + _4, _5 = tmp1 + tmp2,
+                _5 = _5 * 2);
     }
 };
 
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 0cdcfd40c..2c008d7f0 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -4,7 +4,9 @@
 /* Expression templates */
 
 #include <cstddef>
+#include <tuple>
 #include <type_traits>
+#include <utility>
 #include "util.h"
 
 // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
@@ -240,6 +242,66 @@ struct IsTernaryOp<T, std::void_t<typename T::IsTernaryOp>> : std::true_type {};
 template <typename T>
 inline constexpr bool IsTernaryOp_v = IsTernaryOp<T>::value;
 
+// Type for marking concatenating constructor of OpAndThen
+struct ConcatType {
+    constexpr explicit ConcatType() = default;
+};
+
+inline constexpr ConcatType concat;
+
+// Type for marking from-tuple constructor of OpAndThen
+struct FromTupleType {
+    constexpr explicit FromTupleType() = default;
+};
+
+inline constexpr FromTupleType fromTuple;
+
+template <typename T, typename... U>
+struct OpAndThen : std::tuple<T, U...> {
+private:
+    using Base = std::tuple<T, U...>;
+
+public:
+    using FirstType = T;
+
+    OpAndThen() = default;
+    constexpr OpAndThen(T t, U... u) : Base(t, u...) {}
+    template <typename... Ts>
+    constexpr OpAndThen(FromTupleType, std::tuple<Ts...> t)
+        : Base(std::move(t))
+    {
+    }
+    template <typename... V, typename W>
+    constexpr OpAndThen(ConcatType, OpAndThen<V...> v, W w)
+        : Base(std::tuple_cat(static_cast<const std::tuple<V...>&>(v),
+                              std::tuple(w)))
+    {
+    }
+
+    constexpr const Base& GetTuple() const
+    {
+        return *this;
+    }
+
+    constexpr auto GetFirst() const
+    {
+        return std::get<0>(*this);
+    }
+
+    constexpr auto GetRest() const
+    {
+        return std::apply(
+            [](auto&& /*first*/, auto&&... rest) {
+                return OpAndThen<U...>(
+                    std::forward<decltype(rest)>(rest)...);
+            },
+            GetTuple());
+    }
+};
+
+template <typename... Ts>
+OpAndThen(FromTupleType, std::tuple<Ts...>) -> OpAndThen<Ts...>;
+
 namespace Detail {
 
 template <typename T, typename = void>
@@ -278,6 +340,18 @@ struct LocalVarCollectorHelper<T, std::enable_if_t<IsTernaryOp_v<T>>> {
         typename LocalVarCollector<typename T::ThirdType>::Type>;
 };
 
+template <typename T, typename... U>
+struct LocalVarCollectorHelper<OpAndThen<T, U...>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename LocalVarCollector<T>::Type,
+        typename LocalVarCollector<OpAndThen<U...>>::Type>;
+};
+
+template <typename T>
+struct LocalVarCollectorHelper<OpAndThen<T>> {
+    using Type = typename LocalVarCollector<T>::Type;
+};
+
 template <typename... Ts>
 struct LocalVarCollectorHelper<Util::TMP::TypeList<Ts...>> {
     using Type = Util::TMP::Apply_t<
@@ -321,6 +395,18 @@ struct ParamCollectorHelper<T, std::enable_if_t<IsTernaryOp_v<T>>> {
         typename ParamCollector<typename T::ThirdType>::Type>;
 };
 
+template <typename T, typename... U>
+struct ParamCollectorHelper<OpAndThen<T, U...>> {
+    using Type = Util::TMP::Concatenate_t<
+        typename ParamCollector<T>::Type,
+        typename ParamCollector<OpAndThen<U...>>::Type>;
+};
+
+template <typename T>
+struct ParamCollectorHelper<OpAndThen<T>> {
+    using Type = typename ParamCollector<T>::Type;
+};
+
 template <typename... Ts>
 struct ParamCollectorHelper<Util::TMP::TypeList<Ts...>> {
     using Type = Util::TMP::Apply_t<
@@ -502,18 +588,19 @@ template <typename U>
     return Expression<OpAssign<T, U>>{{data, u.data}};
 }
 
-template <typename T, typename U>
-struct OpAndThen : BinaryOp<T, U> {
-    OpAndThen() = default;
-    constexpr OpAndThen(T t, U u) : BinaryOp<T, U>(t, u) {}
-};
-
 template <typename T, typename U>
 [[nodiscard]] constexpr auto operator,(Expression<T> t, Expression<U> u)
 {
     return Expression<OpAndThen<T, U>>{{t.data, u.data}};
 }
 
+template <typename... T, typename U>
+[[nodiscard]] constexpr auto operator,(Expression<OpAndThen<T...>> t,
+                                       Expression<U> u)
+{
+    return Expression<OpAndThen<T..., U>>{{concat, t.data, u.data}};
+}
+
 // Disallow dangerous expressions like (Expression{2}, 3)
 template <typename T, typename U>
 constexpr auto operator,(Expression<T>t, U&& u) = delete;
-- 
Gitee


From 0a9a745e893f38f829eb657d4ec7fa8bb2d71ab3 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 22 Dec 2025 19:38:16 +0800
Subject: [PATCH 108/116] Add tuple utility functions

Potentially useful in the future.

Notice that we have now Map, Find, FindLast, and ForEach, but Filter is
missing.  A tuple cannot be filtered at compile time by its element
values with a usual constexpr function.
---
 .../expression_template/block_emulation2.h    |  8 +-
 best_practices/expression_template/util.h     | 91 ++++++++++++++++++-
 2 files changed, 91 insertions(+), 8 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 437045f40..da1f93e98 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -696,7 +696,7 @@ struct CopyInInserter {
                       Param::usage == ParamUsage::in_out) {
             auto oldItem = std::get<firstUse>(expr);
             auto newItem = OpAndThen(OpCopyInParam<Param>{}, oldItem);
-            return Util::TupleSet<firstUse>(expr, newItem);
+            return Util::Set<firstUse>(expr, newItem);
         } else {
             return expr;
         }
@@ -714,7 +714,7 @@ struct CopyOutInserter {
                       Param::usage == ParamUsage::in_out) {
             auto oldItem = std::get<lastUse>(expr);
             auto newItem = OpAndThen(oldItem, OpCopyOutParam<Param>{});
-            return Util::TupleSet<lastUse>(expr, newItem);
+            return Util::Set<lastUse>(expr, newItem);
         } else {
             return expr;
         }
@@ -730,7 +730,7 @@ struct AllocInserter {
         constexpr auto firstUse = Get_t<ParamUse, 1>::value;
         auto oldItem = std::get<firstUse>(expr);
         auto newItem = OpAndThen(OpAlloc<Param>{}, oldItem);
-        return Util::TupleSet<firstUse>(expr, newItem);
+        return Util::Set<firstUse>(expr, newItem);
     }
 };
 
@@ -743,7 +743,7 @@ struct FreeInserter {
         constexpr auto lastUse = Get_t<ParamUse, 2>::value;
         auto oldItem = std::get<lastUse>(expr);
         auto newItem = OpAndThen(oldItem, OpFree<Param>{});
-        return Util::TupleSet<lastUse>(expr, newItem);
+        return Util::Set<lastUse>(expr, newItem);
     }
 };
 
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index fc7726912..fcfad1ab7 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -69,19 +69,102 @@ constexpr auto TupleSetImpl(Tuple&& t, NewValue&& newValue,
         selector(std::integral_constant<std::size_t, Is>{})...);
 }
 
-} // namespace Detail 
+template <std::size_t I, typename Tuple, typename Func, typename Data>
+constexpr auto TupleForEachImpl(Tuple&& t, Func&& func, Data data)
+{
+    constexpr auto size = std::tuple_size_v<std::remove_reference_t<Tuple>>;
+    if constexpr (I == size) {
+        return data;
+    } else {
+        return TupleForEachImpl<I + 1>(
+            std::forward<Tuple>(t),
+            std::forward<Func>(func),
+            std::forward<Func>(func)(std::get<I>(std::forward<Tuple>(t)),
+                                     data));
+    }
+}
+
+template <typename Tuple, typename Func, std::size_t... Is>
+constexpr std::size_t TupleFindImpl(const Tuple& t, Func&& func,
+                                    std::index_sequence<Is...>)
+{
+    std::size_t result{};
+    bool found =
+        ((result = Is, std::forward<Func>(func)(std::get<Is>(t))) || ...);
+    return found ? result : sizeof...(Is);
+}
 
-template <std::size_t I, typename Tuple, typename NewValue>
-constexpr auto TupleSet(Tuple&& t, NewValue&& newValue)
+template <typename Tuple, typename Func, std::size_t... Is>
+constexpr auto TupleMapImpl(const Tuple& t, Func&& func,
+                            std::index_sequence<Is...>)
+{
+    return std::make_tuple(std::forward<Func>(func)(std::get<Is>(t))...);
+}
+
+} // namespace Detail
+
+template <
+    std::size_t I, typename Tuple, typename NewValue,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
+                     int> = 0>
+constexpr auto Set(Tuple&& t, NewValue&& newValue)
 {
     constexpr auto size = std::tuple_size_v<std::remove_reference_t<Tuple>>;
-    static_assert(I < size, "TupleSet: Index out of bounds");
+    static_assert(I < size, "Set: Index out of bounds");
 
     return Detail::TupleSetImpl<I>(std::forward<Tuple>(t),
                                    std::forward<NewValue>(newValue),
                                    std::make_index_sequence<size>{});
 }
 
+template <
+    typename Tuple, typename Func, typename Data,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
+                     int> = 0>
+constexpr auto ForEach(Tuple&& t, Func&& func, Data data)
+{
+    return Detail::TupleForEachImpl<0>(std::forward<Tuple>(t),
+                                       std::forward<Func>(func), data);
+}
+
+template <
+    typename Tuple, typename Func,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, Tuple>, int> = 0>
+constexpr std::size_t Find(const Tuple& t, Func&& func)
+{
+    return Detail::TupleFindImpl(
+        t, std::forward<Func>(func),
+        std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+}
+
+template <
+    typename Tuple, typename Func,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, Tuple>, int> = 0>
+constexpr std::size_t FindLast(const Tuple& t, Func&& func)
+{
+    return ForEach(
+        t,
+        [&, count = std::size_t(0)](const auto& value,
+                                    std::size_t last) mutable {
+            if (std::forward<Func>(func)(value)) {
+                last = count;
+            }
+            ++count;
+            return last;
+        },
+        std::tuple_size_v<Tuple>);
+}
+
+template <
+    typename Tuple, typename Func,
+    std::enable_if_t<IsSpecializationOf_v<std::tuple, Tuple>, int> = 0>
+constexpr auto Map(const Tuple& t, Func&& func)
+{
+    return Detail::TupleMapImpl(
+        t, std::forward<Func>(func),
+        std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+}
+
 namespace Detail {
 
 // Check if compression would cause ambiguity
-- 
Gitee


From 77a34d3a8e209829b100f777d183429b242fa047 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Mon, 22 Dec 2025 19:49:34 +0800
Subject: [PATCH 109/116] Rename FlattenAtOpAndThen to OpAndThenToTypeList

---
 .../expression_template/block_emulation2.h           | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index da1f93e98..3b2d4805d 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -631,20 +631,20 @@ template <typename T>
 using SimpleTensor = Demo::Tensor<T>;
 
 template <typename T>
-struct FlattenAtOpAndThen {
+struct OpAndThenToTypeList {
     using Type = TypeList<T>;
 };
 
 template <typename T>
-struct FlattenAtOpAndThen<OpAndThen<T>> {
+struct OpAndThenToTypeList<OpAndThen<T>> {
     using Type = TypeList<T>;
 };
 
 template <typename T, typename... U>
-struct FlattenAtOpAndThen<OpAndThen<T, U...>> {
+struct OpAndThenToTypeList<OpAndThen<T, U...>> {
     using Type =
-        Concatenate_t<typename FlattenAtOpAndThen<T>::Type,
-                      typename FlattenAtOpAndThen<OpAndThen<U...>>::Type>;
+        Concatenate_t<typename OpAndThenToTypeList<T>::Type,
+                      typename OpAndThenToTypeList<OpAndThen<U...>>::Type>;
 };
 
 template <typename ExprList, typename Param>
@@ -755,7 +755,7 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
     if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
         using Util::ForEach;
         using Expr = T;
-        using ExprList = typename FlattenAtOpAndThen<Expr>::Type;
+        using ExprList = typename OpAndThenToTypeList<Expr>::Type;
 
         // 1. Collect all parameters used
         using Params = ExprTmpl::Params_t<Expr>;
-- 
Gitee


From b7748adc8a7a00d1ce125cbd91293ecf1994c83e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 23 Dec 2025 09:34:07 +0800
Subject: [PATCH 110/116] Rename a parameter for consistency

---
 best_practices/expression_template/util.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index fcfad1ab7..5b73cea9f 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -39,14 +39,14 @@ template <
     typename Tuple, typename Func,
     std::enable_if_t<IsSpecializationOf_v<std::tuple, std::decay_t<Tuple>>,
                      int> = 0>
-constexpr void ForEach(Tuple&& tuple, Func&& func)
+constexpr void ForEach(Tuple&& t, Func&& func)
 {
     std::apply(
         [&func](auto&&... args) {
             (std::forward<Func>(func)(std::forward<decltype(args)>(args)),
              ...);
         },
-        std::forward<Tuple>(tuple));
+        std::forward<Tuple>(t));
 }
 
 namespace Detail {
-- 
Gitee


From dc8bb33bd0ea6a27d0fabe365518eff148b8366e Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 23 Dec 2025 14:07:46 +0800
Subject: [PATCH 111/116] Flatten the result of AddOpOnDemand

---
 .../expression_template/block_emulation2.h    |  2 +-
 .../expression_template/expr_tmpl.h           | 32 +++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 3b2d4805d..458f870bf 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -793,7 +793,7 @@ constexpr auto AddOpOnDemand(Expression<T> expr)
         //    use.
         auto result4 = ForEach(ParamUseList{}, FreeInserter{}, result3);
 
-        return Expression{OpAndThen(ExprTmpl::fromTuple, result4)};
+        return Expression{FlattenOpAndThen(result4)};
     } else {
         return expr;
     }
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index 2c008d7f0..f07868b5b 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -304,6 +304,38 @@ OpAndThen(FromTupleType, std::tuple<Ts...>) -> OpAndThen<Ts...>;
 
 namespace Detail {
 
+// Make a flattened tuple out of an OpAndThen or std::tuple tree
+template <typename Op>
+constexpr auto FlattenOpAndThenHelper(const Op& op)
+{
+    if constexpr (Util::IsSpecializationOf_v<OpAndThen, Op>) {
+        return std::apply(
+            [](const auto&... elems) {
+                return std::tuple_cat(FlattenOpAndThenHelper(elems)...);
+            },
+            op.GetTuple());
+    } else if constexpr (Util::IsSpecializationOf_v<std::tuple, Op>) {
+        return std::apply(
+            [](const auto&... elems) {
+                return std::tuple_cat(FlattenOpAndThenHelper(elems)...);
+            },
+            op);
+    } else {
+        return std::make_tuple(op);
+    }
+}
+
+} // namespace Detail
+
+// Flatten an OpAndThen or std::tuple tree
+template <typename Op>
+constexpr auto FlattenOpAndThen(const Op& op)
+{
+    return OpAndThen(fromTuple, Detail::FlattenOpAndThenHelper(op));
+}
+
+namespace Detail {
+
 template <typename T, typename = void>
 struct LocalVarCollectorHelper;
 
-- 
Gitee


From ee75e3bb2875b2ddf8ebbf099f9e285d3655b599 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 23 Dec 2025 16:40:18 +0800
Subject: [PATCH 112/116] Optimize for compilation speed

---
 .../expression_template/expr_tmpl.h           | 142 +++++++++++++++---
 best_practices/expression_template/util.h     |  12 ++
 2 files changed, 137 insertions(+), 17 deletions(-)

diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index f07868b5b..fa0e386cf 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -302,36 +302,144 @@ public:
 template <typename... Ts>
 OpAndThen(FromTupleType, std::tuple<Ts...>) -> OpAndThen<Ts...>;
 
+} // namespace ExprTmpl
+
+// Make OpAndThen "tuple-like"
+
+namespace std {
+
+template <typename T, typename... U>
+struct tuple_size<ExprTmpl::OpAndThen<T, U...>>
+    : integral_constant<size_t, sizeof...(U) + 1> {};
+
+template <std::size_t I, typename T, typename... U>
+struct tuple_element<I, ExprTmpl::OpAndThen<T, U...>> {
+    using type = typename tuple_element<I, std::tuple<T, U...>>::type;
+};
+
+template <std::size_t I, typename T, typename... U>
+constexpr auto& get(const ExprTmpl::OpAndThen<T, U...>& op)
+{
+    return std::get<I>(op.GetTuple());
+}
+
+} // namespace std
+
+namespace ExprTmpl {
+
 namespace Detail {
 
-// Make a flattened tuple out of an OpAndThen or std::tuple tree
-template <typename Op>
-constexpr auto FlattenOpAndThenHelper(const Op& op)
+template <typename T>
+constexpr std::size_t CountLeavesTuple();
+
+template <typename T>
+constexpr std::size_t CountLeavesSingle()
 {
-    if constexpr (Util::IsSpecializationOf_v<OpAndThen, Op>) {
-        return std::apply(
-            [](const auto&... elems) {
-                return std::tuple_cat(FlattenOpAndThenHelper(elems)...);
-            },
-            op.GetTuple());
-    } else if constexpr (Util::IsSpecializationOf_v<std::tuple, Op>) {
-        return std::apply(
-            [](const auto&... elems) {
-                return std::tuple_cat(FlattenOpAndThenHelper(elems)...);
-            },
-            op);
+    if constexpr (Util::IsSpecializationOf_v<OpAndThen, T>) {
+        return CountLeavesTuple<
+            std::decay_t<decltype(std::declval<T>().GetTuple())>>();
+    } else if constexpr (Util::IsSpecializationOf_v<std::tuple, T>) {
+        return CountLeavesTuple<T>();
     } else {
-        return std::make_tuple(op);
+        return 1;
     }
 }
 
+template <typename Tuple, std::size_t... Is>
+constexpr std::size_t SumLeaves(std::index_sequence<Is...>)
+{
+    return (CountLeavesSingle<std::tuple_element_t<Is, Tuple>>() + ... +
+            0);
+}
+
+template <typename T>
+constexpr std::size_t CountLeavesTuple()
+{
+    return SumLeaves<T>(
+        std::make_index_sequence<std::tuple_size<T>::value>{});
+}
+
+template <typename T>
+inline constexpr std::size_t CountLeaves = CountLeavesSingle<T>();
+
+template <std::size_t TargetIdx, typename T>
+constexpr auto ExtractLeafImpl(const T& value);
+
+// Helper to extract from a tuple by iterating over its elements
+template <std::size_t TargetIdx, typename Tuple, std::size_t... Is>
+struct ExtractFromTupleHelper;
+
+template <std::size_t TargetIdx, typename Tuple, std::size_t I,
+          std::size_t... Is>
+struct ExtractFromTupleHelper<TargetIdx, Tuple, I, Is...> {
+    static constexpr auto Apply(const Tuple& t)
+    {
+        using ElemType = std::tuple_element_t<I, Tuple>;
+        constexpr std::size_t elemSize = CountLeaves<ElemType>;
+
+        if constexpr (TargetIdx < elemSize) {
+            // Target is within this element
+            return ExtractLeafImpl<TargetIdx>(std::get<I>(t));
+        } else {
+            // Try next element
+            return ExtractFromTupleHelper<TargetIdx - elemSize, Tuple,
+                                          Is...>::Apply(t);
+        }
+    }
+};
+
+template <std::size_t TargetIdx, typename Tuple>
+struct ExtractFromTupleHelper<TargetIdx, Tuple> {
+    // Base case - should never be reached with valid indices
+    static constexpr auto Apply(const Tuple&)
+    {
+        struct Invalid {};
+        return Invalid{};
+    }
+};
+
+// Dispatch function for tuple extraction
+template <std::size_t TargetIdx, typename Tuple, std::size_t... Is>
+constexpr auto ExtractFromTupleDispatch(const Tuple& t,
+                                        std::index_sequence<Is...>)
+{
+    return ExtractFromTupleHelper<TargetIdx, Tuple, Is...>::Apply(t);
+}
+
+template <std::size_t TargetIdx, typename T>
+constexpr auto ExtractLeafImpl(const T& value)
+{
+    if constexpr (!Util::IsTupleLike_v<T>) {
+        // Single element - target must be 0
+        static_assert(TargetIdx == 0, "Index out of bounds for non-tuple");
+        return value;
+    } else {
+        // Use the helper otherwise
+        return ExtractFromTupleDispatch<TargetIdx>(
+            value, std::make_index_sequence<std::tuple_size<T>::value>{});
+    }
+}
+
+template <typename Tuple, std::size_t... Is>
+constexpr auto FlattenImpl(const Tuple& t, std::index_sequence<Is...>)
+{
+    return std::make_tuple(ExtractLeafImpl<Is>(t)...);
+}
+
+template <typename Tuple>
+constexpr auto FlattenTuple(const Tuple& t)
+{
+    constexpr std::size_t total = CountLeaves<std::decay_t<Tuple>>;
+    return FlattenImpl(t, std::make_index_sequence<total>{});
+}
+
 } // namespace Detail
 
 // Flatten an OpAndThen or std::tuple tree
 template <typename Op>
 constexpr auto FlattenOpAndThen(const Op& op)
 {
-    return OpAndThen(fromTuple, Detail::FlattenOpAndThenHelper(op));
+    return OpAndThen(fromTuple, Detail::FlattenTuple(op));
 }
 
 namespace Detail {
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 5b73cea9f..3ee09bf4e 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -165,6 +165,18 @@ constexpr auto Map(const Tuple& t, Func&& func)
         std::make_index_sequence<std::tuple_size_v<Tuple>>{});
 }
 
+// Detection for tuple-like types
+template <typename T, typename = void>
+struct IsTupleLike : std::false_type {};
+
+// Specialization for types that have std::tuple_size defined
+template <typename T>
+struct IsTupleLike<T, std::void_t<decltype(std::tuple_size<T>::value)>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool IsTupleLike_v = IsTupleLike<T>::value;
+
 namespace Detail {
 
 // Check if compression would cause ambiguity
-- 
Gitee


From 4dd356fb1eab366c27ae455c073f7e570fb34355 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 23 Dec 2025 17:24:16 +0800
Subject: [PATCH 113/116] Remove an unused using

---
 best_practices/expression_template/block_emulation2.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 458f870bf..8e1573643 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -753,7 +753,6 @@ template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes, typename T>
 constexpr auto AddOpOnDemand(Expression<T> expr)
 {
     if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
-        using Util::ForEach;
         using Expr = T;
         using ExprList = typename OpAndThenToTypeList<Expr>::Type;
 
-- 
Gitee


From d83e2d164c207f3635851cba5229041600a31c05 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Tue, 23 Dec 2025 20:46:36 +0800
Subject: [PATCH 114/116] Remove a trailing space

---
 best_practices/expression_template/.clang-format | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/best_practices/expression_template/.clang-format b/best_practices/expression_template/.clang-format
index 077c7228a..709aada5e 100644
--- a/best_practices/expression_template/.clang-format
+++ b/best_practices/expression_template/.clang-format
@@ -24,7 +24,7 @@ SpacesBeforeTrailingComments: 1
 
 SortIncludes: true
 IncludeBlocks: Preserve
-IncludeCategories: 
+IncludeCategories:
   - Regex:           '^<.*/.*>$'
     Priority:        3
   - Regex:           '^<.*\.h>$'
-- 
Gitee


From 4852b2a81429cbc85c32fbbfee411fdf019f2e49 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 24 Dec 2025 10:14:35 +0800
Subject: [PATCH 115/116] Enable pipelining

---
 .../expression_template/block_emulation2.h    | 139 +++++++++++-------
 .../expression_template/expr_tmpl.h           |   8 +
 2 files changed, 97 insertions(+), 50 deletions(-)

diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
index 8e1573643..83b11ba0a 100644
--- a/best_practices/expression_template/block_emulation2.h
+++ b/best_practices/expression_template/block_emulation2.h
@@ -749,61 +749,101 @@ struct FreeInserter {
 
 enum class AutoOpOnDemand { no, yes };
 
-template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes, typename T>
-constexpr auto AddOpOnDemand(Expression<T> expr)
-{
-    if constexpr (AutoOpFlag == AutoOpOnDemand::yes) {
-        using Expr = T;
-        using ExprList = typename OpAndThenToTypeList<Expr>::Type;
-
-        // 1. Collect all parameters used
-        using Params = ExprTmpl::Params_t<Expr>;
-
-        // 2. Get a type list of type lists of three items:
-        //      (Param, FirstUseConst, LastUseConst)
-        using ParamUseList =
-            Map_t<FirstAndLastUseFinder<ExprList>::template Type, Params>;
-
-        // TODO: Insert sync.  Positions are calculated below.
-        using HasCopyInExprIndexList =
-            Filter_t<IsNotEmpty,
-                     Unique_t<Map_t<HasCopyInOp, ParamUseList>>>;
-
-        using HasCopyOutExprIndexList =
-            Filter_t<IsNotEmpty,
-                     Unique_t<Map_t<HasCopyOutOp, ParamUseList>>>;
-
-        // 3. For each input Param in ParamUseList, add an OpCopyInParam
-        //    before its first use.  Reverse order makes the result "look"
-        //    better.
-        auto result1 = ForEach(Reverse_t<ParamUseList>{}, CopyInInserter{},
-                               expr.data.GetTuple());
-
-        // 4. For each output Param in ParamUseList, add an OpCopyOutParam
-        //    after its last use.
-        auto result2 = ForEach(ParamUseList{}, CopyOutInserter{}, result1);
-
-        // 5. For each Param in ParamUseList, add an OpAlloc before its
-        //    first use.  Reverse order makes the result "look" better.
-        auto result3 =
-            ForEach(Reverse_t<ParamUseList>{}, AllocInserter{}, result2);
-
-        // 6. For each Param in ParamUseList, add an OpFree after its last
-        //    use.
-        auto result4 = ForEach(ParamUseList{}, FreeInserter{}, result3);
-
-        return Expression{FlattenOpAndThen(result4)};
-    } else {
+template <typename T>
+constexpr auto AddOpOnDemand(const Expression<T>& expr)
+{
+    using Expr = T;
+    using ExprList = typename OpAndThenToTypeList<Expr>::Type;
+
+    // 1. Collect all parameters used
+    using Params = ExprTmpl::Params_t<Expr>;
+
+    // 2. Get a type list of type lists of three items:
+    //      (Param, FirstUseConst, LastUseConst)
+    using ParamUseList =
+        Map_t<FirstAndLastUseFinder<ExprList>::template Type, Params>;
+
+    // TODO: Insert sync.  Positions are calculated below.
+    using HasCopyInExprIndexList =
+        Filter_t<IsNotEmpty, Unique_t<Map_t<HasCopyInOp, ParamUseList>>>;
+
+    using HasCopyOutExprIndexList =
+        Filter_t<IsNotEmpty, Unique_t<Map_t<HasCopyOutOp, ParamUseList>>>;
+
+    // 3. For each input Param in ParamUseList, add an OpCopyInParam
+    //    before its first use.  Reverse order makes the result "look"
+    //    better.
+    auto result1 = ForEach(Reverse_t<ParamUseList>{}, CopyInInserter{},
+                           expr.data.GetTuple());
+
+    // 4. For each output Param in ParamUseList, add an OpCopyOutParam
+    //    after its last use.
+    auto result2 = ForEach(ParamUseList{}, CopyOutInserter{}, result1);
+
+    // 5. For each Param in ParamUseList, add an OpAlloc before its
+    //    first use.  Reverse order makes the result "look" better.
+    auto result3 =
+        ForEach(Reverse_t<ParamUseList>{}, AllocInserter{}, result2);
+
+    // 6. For each Param in ParamUseList, add an OpFree after its last
+    //    use.
+    auto result4 = ForEach(ParamUseList{}, FreeInserter{}, result3);
+
+    return Expression{OpAndThen(fromTuple, result4)};
+}
+
+template <bool On = true>
+struct AddOpOnDemandFn;
+
+template <>
+struct AddOpOnDemandFn<false> {
+    template <typename T>
+    constexpr decltype(auto) operator()(const Expression<T>& expr) const
+    {
         return expr;
     }
-}
+};
+
+template <>
+struct AddOpOnDemandFn<true> {
+    template <typename T>
+    constexpr auto operator()(const Expression<T>& expr) const
+    {
+        return AddOpOnDemand(expr);
+    }
+};
+
+template <bool On = false>
+struct FlattenOpAndThenFn;
+
+template <>
+struct FlattenOpAndThenFn<false> {
+    template <typename T>
+    constexpr decltype(auto) operator()(const Expression<T>& expr) const
+    {
+        return expr;
+    }
+};
+
+template <>
+struct FlattenOpAndThenFn<true> {
+    template <typename T>
+    constexpr auto operator()(const Expression<T>& expr) const
+    {
+        return Expression{FlattenOpAndThen(expr.data)};
+    }
+};
 
 template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes,
           typename ExprMaker, typename... Args>
 void DoElementwise(const ExprMaker& maker, Args&&... args)
 {
-    auto expr =
-        AddOpOnDemand<AutoOpFlag>(maker.template Get<BlockTensor>());
+    constexpr AddOpOnDemandFn<static_cast<bool>(AutoOpFlag)> addOpOnDemand;
+    constexpr FlattenOpAndThenFn<false> flattenOpAndThen;
+
+    auto expr = maker.template Get<BlockTensor>() |
+        addOpOnDemand |
+        flattenOpAndThen;
     using Expr = typename decltype(expr)::Type;
 
     auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
@@ -832,8 +872,7 @@ void DoElementwise(const ExprMaker& maker, Args&&... args)
     }
     if (i < len) {
         std::size_t sizeTB = len - i;  // tail-block size
-        auto exprTB =
-            AddOpOnDemand<AutoOpFlag>(maker.template Get<SimpleTensor>());
+        auto exprTB = maker.template Get<SimpleTensor>() | addOpOnDemand;
         using ExprTB = typename decltype(exprTB)::Type;
         using ParamsTB = Params_t<ExprTB>;
 
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
index fa0e386cf..f787937c9 100644
--- a/best_practices/expression_template/expr_tmpl.h
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -56,6 +56,14 @@ using IsExpression = Util::IsSpecializationOf<Expression, T>;
 template <typename T>
 inline constexpr bool IsExpression_v = IsExpression<T>::value;
 
+template <typename T, typename Func,
+          typename = std::enable_if_t<
+              std::is_invocable_v<Func, const Expression<T>&>>>
+decltype(auto) operator|(const Expression<T>& expr, Func&& func)
+{
+    return std::forward<Func>(func)(expr);
+}
+
 template <std::size_t N, typename T, typename L = void>
 struct LocalVar {
     static_assert(!std::is_reference_v<T>,
-- 
Gitee


From 336793b3ef1c91fd403ca5bfc0c81479f80eb4c4 Mon Sep 17 00:00:00 2001
From: Wu Yongwei <wuyongwei+gitee@gmail.com>
Date: Wed, 24 Dec 2025 17:21:22 +0800
Subject: [PATCH 116/116] Implement Drop for TypeList

---
 best_practices/expression_template/util.h     | 25 +++++++++++++++++++
 .../expression_template/util_test.cpp         |  8 ++++++
 2 files changed, 33 insertions(+)

diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
index 3ee09bf4e..8c56020a3 100644
--- a/best_practices/expression_template/util.h
+++ b/best_practices/expression_template/util.h
@@ -520,6 +520,17 @@ struct First<TypeList<Head, Tail...>> {
 template <typename List>
 using First_t = typename First<List>::Type;
 
+template <typename List>
+struct Rest;
+
+template <typename Head, typename... Tail>
+struct Rest<TypeList<Head, Tail...>> {
+    using Type = TypeList<Tail...>;
+};
+
+template <typename List>
+using Rest_t = typename Rest<List>::Type;
+
 template <typename List>
 struct Size;
 
@@ -723,6 +734,20 @@ struct IsNotEmpty<TypeList<>> : std::false_type {};
 template <typename List>
 inline constexpr bool IsNotEmpty_v = IsNotEmpty<List>::value;
 
+template <typename List, std::size_t N>
+struct Drop {
+    static_assert(IsNotEmpty_v<List>, "Cannot drop from empty list");
+    using Type = typename Drop<Rest_t<List>, N - 1>::Type;
+};
+
+template <typename List>
+struct Drop<List, 0> {
+    using Type = List;
+};
+
+template <typename List, std::size_t N>
+using Drop_t = typename Drop<List, N>::Type;
+
 template <template <typename...> class Proc, typename List>
 struct Apply;
 
diff --git a/best_practices/expression_template/util_test.cpp b/best_practices/expression_template/util_test.cpp
index 031a43a9f..68346e414 100644
--- a/best_practices/expression_template/util_test.cpp
+++ b/best_practices/expression_template/util_test.cpp
@@ -58,4 +58,12 @@ int main()
         using NewList = Set_t<List, 3, C>;
         static_assert(std::is_same_v<NewList, TypeList<A, B, A, C, D>>);
     }
+    {
+        using List = TypeList<A, B, A, A, D>;
+        static_assert(std::is_same_v<Drop_t<List, 0>, List>);
+        static_assert(std::is_same_v<Drop_t<List, 1>, TypeList<B, A, A, D>>);
+        static_assert(std::is_same_v<Drop_t<List, 2>, TypeList<A, A, D>>);
+        static_assert(std::is_same_v<Drop_t<List, 4>, TypeList<D>>);
+        static_assert(std::is_same_v<Drop_t<List, 5>, TypeList<>>);
+    }
 }
-- 
Gitee