diff --git a/best_practices/atvos/include/atvos.h b/best_practices/atvos/include/atvos.h
new file mode 100644
index 0000000000000000000000000000000000000000..f3912288633093810de5117f8bd34ff9865f8561
--- /dev/null
+++ b/best_practices/atvos/include/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/include/block/block_elemwise.h b/best_practices/atvos/include/block/block_elemwise.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff45114fb65e2baaf9d340fc400004440b1de5d5
--- /dev/null
+++ b/best_practices/atvos/include/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/include/block/block_elemwise_impl.h b/best_practices/atvos/include/block/block_elemwise_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a3d03ff06ccd80303a2e439e22c6ab33d91dfa1
--- /dev/null
+++ b/best_practices/atvos/include/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/include/common/dagsch.h b/best_practices/atvos/include/common/dagsch.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1459eca8e4ae07db94ddde8a5cc81bcc8059a45
--- /dev/null
+++ b/best_practices/atvos/include/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/include/common/expression.h b/best_practices/atvos/include/common/expression.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdc3805c885b468c9d5616eab48453443b9ba1e2
--- /dev/null
+++ b/best_practices/atvos/include/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/include/common/impl/atvos_impl.h b/best_practices/atvos/include/common/impl/atvos_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..9584a636cf84621e97e6665ac6132a5d31a77407
--- /dev/null
+++ b/best_practices/atvos/include/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/include/common/layout.h b/best_practices/atvos/include/common/layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..73a5c1cc89183c9cab461af348e1830eccde2be0
--- /dev/null
+++ b/best_practices/atvos/include/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/include/common/placeholder.h b/best_practices/atvos/include/common/placeholder.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdca4cd9cf41ad4d832be6a361500765eeb07c37
--- /dev/null
+++ b/best_practices/atvos/include/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/include/device/device_vector.h b/best_practices/atvos/include/device/device_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ec8a0d74cc89a3cac5e0e8efdcb583c94e5984b
--- /dev/null
+++ b/best_practices/atvos/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 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/include/device/device_vector_impl.h b/best_practices/atvos/include/device/device_vector_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b52be84e21917ff0f0667fc4adbfa3df662e712
--- /dev/null
+++ b/best_practices/atvos/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/include/dfx/check.h b/best_practices/atvos/include/dfx/check.h
new file mode 100644
index 0000000000000000000000000000000000000000..604ac7db46039b29fea105d9992fbac327ef33d5
--- /dev/null
+++ b/best_practices/atvos/include/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/include/dfx/kernel_mirror.h b/best_practices/atvos/include/dfx/kernel_mirror.h
new file mode 100644
index 0000000000000000000000000000000000000000..214dc0b428d5e6fc9b0399226492e2a608e7ab9e
--- /dev/null
+++ b/best_practices/atvos/include/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/include/kernel/kernel_elemwise.h b/best_practices/atvos/include/kernel/kernel_elemwise.h
new file mode 100644
index 0000000000000000000000000000000000000000..870b17241e7d2730315c198a8fd1446f6bb32775
--- /dev/null
+++ b/best_practices/atvos/include/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/include/kernel/kernel_elemwise_impl.h b/best_practices/atvos/include/kernel/kernel_elemwise_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..7bf3e0ca58f66d5b13186f6a01b2bba087ea9aae
--- /dev/null
+++ b/best_practices/atvos/include/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/include/tile/tile_alu.h b/best_practices/atvos/include/tile/tile_alu.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fae50a6c0c61e566724b8b853ccc01403dcfb2a
--- /dev/null
+++ b/best_practices/atvos/include/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
diff --git a/best_practices/atvos/main/main.cpp b/best_practices/atvos/main/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c48a9f3338173fd933dd9798e906cb32506e3ecf
--- /dev/null
+++ b/best_practices/atvos/main/main.cpp
@@ -0,0 +1,94 @@
+#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： ATVOSS方案 -------*/
+// 1, 描述算子原型
+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的输入，自动推导
+
+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};
+};
+
+// 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 
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 0000000000000000000000000000000000000000..8f842a6c1d18b9dbed0b69af46947f0738631090
--- /dev/null
+++ b/best_practices/atvos_demo/include/block/block_elewise.h
@@ -0,0 +1,198 @@
+#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 {
+
+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(){
+        bufPool_.InitBufPool(6, 1024, 4, 2048); // Todo: 需要通过tile layout配置
+    }
+
+    template <typename ArgTup>
+    __aicore__ inline Tile::Config MakeConfig(const Config& configBlock, ArgTup& argTuple)
+    {
+        Tile::Config configTile{12, 1, 2048};
+        return configTile;
+    }
+
+    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<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 的访问都成了引用
+        // auto inParams = GetInParams<Params>(params);
+        // auto outParams = GetOutParams<Params>(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 < 1; ++i) {
+        //     // 把 argTuple 里的向量替换成 params 里的对应 Local Tensor引用
+        //     // 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) {
+
+        // // }
+    }
+private:
+template <typename ArgIn, typename ArgOut>
+__aicore__ inline auto CombineArgs(ArgIn& inParams, ArgOut& outParams)
+{
+    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>
+    __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>
+    __aicore__ inline 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>
+    __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>
+//     __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)
+    {
+        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.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 {
+            return AscendC::Std::tuple<>{};
+        }
+    }
+
+    template <typename Params, typename ParamTup, size_t... Ints>
+    __aicore__ inline constexpr auto GetInParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
+    {
+        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>
+    __aicore__ inline constexpr auto GetOutParamsImpl(ParamTup& params, AscendC::Std::index_sequence<Ints...>)
+    {
+        return AscendC::Std::make_tuple(
+            GetOneParam<Params, Ints, ATVC::ExprTmpl::ParamUsage::out, ATVC::ExprTmpl::ParamUsage::in_out>(params)...);
+    }
+    template <typename Params, typename ParamTup>
+    __aicore__ inline auto GetInParams(ParamTup& params)
+    {
+        constexpr auto size = Util::TMP::Size_v<Params>;
+        static_assert(size == AscendC::Std::tuple_size<ParamTup>::value);
+        return GetInParamsImpl<Params>(
+            params, AscendC::Std::make_index_sequence<size>{});
+    }
+
+    template <typename Params, typename ParamTup>
+    __aicore__ inline auto GetOutParams(ParamTup& params)
+    {
+        constexpr auto size = Util::TMP::Size_v<Params>;
+        static_assert(size == AscendC::Std::tuple_size<ParamTup>::value);
+        return GetOutParamsImpl<Params>(
+            params, AscendC::Std::make_index_sequence<size>{});
+    }
+
+    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::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);
+    // }
+private:
+    ATVC::UTILS::EleBufPool bufPool_; // kernel调用block的时候 传入bufPool(kernel层实例化bufPool_，多次调用kernel的时候可以复用)
+};
+} // namespace ATVC::Block
+
+#endif
\ No newline at end of file
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 0000000000000000000000000000000000000000..9700c7dfcf3084f0212430fbda57824a99bb0b39
--- /dev/null
+++ b/best_practices/atvos_demo/include/block/block_tensor.h
@@ -0,0 +1,67 @@
+#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)
+    {
+        SetGmTensor(gmTensor);
+    }
+    
+    __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 = false;
+};
+}
+#endif
\ No newline at end of file
diff --git a/best_practices/atvos_demo/include/common.h b/best_practices/atvos_demo/include/common.h
new file mode 100644
index 0000000000000000000000000000000000000000..64d2503a83ecc33b4466dfe90d09f8a54d07ebcb
--- /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
new file mode 100644
index 0000000000000000000000000000000000000000..2c05501d0cdd02456c75c852ef5b1f62edf24b1f
--- /dev/null
+++ b/best_practices/atvos_demo/include/device/device_elewise.h
@@ -0,0 +1,271 @@
+#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;                                                                 \
+        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>
+// __global__ __aicore__ void MyKernel(GM_ADDR configDevice, GM_ADDR x, GM_ADDR y, GM_ADDR z)
+// {
+//     KernelOp op;
+//     AscendC::TPipe pipeIn;
+//     AscendC::printf("x: %p\n", x);
+//     AscendC::printf("y: %p\n", y);
+//     AscendC::printf("z: %p\n", z);
+//     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>
+void LaunchKernelWithDataTuple(uint32_t blockNum, aclrtStream& stream, uint8_t* configDevice, ArgTup& 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);
+    // 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);
+}
+
+/*
+ExprMaker maker: 描述计算表达信息
+Args&&... args： 输入输出信息
+*/
+template <typename KernelOp>
+class DeviceEleWise
+// TODO: MakeConfig 总的切分策略计算 UB空间分配策略
+{
+public:
+    using ExprMaker = typename KernelOp::ExprMaker;
+    DeviceEleWise(){};
+    // 计算kernel切分策略
+    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);
+        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
+        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 的访问都成了引用
+        // tuple of references
+        auto inParams = GetInParams<Params>(params);
+        auto outParams = GetOutParams<Params>(params);
+
+        // 把 argTuple 里的入参向量复制到 inParams 里的对应 Tensor 里
+        CopyIn<InParams>(inParams, argTuple);
+
+        // 把 config 复制到 GM
+        uint8_t* configDevice;
+        // CopyConfig(config, configDevice);
+        // 传递参数到设备侧执行
+        LaunchKernelWithDataTuple<KernelOp>(config.configKernel.blockNum, stream, configDevice, params);
+        CleanACL(stream, context, deviceId);
+        // 把 outParams 里的 Tensor 复制到 argTuple 里的对应出参向量里
+        CopyOut<OutParams>(outParams, argTuple);
+
+        // Tensor 和 configDevice 需手工清理
+        // ClearConfig(configDevice);
+        // ClearTensors(params);
+        return 0;
+    }
+
+private:
+    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 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>
+    constexpr auto ConstructParam(ArgTup& args)
+    {   // 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>
+    constexpr 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>
+    constexpr auto PrepareParams(ArgTup& argTuple)
+    {
+        return PrepareParamsImpl<Params>(
+            argTuple, std::make_index_sequence<Util::TMP::Size_v<Params>>{});
+    }
+
+    template <typename Params, std::size_t Index, typename ParamTup, typename ArgTup>
+    constexpr 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>
+    constexpr 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>>{});
+    }
+
+    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
+#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 0000000000000000000000000000000000000000..6e015fd117f285a64106d8b088f20cc4b08301e9
--- /dev/null
+++ b/best_practices/atvos_demo/include/device/device_tensor.h
@@ -0,0 +1,71 @@
+#include <algorithm>
+#include "acl/acl.h"
+namespace ATVC::Device {
+
+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");
+        }
+        aclrtMalloc((void **)&ptr_, size * sizeof(T), ACL_MEM_MALLOC_HUGE_FIRST);
+        std::cout<<"Malloc Tensor: "<<ptr_<< "   size: "<<size<<std::endl;
+        len_ = size;
+    }
+    std::size_t GetSize() const
+    {
+        return len_;
+    }
+    uint8_t* GetPtr() const
+    {
+        return (uint8_t* )ptr_;
+    }
+
+    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 (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_{};
+};
+}
\ 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
new file mode 100644
index 0000000000000000000000000000000000000000..0c83579d4596ec49d49f3fbdf14a042ebe1d9983
--- /dev/null
+++ b/best_practices/atvos_demo/include/kernel/kernel_elewise.h
@@ -0,0 +1,65 @@
+#ifndef KERNEL_ELE_WISE_H
+#define KERNEL_ELE_WISE_H
+#include <functional>
+
+namespace ATVC::Kernel {
+
+template <typename BlockOp>
+class KernelEleWise{
+    //TODO: kenel层的切分策略 融合到当前demo中： MakeConfig
+    //        PrepareParams: 输入输出gm指针 转换为tuple<GlobalTensor> 包含 GlobalTensor资源分配
+public:
+    using ExprMaker = typename BlockOp::ExpressMaker;
+    __aicore__ inline KernelEleWise(){};
+
+    // 计算block切分策略
+    __aicore__ inline Block::Config MakeConfig(GM_ADDR configKernel) {
+        Block::Config configBlock{10, 1, 1024};
+        return configBlock;
+    }
+
+    // 需要从Params中萃取每个输入输出的Dtype 生成每个输入输出的Gm地址， gm内存大小， 生成GlobalTensor组成的tuple
+    template <typename Params, typename... 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);
+        return params;
+    }
+
+    // 运行接口
+    template <typename... Args>
+    __aicore__ inline void Run(GM_ADDR configKernel, Args... args)
+    {
+        // 配置Block层切分策略
+        Block::Config configBlock = MakeConfig(configKernel);
+
+        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>;
+
+        // 得到 tuple<GlobalTensor, ...>，向量变成了 GlobalTensor 类型，
+        // 并根据 blockId 调整每个 GlobalTensor 的偏移量和大小
+        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);
+        // 执行计算
+        // 循环执行
+
+        BlockOp blockOp;
+        for (int i = 0; i < 1; ++i) {
+            blockOp.Run(configBlock, params);
+        }
+        // // 尾块
+        // for (int i = 0; i < configBlock.tileBlockCount; ++i) {
+        //     blockOp.Run(configBlock, params);
+        // }
+    }
+};
+
+} // 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
new file mode 100644
index 0000000000000000000000000000000000000000..40891a329215b2b6dc15f8b6554f4bc70f63cded
--- /dev/null
+++ b/best_practices/atvos_demo/include/tile/tile_elewise.h
@@ -0,0 +1,17 @@
+#ifndef TILE_ELE_WISE_H
+#define TILE_ELE_WISE_H
+#include "tile_evaluator_common.h"
+// #include "tile_operator.h"
+
+
+namespace ATVC::Tile {
+
+template <typename Expr, typename ArgTup>
+__aicore__ inline void Evaluate(ArgTup& args)
+{
+    auto localVar = AscendC::Std::tuple<>{};
+    DemoEval::Evaluator<Expr>{}(Expr{}, args, localVar);
+}
+
+} // 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 0000000000000000000000000000000000000000..5c431e38deb2b08dcdef699bebfd2e358c265664
--- /dev/null
+++ b/best_practices/atvos_demo/include/tile/tile_evaluator_common.h
@@ -0,0 +1,261 @@
+#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>
+    __aicore__ 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>
+// 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)
+{
+    static_assert(IsLocalVar_v<L>, "A LocalVar is needed");
+    if constexpr (!std::is_same_v<typename L::Like, void>) {
+        MakeAlikeDatum(localVar, AscendC::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>>(
+         AscendC::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, 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);
+    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>
+    __aicore__ decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              ArgTup& /*args*/,
+                              LocalVarTup& localVars) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return AscendC::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>
+    __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 =
+            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 AscendC::Std::get<index>(args);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(AscendC::Std::get<index>(args));
+        }
+    }
+};
+
+template <typename T, typename U>
+__aicore__ 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>
+    __aicore__  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>
+    __aicore__ 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>
+__aicore__ auto Add(const T& src1, const U& src2)
+{
+    return src1 + src2;
+}
+
+template <typename T>
+__aicore__ inline void AddAssign(AscendC::LocalTensor<T>& dst,
+               const AscendC::LocalTensor<T>& src1,
+               const AscendC::LocalTensor<T>& src2)
+{
+    AscendC::printf("AddAssign 1");
+    AscendC::Add(dst, src1, src2, src2.GetSize());
+    AscendC::Adds(dst, dst, (T)3, 32);
+    AscendC::DumpTensor(dst, 111, 64);
+}
+
+// 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>
+    __aicore__ 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>
+    __aicore__ 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 0000000000000000000000000000000000000000..49c0a3507c0b195b71746a2575982bb7062464ed
--- /dev/null
+++ b/best_practices/atvos_demo/include/tile/tile_operator.h
@@ -0,0 +1,16 @@
+#ifndef __ATVC_TILE_OPERATOR_H__
+#define __ATVC_TILE_OPERATOR_H__
+#include "tile_evaluator_common.h"
+
+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 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 0000000000000000000000000000000000000000..35a63dfd9f6cf2e60d36aa58e4733ee61a946e9a
--- /dev/null
+++ b/best_practices/atvos_demo/include/utils/buf_pool/ele_buf_pool.h
@@ -0,0 +1,40 @@
+#ifndef __ATVC_UTILS_ELE_BUF_POOL_H__
+#define __ATVC_UTILS_ELE_BUF_POOL_H__
+namespace ATVC::UTILS {
+
+class EleBufPool {
+public:
+    __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);
+    }
+
+    // __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/include/utils/expression/expression.h b/best_practices/atvos_demo/include/utils/expression/expression.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e6cac33a498a45faf9a08309bdd24a17b872c9f
--- /dev/null
+++ b/best_practices/atvos_demo/include/utils/expression/expression.h
@@ -0,0 +1,308 @@
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
+#include <cstddef>
+#include <iostream>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "utility.h"
+
+/* Expression templates */
+
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
+// NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature)
+// NOLINTBEGIN(misc-unconventional-assign-operator)
+
+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;
+    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>
+__host_aicore__ 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");
+    static constexpr bool hasData =
+        HasDataTrait<T>::value || HasDataTrait<U>::value;
+    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>
+__host_aicore__ 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>
+__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>
+__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>
+__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>
+__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>
+__host_aicore__ 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 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 0000000000000000000000000000000000000000..7e56558ca1ee13c5e658d0b88bc8cd1a92549b81
--- /dev/null
+++ b/best_practices/atvos_demo/include/utils/expression/utility.h
@@ -0,0 +1,206 @@
+#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
new file mode 100644
index 0000000000000000000000000000000000000000..281d25f3a42d354531b585dbc73128602c0bd7fa
--- /dev/null
+++ b/best_practices/atvos_demo/test/main.cpp
@@ -0,0 +1,60 @@
+#include <cstddef>
+#include <iostream>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#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)
+{
+    KernelOp op;
+    AscendC::TPipe pipeIn;
+    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/common.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"
+
+
+// 描述计算逻辑
+struct MyAddOp : ATVC::ExprTmpl::Maker {
+    template <template <typename> class VectorType>
+    __host_aicore__ 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 = _1 + _2);
+    }
+};
+
+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);
+    DeviceOp deviceOp;
+    deviceOp.Run(v1, v2, v3); // 完成 core num计算 kernel launch
+    std::cout<<"test out !"<<std::endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/best_practices/expression_template/.clang-format b/best_practices/expression_template/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..077c7228a4bd00be59f6337d39c9ad749e166fa1
--- /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
+...
diff --git a/best_practices/expression_template/CMakeLists.txt b/best_practices/expression_template/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f7b70e5767b5f274303f1d5f6e70bb159edfb223
--- /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
+                          Boost::boost Threads::Threads)
+    target_sources(expr_template_demo PRIVATE
+                   dpopen.c pipeline.cpp type_formatter.cpp)
+endif()
diff --git a/best_practices/expression_template/block_emulation1.h b/best_practices/expression_template/block_emulation1.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfe091c3e79a2ad5f767459fbca9daf053827e7e
--- /dev/null
+++ b/best_practices/expression_template/block_emulation1.h
@@ -0,0 +1,293 @@
+#ifndef BLOCK_EMULATION1_H
+#define BLOCK_EMULATION1_H
+
+/* Block Emulation 1 */
+
+#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 BlockEmulation1 {
+
+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<Util::TMP::Get_t<Params, Ints>>(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; // 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,
+          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 BlockEmulation1
+
+#endif // BLOCK_EMULATION1_H
diff --git a/best_practices/expression_template/block_emulation2.h b/best_practices/expression_template/block_emulation2.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7e9d36ea9a07e156344514f02a9646fc0ff4b5b
--- /dev/null
+++ b/best_practices/expression_template/block_emulation2.h
@@ -0,0 +1,889 @@
+#ifndef BLOCK_EMULATION2_H
+#define BLOCK_EMULATION2_H
+
+/* Block Emulation 2 */
+
+#include <cmath>
+#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::Concatenate_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::Map_t;
+using Util::TMP::Reverse_t;
+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 Context>
+    decltype(auto) operator()(const T& value, Context& /*context*/) 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, typename U>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<U>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename T, typename U, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<U, 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<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 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<Get_t<Params, Ints>>(arg...)...);
+}
+
+template <typename Params, std::size_t Index, typename ParamTup,
+          typename ArgTup>
+constexpr decltype(auto) ConvertOneArg(ParamTup& params, ArgTup& args)
+{
+    constexpr auto pos =
+        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);
+    }
+}
+
+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 = 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 Context>
+    decltype(auto) operator()(LocalVar<N, T, L> /*unused*/,
+                              Context& context) const
+    {
+        static_assert(N > 0, "LocalVar number starts from 1");
+        return std::get<N - 1>(context.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 Context>
+    decltype(auto) operator()(Param<N, T, U> /*unused*/,
+                              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>(context.convArgs);
+        } else {
+            static_assert(
+                U == ParamUsage::in,
+                "Only in-parameters allow implicit type conversions");
+            return static_cast<T>(std::get<index>(context.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 Context>
+    void operator()(const OpAssign<T, U>& op, Context& context) const
+    {
+        Assign(Evaluator<T>{}(op.GetLhs(), context),
+               Evaluator<U>{}(op.GetRhs(), context));
+    }
+};
+
+// Partial specializtion for E_x, E_y
+template <typename T, typename U>
+struct Evaluator<OpAndThen<T, U>> {
+    using Type = typename Evaluator<U>::Type;
+
+    template <typename Context>
+    Type operator()(const OpAndThen<T, U>& op, Context& context) const
+    {
+        // operator, evaluates sequentially
+        return Evaluator<T>{}(op.GetLhs(), context),
+               Evaluator<U>{}(op.GetRhs(), context);
+    }
+};
+
+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 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)
+{
+    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, 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)
+{
+    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)
+{
+    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 Context>
+    Type operator()(const OpAdd<T, U>& op, Context& context) const
+    {
+        return Add(Evaluator<T>{}(op.GetLhs(), context),
+                   Evaluator<U>{}(op.GetRhs(), context));
+    }
+};
+
+// Partial specializtion for E_x - E_y
+template <typename T, typename U>
+struct Evaluator<OpSubtract<T, U>> {
+    using Type =
+        decltype(Subtract(std::declval<typename Evaluator<T>::Type>(),
+                          std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename Context>
+    Type operator()(const OpSubtract<T, U>& op, Context& context) const
+    {
+        return Subtract(Evaluator<T>{}(op.GetLhs(), context),
+                        Evaluator<U>{}(op.GetRhs(), context));
+    }
+};
+
+// 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 Context>
+    Dest operator()(const OpCast<Dest, Mode, T>& op, Context& context) const
+    {
+        return Cast<Dest, Mode>(Evaluator<T>{}(op.GetData(), context));
+    }
+};
+
+// 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 Context>
+    void operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    Context& context) const
+    {
+        AddAssign(Evaluator<T>{}(op.GetLhs(), context),
+                  Evaluator<U>{}(op.GetRhs().GetLhs(), context),
+                  Evaluator<V>{}(op.GetRhs().GetRhs(), context));
+    }
+};
+
+// 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>>> {
+    using Type = void;
+
+    template <typename Context>
+    void operator()(const OpAssign<T, OpCast<Dest, Mode, U>>& op,
+                    Context& context) const
+    {
+        CastAssign<Dest, Mode>(
+            Evaluator<T>{}(op.GetLhs(), context),
+            Evaluator<U>{}(op.GetRhs().GetData(), context));
+    }
+};
+
+// Partial specialization for Alloc(E)
+template <typename T>
+struct Evaluator<OpAlloc<T>> {
+    using Type = void;
+
+    template <typename Context>
+    void operator()(const OpAlloc<T>& op, Context& context) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
+        // Do nothing for now
+        (void)obj;
+    }
+};
+
+// Partial specialization for Free(E)
+template <typename T>
+struct Evaluator<OpFree<T>> {
+    using Type = void;
+
+    template <typename Context>
+    void operator()(const OpFree<T>& op, Context& context) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
+        // Do nothing for now
+        (void)obj;
+    }
+};
+
+// Partial specialization for CopyIn(E)
+template <typename T>
+struct Evaluator<OpCopyInParam<T>> {
+    using Type = void;
+
+    template <typename Context>
+    void operator()(const OpCopyInParam<T>& op, Context& context) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
+        CopyInParam<T>(obj, context.orgArgs, context.blockSize);
+    }
+};
+
+// Partial specialization for CopyOut(E)
+template <typename T>
+struct Evaluator<OpCopyOutParam<T>> {
+    using Type = void;
+
+    template <typename Context>
+    void operator()(const OpCopyOutParam<T>& op, Context& context) const
+    {
+        auto& obj = Evaluator<T>{}(op.GetData(), context);
+        CopyOutParam<T>(obj, context.orgArgs, context.blockSize);
+    }
+};
+
+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 T>
+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>;
+};
+
+template <typename T, typename U, typename... Rest>
+struct BuildExpression<TypeList<T, U, Rest...>>
+{
+    using Type =
+        typename Detail::BuildExpressionHelper<Expression<T>,
+                                               TypeList<U, Rest...>>::Type;
+};
+
+template <typename ExprList, typename Param>
+struct FirstAndLastUse {
+    static constexpr std::size_t firstUse =
+        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>>;
+};
+
+template <typename ExprList>
+struct FirstAndLastUseFinder {
+    template <typename Param>
+    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
+    {
+        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>{};
+        } else {
+            return ExprList{};
+        }
+    }
+};
+
+struct CopyOutInserter {
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) 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>{};
+        } else {
+            return ExprList{};
+        }
+    }
+};
+
+struct AllocInserter {
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) 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>{};
+    }
+};
+
+struct FreeInserter {
+    template <typename T, typename ExprList>
+    constexpr auto operator()(T, ExprList) 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>{};
+    }
+};
+
+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 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 =
+            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{},
+                               ExprList{});
+
+        // 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);
+
+        using Result = typename BuildExpression<decltype(result4)>::Type;
+        return Result{};
+    } else {
+        return expr;
+    }
+}
+
+template <AutoOpOnDemand AutoOpFlag = AutoOpOnDemand::yes,
+          typename ExprMaker, typename... Args>
+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)...);
+
+    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(Size_v<InParams> != 0);
+    const std::size_t len =
+        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, context);
+    }
+    if (i < len) {
+        std::size_t sizeTB = len - i;  // tail-block size
+        auto exprTB =
+            AddOpOnDemand<AutoOpFlag>(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
+
+        ContextData context{argTuple, convertedArgsTB, localVarsTB, sizeTB};
+        Evaluator<ExprTB>{}(exprTB.data, context);
+    }
+
+    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/demo_eval.h b/best_practices/expression_template/demo_eval.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8c86558e337dbd62695decf7a2f6e6e8324e41e
--- /dev/null
+++ b/best_practices/expression_template/demo_eval.h
@@ -0,0 +1,530 @@
+#ifndef DEMO_EVAL_H
+#define DEMO_EVAL_H
+
+/* Demo Evaluation */
+
+#include <cmath>
+#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
+    {
+        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, typename U>
+void MakeAlikeDatum(std::vector<T>& dst, const std::vector<U>& src)
+{
+    dst.resize(src.size());
+}
+
+template <typename T, typename U, typename L>
+void MakeAlikeDatum(Tensor<T, L>& dst, const Tensor<U, 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 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);
+    }
+}
+
+// Partial specialization for Cast<Dest, Mode>(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));
+    }
+};
+
+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
+    {
+        Assign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+               Evaluator<U>{}(op.GetRhs(), args, localVars));
+    }
+};
+
+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>> {
+    using Type = typename Evaluator<U>::Type;
+
+    template <typename ArgTup, typename LocalVarTup>
+    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);
+    }
+};
+
+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, 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)
+{
+    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>
+    Type 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(Subtract(std::declval<typename Evaluator<T>::Type>(),
+                          std::declval<typename Evaluator<U>::Type>()));
+
+    template <typename ArgTup, typename LocalVarTup>
+    Type 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>
+    void operator()(const OpAssign<T, OpAdd<U, V>>& op,
+                    ArgTup& args,
+                    LocalVarTup& localVars) const
+    {
+        AddAssign(Evaluator<T>{}(op.GetLhs(), args, localVars),
+                  Evaluator<U>{}(op.GetRhs().GetLhs(), args, localVars),
+                  Evaluator<V>{}(op.GetRhs().GetRhs(), args, localVars));
+    }
+};
+
+// 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>> {
+    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);
+    }
+};
+
+// 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/dpopen.c b/best_practices/expression_template/dpopen.c
new file mode 100644
index 0000000000000000000000000000000000000000..83a1902e9bc4e5c9e4faba6971e2cce5733a200d
--- /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 0000000000000000000000000000000000000000..a94a4e7347bbd500c5a3dd50dcbc61412ddbf6a4
--- /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/emulation.h b/best_practices/expression_template/emulation.h
new file mode 100644
index 0000000000000000000000000000000000000000..839d9cfbb3a20667b86a4670793e654324bf575a
--- /dev/null
+++ b/best_practices/expression_template/emulation.h
@@ -0,0 +1,233 @@
+#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<Util::TMP::Get_t<Params, Ints>>(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
new file mode 100644
index 0000000000000000000000000000000000000000..3160ea8dc51e9ed5a6428788ff5522a10b4656cf
--- /dev/null
+++ b/best_practices/expression_template/expr_template_demo.cpp
@@ -0,0 +1,206 @@
+#include <algorithm>
+#include <cstddef>
+#include <iostream>
+#include <vector>
+#include "block_emulation1.h"
+#include "block_emulation2.h"
+#include "demo_eval.h"
+#include "emulation.h"
+#include "expr_tmpl.h"
+#include "layout.h"
+#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>
+    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>>();
+        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);
+    }
+};
+
+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));
+    }
+};
+
+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<double>, ParamUsage::out>();
+        auto tmp = DefineLocalVarLike<1, VectorType<T>>(_1);
+        return (tmp = _1 + _2, _3 = Cast<double>(tmp));
+    }
+};
+
+#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;
+    using namespace Demo;
+    using namespace DemoEval;
+
+    auto _1 = DefineParam<1, int>();
+    auto _2 = DefineParam<2, int>();
+    [[maybe_unused]] auto result1 = _1 + _2;
+    [[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';
+    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);
+    std::cout << out << '\n';
+
+    auto outVar = Expression{out};
+
+    auto tmp1 = DefineLocalVar<1, float>();
+    auto tmp2 = DefineAutoLocalVar<2>(tmp1 + tmp1);
+    auto result5 = (tmp1 = _1 + _2,
+                    tmp2 = tmp1 + tmp1,
+                    tmp2 = tmp2 + 0.5,
+                    outVar = Cast<int, CastMode::round>(tmp2),
+                    tmp2);
+    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
+    auto srcParam = DefineParam<1, Tensor<float>>();
+    auto dstParam = DefineParam<2, Tensor<float>, ParamUsage::out>();
+    auto localVar = DefineLocalVarLike<1>(srcParam);
+    auto result7 = (CopyInData(localVar, srcParam),
+                    CopyOutData(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";
+    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);
+    std::vector<float> v4(300, 4.0F);
+    std::vector<float> v5(300);
+    std::cout
+        << "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';
+
+    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);
+    }
+    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<AutoOpOnDemand::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);
+    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<double> t3(vd.data(), 300, make_layout(300));
+        DoElementwise<AutoOpOnDemand::yes>(AddOpWithCopyOnDemand<float>{},
+                                           t1, t2, t3);
+    }
+    std::cout << vd[0] << ' ' << vd[1] << ' ' << vd[2] << " ... " << vd[299]
+              << '\n';
+}
diff --git a/best_practices/expression_template/expr_tmpl.h b/best_practices/expression_template/expr_tmpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..0cdcfd40cd5fb45f43af4d0d969b1db8fb14715f
--- /dev/null
+++ b/best_practices/expression_template/expr_tmpl.h
@@ -0,0 +1,647 @@
+#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 T = void, typename L>
+constexpr auto DefineLocalVarLike(Expression<L> /*unused*/)
+{
+    static_assert(IsParam_v<L>, "A LocalVar can only be like a Param");
+    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>
+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 = 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:
+    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(); }
+};
+
+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;
+
+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>
+struct LocalVarCollectorHelper;
+
+template <typename T>
+using LocalVarCollector = LocalVarCollectorHelper<T>;
+
+template <typename T, typename>
+struct LocalVarCollectorHelper {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct LocalVarCollectorHelper<T, std::enable_if_t<IsLocalVar_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct LocalVarCollectorHelper<T, std::enable_if_t<IsUnaryOp_v<T>>> {
+    using Type = typename LocalVarCollector<typename T::DataType>::Type;
+};
+
+template <typename 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 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 ParamCollectorHelper;
+
+template <typename T>
+using ParamCollector = ParamCollectorHelper<T>;
+
+template <typename T, typename>
+struct ParamCollectorHelper {
+    using Type = TypeList<>;
+};
+
+template <typename T>
+struct ParamCollectorHelper<T, std::enable_if_t<IsParam_v<T>>> {
+    using Type = TypeList<T>;
+};
+
+template <typename T>
+struct ParamCollectorHelper<T, std::enable_if_t<IsUnaryOp_v<T>>> {
+    using Type = typename ParamCollector<typename T::DataType>::Type;
+};
+
+template <typename 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 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>;
+};
+
+} // namespace Detail
+
+template <typename T, std::size_t N>
+struct IsParamN : std::false_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 {
+    template <typename T>
+    using Type = IsParamN<T, N>;
+};
+
+template <typename T, std::size_t N>
+struct HasParamN {
+private:
+    using ParamsInT = typename 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 =
+        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::All_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 = typename Detail::UniqueParams<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::All_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 IsInParam : std::bool_constant<U::usage == ParamUsage::in ||
+                                          U::usage == ParamUsage::in_out> {
+    };
+    using Type =
+        Util::TMP::Filter_t<IsInParam,
+                            typename Detail::UniqueParams<T>::Type>;
+};
+
+template <typename T>
+using InParams_t = typename InParams<T>::Type;
+
+template <typename T>
+struct OutParams {
+    template <typename U>
+    struct IsOutParam : std::bool_constant<U::usage == ParamUsage::out ||
+                                           U::usage == ParamUsage::in_out> {
+    };
+    using Type =
+        Util::TMP::Filter_t<IsOutParam,
+                            typename Detail::UniqueParams<T>::Type>;
+};
+
+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;
+    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}};
+}
+
+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 Dest, CastMode Mode = CastMode::normal, typename T>
+[[nodiscard]] constexpr auto Cast(Expression<T> t)
+{
+    return Expression<OpCast<Dest, Mode, 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 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;
+    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}};
+}
+
+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 {};
+
+} // 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/layout.h b/best_practices/expression_template/layout.h
new file mode 100644
index 0000000000000000000000000000000000000000..1289386c3083fb9df21d09c4ab99d00630329fe1
--- /dev/null
+++ b/best_practices/expression_template/layout.h
@@ -0,0 +1,255 @@
+#ifndef LAYOUT_H
+#define LAYOUT_H
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <functional>
+#include <numeric>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+namespace Demo {
+
+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())
+    {
+    }
+
+    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]; }
+
+    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)
+    {
+    }
+
+    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_; }
+    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) {
+            // 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];
+            }
+        }
+
+        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 Demo
+
+#endif // LAYOUT_H
diff --git a/best_practices/expression_template/pipeline.cpp b/best_practices/expression_template/pipeline.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..180014ae45b2782a3303c0374891c27527fe4dfe
--- /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 0000000000000000000000000000000000000000..63b0f3777c0ddeb576ace7574a1f9403cd4d1ac3
--- /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/tensor.h b/best_practices/expression_template/tensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..31fdac282ffb0d5cff58b8094a573b54bf250a4e
--- /dev/null
+++ b/best_practices/expression_template/tensor.h
@@ -0,0 +1,695 @@
+#ifndef TENSOR_H
+#define TENSOR_H
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "layout.h"
+
+namespace Demo {
+
+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(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]; }
+
+    template <typename... Coords>
+    T& operator()(Coords... coords)
+    {
+        return ptr_[layout_(coords...)];
+    }
+    template <typename... Coords>
+    const T& operator()(Coords... coords) const
+    {
+        return ptr_[layout_(coords...)];
+    }
+
+    // 1D iterator
+    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_;
+    };
+
+    // 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_;
+    };
+
+    // 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>
+    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()};
+    }
+
+    // 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};
+    }
+
+    // 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};
+    }
+
+    std::size_t size() const { return len_; }
+
+    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_; }
+
+    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 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_) {
+            throw std::logic_error("Destination vector is too small");
+        }
+        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)
+    {
+        if (src.size() > len_) {
+            throw std::logic_error("Source vector is too big");
+        }
+        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_) {
+            throw std::logic_error("Destination vector is too small");
+        }
+        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_;
+};
+
+// 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:
+    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 Demo
+
+#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 0000000000000000000000000000000000000000..8c97f1cacc05494925dced41f7d57b1d2624ed83
--- /dev/null
+++ b/best_practices/expression_template/tensor_test.cpp
@@ -0,0 +1,86 @@
+#include "tensor.h"
+#include <algorithm>
+#include <cstddef>
+#include <iostream>
+#include <iterator>
+#include "demo_eval.h"
+#include "layout.h"
+
+using namespace Demo;
+
+int main()
+{
+    using namespace DemoEval;
+
+    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 < 2; ++j) {
+            for (int k = 0; k < 3; ++k) {
+                std::cout << tensor(i, j, k) << ' ';
+            }
+            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(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';
+
+    Tensor<float> tensor2;
+    tensor2 = tensor;
+    std::copy(tensor2.begin(), tensor2.end(),
+              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();
+    // No tensor or slice can be accessed from now on
+}
diff --git a/best_practices/expression_template/type_formatter.cpp b/best_practices/expression_template/type_formatter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb39fbc4a79bbb42df0799229f6da931a35008f9
--- /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 0000000000000000000000000000000000000000..d89d88fdb1a75d9b62dc3f52066d1eeae1642c3b
--- /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
diff --git a/best_practices/expression_template/util.h b/best_practices/expression_template/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5590c32d4c51855267fdcdde8c235438aff8a6b
--- /dev/null
+++ b/best_practices/expression_template/util.h
@@ -0,0 +1,759 @@
+#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>
+constexpr 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 {
+
+// 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;
+
+// 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>>>
+    constexpr explicit CompressedDataStorage(U&& u) : data_(std::forward<U>(u))
+    {
+    }
+
+    CompressedDataStorage() = default;
+
+    constexpr T& Data() { return data_; }
+    constexpr 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>>>
+    constexpr explicit CompressedDataStorage(U&& u) : T(std::forward<U>(u))
+    {
+    }
+
+    CompressedDataStorage() = default;
+
+    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
+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>
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
+        : first_(std::forward<U1>(f)), second_(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    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_;
+    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>
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
+        : T1(std::forward<U1>(f)), second_(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    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_;
+};
+
+// 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>
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
+        : T2(std::forward<U2>(s)), first_(std::forward<U1>(f))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    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_;
+};
+
+// 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>
+    constexpr CompressedPairStorage(U1&& f, U2&& s)
+        : T1(std::forward<U1>(f)), T2(std::forward<U2>(s))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    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>
+    constexpr CompressedPairStorage(U1&& f, U2&&) : T(std::forward<U1>(f))
+    {
+    }
+
+    CompressedPairStorage() = default;
+
+    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
+
+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>>>
+    constexpr explicit CompressedData(U&& u) : Storage(std::forward<U>(u))
+    {
+    }
+
+    // Accessors for data
+    constexpr T& Data() { return Storage::Data(); }
+    constexpr 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>
+constexpr void swap(CompressedData<T>& lhs, CompressedData<T>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+// Equality comparison operators
+template <typename T>
+constexpr bool operator==(const CompressedData<T>& lhs,
+                          const CompressedData<T>& rhs)
+{
+    return lhs.Data() == rhs.Data();
+}
+
+template <typename T>
+constexpr 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,
+                           Detail::CompressFirst_v<T1, T2>,
+                           Detail::CompressSecond_v<T1, T2>> {
+    using Storage = Detail::CompressedPairStorage<
+        T1, T2,
+        Detail::CompressFirst_v<T1, T2>,
+        Detail::CompressSecond_v<T1, T2>>;
+
+public:
+    using FirstType = T1;
+    using SecondType = T2;
+
+    // Default constructor
+    CompressedPair() = default;
+
+    // Perfect forwarding constructor
+    template <typename U1, typename U2>
+    constexpr CompressedPair(U1&& f, U2&& s)
+        : Storage(std::forward<U1>(f), std::forward<U2>(s))
+    {
+    }
+
+    // Accessors for first element
+    constexpr T1& First() { return Storage::First(); }
+    constexpr const T1& First() const { return Storage::First(); }
+
+    // Accessors for second element
+    constexpr T2& Second() { return Storage::Second(); }
+    constexpr const T2& Second() const { return Storage::Second(); }
+
+    // Swap
+    constexpr 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>
+constexpr void swap(CompressedPair<T1, T2>& lhs,
+                    CompressedPair<T1, T2>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+// Equality comparison operators
+template <typename T1, typename T2>
+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>
+constexpr bool operator!=(const CompressedPair<T1, T2>& lhs,
+                          const CompressedPair<T1, T2>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+namespace TMP {
+
+template <typename T>
+struct TypeWrapper {
+    using Type = T;
+};
+
+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...>>
+    : std::integral_constant<std::size_t, sizeof...(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;
+
+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... Lists>
+struct Concatenate<List1, List2, Lists...> {
+    using Type =
+        typename Concatenate<typename Concatenate<List1, List2>::Type,
+                             Lists...>::Type;
+};
+
+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;
+
+template <template <typename> class Pred, typename Head, typename... Tail>
+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<>> : std::true_type {};
+
+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<Head, typename Filter<Pred, TypeList<Tail...>>::Type>,
+        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;
+
+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;
+
+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> {
+    // Always false if matched here
+    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 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 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;
+
+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>
+using Map_t = typename Map<Proc, List>::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, 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;
+
+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;
+
+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>
+    : std::bool_constant<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>
+constexpr auto ForEach(TypeList<>, Func&& /*func*/, Data data)
+{
+    return data;
+}
+
+template <typename Head, typename... Tail, typename Func, typename 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));
+}
+
+} // 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
diff --git a/best_practices/expression_template/util_test.cpp b/best_practices/expression_template/util_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..031a43a9f5d82d07ef0bc40c956affc339e5bebf
--- /dev/null
+++ b/best_practices/expression_template/util_test.cpp
@@ -0,0 +1,61 @@
+#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';
+    }
+    {
+        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>>);
+    }
+}