1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Mehdi Goli Codeplay Software Ltd. 5 // Ralph Potter Codeplay Software Ltd. 6 // Luke Iwanski Codeplay Software Ltd. 7 // Contact: <eigen@codeplay.com> 8 // 9 // This Source Code Form is subject to the terms of the Mozilla 10 // Public License v. 2.0. If a copy of the MPL was not distributed 11 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 12 13 /***************************************************************** 14 * TensorSyclExprConstructor.h 15 * 16 * \brief: 17 * This file re-create an expression on the SYCL device in order 18 * to use the original tensor evaluator. 19 * 20 *****************************************************************/ 21 22 #ifndef UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_EXPR_CONSTRUCTOR_HPP 23 #define UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_EXPR_CONSTRUCTOR_HPP 24 25 namespace Eigen { 26 namespace TensorSycl { 27 namespace internal { 28 /// this class is used by EvalToOp in order to create an lhs expression which is 29 /// a pointer from an accessor on device-only buffer 30 template <typename PtrType, size_t N, typename... Params> 31 struct EvalToLHSConstructor { 32 PtrType expr; EvalToLHSConstructorEvalToLHSConstructor33 EvalToLHSConstructor(const utility::tuple::Tuple<Params...> &t): expr((&(*(utility::tuple::get<N>(t).get_pointer())))) {} 34 }; 35 36 /// struct ExprConstructor is used to reconstruct the expression on the device and 37 /// recreate the expression with MakeGlobalPointer containing the device address 38 /// space for the TensorMap pointers used in eval function. 39 /// It receives the original expression type, the functor of the node, the tuple 40 /// of accessors, and the device expression type to re-instantiate the 41 /// expression tree for the device 42 template <typename OrigExpr, typename IndexExpr, typename... Params> 43 struct ExprConstructor; 44 45 /// specialisation of the \ref ExprConstructor struct when the node type is 46 /// TensorMap 47 #define TENSORMAP(CVQual)\ 48 template <typename Scalar_, int Options_, int Options2_, int Options3_, int NumIndices_, typename IndexType_,\ 49 template <class> class MakePointer_, size_t N, typename... Params>\ 50 struct ExprConstructor< CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakeGlobalPointer>,\ 51 CVQual PlaceHolder<CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options3_, MakePointer_>, N>, Params...>{\ 52 typedef CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakeGlobalPointer> Type;\ 53 Type expr;\ 54 template <typename FuncDetector>\ 55 ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\ 56 : expr(Type((&(*(utility::tuple::get<N>(t).get_pointer()))), fd.dimensions())) {}\ 57 }; 58 59 TENSORMAP(const) 60 TENSORMAP() 61 #undef TENSORMAP 62 63 #define UNARYCATEGORY(CVQual)\ 64 template <template<class, class> class UnaryCategory, typename OP, typename OrigRHSExpr, typename RHSExpr, typename... Params>\ 65 struct ExprConstructor<CVQual UnaryCategory<OP, OrigRHSExpr>, CVQual UnaryCategory<OP, RHSExpr>, Params...> {\ 66 typedef ExprConstructor<OrigRHSExpr, RHSExpr, Params...> my_type;\ 67 my_type rhsExpr;\ 68 typedef CVQual UnaryCategory<OP, typename my_type::Type> Type;\ 69 Type expr;\ 70 template <typename FuncDetector>\ 71 ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\ 72 : rhsExpr(funcD.rhsExpr, t), expr(rhsExpr.expr, funcD.func) {}\ 73 }; 74 75 UNARYCATEGORY(const) 76 UNARYCATEGORY() 77 #undef UNARYCATEGORY 78 79 /// specialisation of the \ref ExprConstructor struct when the node type is 80 /// TensorBinaryOp 81 #define BINARYCATEGORY(CVQual)\ 82 template <template<class, class, class> class BinaryCategory, typename OP, typename OrigLHSExpr, typename OrigRHSExpr, typename LHSExpr,\ 83 typename RHSExpr, typename... Params>\ 84 struct ExprConstructor<CVQual BinaryCategory<OP, OrigLHSExpr, OrigRHSExpr>, CVQual BinaryCategory<OP, LHSExpr, RHSExpr>, Params...> {\ 85 typedef ExprConstructor<OrigLHSExpr, LHSExpr, Params...> my_left_type;\ 86 typedef ExprConstructor<OrigRHSExpr, RHSExpr, Params...> my_right_type;\ 87 typedef CVQual BinaryCategory<OP, typename my_left_type::Type, typename my_right_type::Type> Type;\ 88 my_left_type lhsExpr;\ 89 my_right_type rhsExpr;\ 90 Type expr;\ 91 template <typename FuncDetector>\ 92 ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\ 93 : lhsExpr(funcD.lhsExpr, t),rhsExpr(funcD.rhsExpr, t), expr(lhsExpr.expr, rhsExpr.expr, funcD.func) {}\ 94 }; 95 96 BINARYCATEGORY(const) 97 BINARYCATEGORY() 98 #undef BINARYCATEGORY 99 100 /// specialisation of the \ref ExprConstructor struct when the node type is 101 /// TensorCwiseTernaryOp 102 #define TERNARYCATEGORY(CVQual)\ 103 template <template <class, class, class, class> class TernaryCategory, typename OP, typename OrigArg1Expr, typename OrigArg2Expr,typename OrigArg3Expr,\ 104 typename Arg1Expr, typename Arg2Expr, typename Arg3Expr, typename... Params>\ 105 struct ExprConstructor<CVQual TernaryCategory<OP, OrigArg1Expr, OrigArg2Expr, OrigArg3Expr>, CVQual TernaryCategory<OP, Arg1Expr, Arg2Expr, Arg3Expr>, Params...> {\ 106 typedef ExprConstructor<OrigArg1Expr, Arg1Expr, Params...> my_arg1_type;\ 107 typedef ExprConstructor<OrigArg2Expr, Arg2Expr, Params...> my_arg2_type;\ 108 typedef ExprConstructor<OrigArg3Expr, Arg3Expr, Params...> my_arg3_type;\ 109 typedef CVQual TernaryCategory<OP, typename my_arg1_type::Type, typename my_arg2_type::Type, typename my_arg3_type::Type> Type;\ 110 my_arg1_type arg1Expr;\ 111 my_arg2_type arg2Expr;\ 112 my_arg3_type arg3Expr;\ 113 Type expr;\ 114 template <typename FuncDetector>\ 115 ExprConstructor(FuncDetector &funcD,const utility::tuple::Tuple<Params...> &t)\ 116 : arg1Expr(funcD.arg1Expr, t), arg2Expr(funcD.arg2Expr, t), arg3Expr(funcD.arg3Expr, t), expr(arg1Expr.expr, arg2Expr.expr, arg3Expr.expr, funcD.func) {}\ 117 }; 118 119 TERNARYCATEGORY(const) 120 TERNARYCATEGORY() 121 #undef TERNARYCATEGORY 122 123 /// specialisation of the \ref ExprConstructor struct when the node type is 124 /// TensorCwiseSelectOp 125 #define SELECTOP(CVQual)\ 126 template <typename OrigIfExpr, typename OrigThenExpr, typename OrigElseExpr, typename IfExpr, typename ThenExpr, typename ElseExpr, typename... Params>\ 127 struct ExprConstructor< CVQual TensorSelectOp<OrigIfExpr, OrigThenExpr, OrigElseExpr>, CVQual TensorSelectOp<IfExpr, ThenExpr, ElseExpr>, Params...> {\ 128 typedef ExprConstructor<OrigIfExpr, IfExpr, Params...> my_if_type;\ 129 typedef ExprConstructor<OrigThenExpr, ThenExpr, Params...> my_then_type;\ 130 typedef ExprConstructor<OrigElseExpr, ElseExpr, Params...> my_else_type;\ 131 typedef CVQual TensorSelectOp<typename my_if_type::Type, typename my_then_type::Type, typename my_else_type::Type> Type;\ 132 my_if_type ifExpr;\ 133 my_then_type thenExpr;\ 134 my_else_type elseExpr;\ 135 Type expr;\ 136 template <typename FuncDetector>\ 137 ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\ 138 : ifExpr(funcD.ifExpr, t), thenExpr(funcD.thenExpr, t), elseExpr(funcD.elseExpr, t), expr(ifExpr.expr, thenExpr.expr, elseExpr.expr) {}\ 139 }; 140 141 SELECTOP(const) 142 SELECTOP() 143 #undef SELECTOP 144 145 /// specialisation of the \ref ExprConstructor struct when the node type is 146 /// const TensorAssignOp 147 #define ASSIGN(CVQual)\ 148 template <typename OrigLHSExpr, typename OrigRHSExpr, typename LHSExpr, typename RHSExpr, typename... Params>\ 149 struct ExprConstructor<CVQual TensorAssignOp<OrigLHSExpr, OrigRHSExpr>, CVQual TensorAssignOp<LHSExpr, RHSExpr>, Params...> {\ 150 typedef ExprConstructor<OrigLHSExpr, LHSExpr, Params...> my_left_type;\ 151 typedef ExprConstructor<OrigRHSExpr, RHSExpr, Params...> my_right_type;\ 152 typedef CVQual TensorAssignOp<typename my_left_type::Type, typename my_right_type::Type> Type;\ 153 my_left_type lhsExpr;\ 154 my_right_type rhsExpr;\ 155 Type expr;\ 156 template <typename FuncDetector>\ 157 ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\ 158 : lhsExpr(funcD.lhsExpr, t), rhsExpr(funcD.rhsExpr, t), expr(lhsExpr.expr, rhsExpr.expr) {}\ 159 }; 160 161 ASSIGN(const) 162 ASSIGN() 163 #undef ASSIGN 164 /// specialisation of the \ref ExprConstructor struct when the node type is 165 /// TensorEvalToOp 166 #define EVALTO(CVQual)\ 167 template <typename OrigExpr, typename Expr, typename... Params>\ 168 struct ExprConstructor<CVQual TensorEvalToOp<OrigExpr, MakeGlobalPointer>, CVQual TensorEvalToOp<Expr>, Params...> {\ 169 typedef ExprConstructor<OrigExpr, Expr, Params...> my_expr_type;\ 170 typedef typename TensorEvalToOp<OrigExpr, MakeGlobalPointer>::PointerType my_buffer_type;\ 171 typedef CVQual TensorEvalToOp<typename my_expr_type::Type, MakeGlobalPointer> Type;\ 172 my_expr_type nestedExpression;\ 173 EvalToLHSConstructor<my_buffer_type, 0, Params...> buffer;\ 174 Type expr;\ 175 template <typename FuncDetector>\ 176 ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\ 177 : nestedExpression(funcD.rhsExpr, t), buffer(t), expr(buffer.expr, nestedExpression.expr) {}\ 178 }; 179 180 EVALTO(const) 181 EVALTO() 182 #undef EVALTO 183 184 /// specialisation of the \ref ExprConstructor struct when the node type is 185 /// TensorForcedEvalOp 186 #define FORCEDEVAL(CVQual)\ 187 template <typename OrigExpr, typename DevExpr, size_t N, typename... Params>\ 188 struct ExprConstructor<CVQual TensorForcedEvalOp<OrigExpr, MakeGlobalPointer>,\ 189 CVQual PlaceHolder<CVQual TensorForcedEvalOp<DevExpr>, N>, Params...> {\ 190 typedef CVQual TensorMap<Tensor<typename TensorForcedEvalOp<DevExpr, MakeGlobalPointer>::Scalar,\ 191 TensorForcedEvalOp<DevExpr, MakeGlobalPointer>::NumDimensions, 0, typename TensorForcedEvalOp<DevExpr>::Index>, 0, MakeGlobalPointer> Type;\ 192 Type expr;\ 193 template <typename FuncDetector>\ 194 ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\ 195 : expr(Type((&(*(utility::tuple::get<N>(t).get_pointer()))), fd.dimensions())) {}\ 196 }; 197 198 FORCEDEVAL(const) 199 FORCEDEVAL() 200 #undef FORCEDEVAL 201 202 template <bool Conds, size_t X , size_t Y > struct ValueCondition { 203 static const size_t Res =X; 204 }; 205 template<size_t X, size_t Y> struct ValueCondition<false, X , Y> { 206 static const size_t Res =Y; 207 }; 208 209 /// specialisation of the \ref ExprConstructor struct when the node type is TensorReductionOp 210 #define SYCLREDUCTIONEXPR(CVQual)\ 211 template <typename OP, typename Dim, typename OrigExpr, typename DevExpr, size_t N, typename... Params>\ 212 struct ExprConstructor<CVQual TensorReductionOp<OP, Dim, OrigExpr, MakeGlobalPointer>,\ 213 CVQual PlaceHolder<CVQual TensorReductionOp<OP, Dim, DevExpr>, N>, Params...> {\ 214 static const size_t NumIndices= ValueCondition< TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::NumDimensions==0, 1, TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::NumDimensions >::Res;\ 215 typedef CVQual TensorMap<Tensor<typename TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::Scalar,\ 216 NumIndices, 0, typename TensorReductionOp<OP, Dim, DevExpr>::Index>, 0, MakeGlobalPointer> Type;\ 217 Type expr;\ 218 template <typename FuncDetector>\ 219 ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\ 220 : expr(Type((&(*(utility::tuple::get<N>(t).get_pointer()))), fd.dimensions())) {}\ 221 }; 222 223 SYCLREDUCTIONEXPR(const) 224 SYCLREDUCTIONEXPR() 225 #undef SYCLREDUCTIONEXPR 226 227 /// template deduction for \ref ExprConstructor struct 228 template <typename OrigExpr, typename IndexExpr, typename FuncD, typename... Params> 229 auto createDeviceExpression(FuncD &funcD, const utility::tuple::Tuple<Params...> &t) 230 -> decltype(ExprConstructor<OrigExpr, IndexExpr, Params...>(funcD, t)) { 231 return ExprConstructor<OrigExpr, IndexExpr, Params...>(funcD, t); 232 } 233 234 } /// namespace TensorSycl 235 } /// namespace internal 236 } /// namespace Eigen 237 238 239 #endif // UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_EXPR_CONSTRUCTOR_HPP 240