Loading...
Searching...
No Matches
TensorSyclExprConstructor.h
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
25namespace Eigen {
26namespace TensorSycl {
27namespace internal {
30template <typename PtrType, size_t N, typename... Params>
31struct EvalToLHSConstructor {
32 PtrType expr;
33 EvalToLHSConstructor(const utility::tuple::Tuple<Params...> &t): expr((&(*(utility::tuple::get<N>(t).get_pointer())))) {}
34};
35
42template <typename OrigExpr, typename IndexExpr, typename... Params>
43struct ExprConstructor;
44
47#define TENSORMAP(CVQual)\
48template <typename Scalar_, int Options_, int Options2_, int Options3_, int NumIndices_, typename IndexType_,\
49template <class> class MakePointer_, size_t N, typename... Params>\
50struct ExprConstructor< CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakeGlobalPointer>,\
51CVQual 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
59TENSORMAP(const)
60TENSORMAP()
61#undef TENSORMAP
62
63#define UNARYCATEGORY(CVQual)\
64template <template<class, class> class UnaryCategory, typename OP, typename OrigRHSExpr, typename RHSExpr, typename... Params>\
65struct 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
75UNARYCATEGORY(const)
76UNARYCATEGORY()
77#undef UNARYCATEGORY
78
81#define BINARYCATEGORY(CVQual)\
82template <template<class, class, class> class BinaryCategory, typename OP, typename OrigLHSExpr, typename OrigRHSExpr, typename LHSExpr,\
83typename RHSExpr, typename... Params>\
84struct 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
96BINARYCATEGORY(const)
97BINARYCATEGORY()
98#undef BINARYCATEGORY
99
102#define TERNARYCATEGORY(CVQual)\
103template <template <class, class, class, class> class TernaryCategory, typename OP, typename OrigArg1Expr, typename OrigArg2Expr,typename OrigArg3Expr,\
104typename Arg1Expr, typename Arg2Expr, typename Arg3Expr, typename... Params>\
105struct 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
119TERNARYCATEGORY(const)
120TERNARYCATEGORY()
121#undef TERNARYCATEGORY
122
125#define SELECTOP(CVQual)\
126template <typename OrigIfExpr, typename OrigThenExpr, typename OrigElseExpr, typename IfExpr, typename ThenExpr, typename ElseExpr, typename... Params>\
127struct 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
141SELECTOP(const)
142SELECTOP()
143#undef SELECTOP
144
147#define ASSIGN(CVQual)\
148template <typename OrigLHSExpr, typename OrigRHSExpr, typename LHSExpr, typename RHSExpr, typename... Params>\
149struct 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
166#define EVALTO(CVQual)\
167template <typename OrigExpr, typename Expr, typename... Params>\
168struct 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
180EVALTO(const)
181EVALTO()
182#undef EVALTO
183
186#define FORCEDEVAL(CVQual)\
187template <typename OrigExpr, typename DevExpr, size_t N, typename... Params>\
188struct ExprConstructor<CVQual TensorForcedEvalOp<OrigExpr, MakeGlobalPointer>,\
189CVQual 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
198FORCEDEVAL(const)
199FORCEDEVAL()
200#undef FORCEDEVAL
201
202template <bool Conds, size_t X , size_t Y > struct ValueCondition {
203 static const size_t Res =X;
204};
205template<size_t X, size_t Y> struct ValueCondition<false, X , Y> {
206 static const size_t Res =Y;
207};
208
210#define SYCLREDUCTIONEXPR(CVQual)\
211template <typename OP, typename Dim, typename OrigExpr, typename DevExpr, size_t N, typename... Params>\
212struct ExprConstructor<CVQual TensorReductionOp<OP, Dim, OrigExpr, MakeGlobalPointer>,\
213CVQual 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
223SYCLREDUCTIONEXPR(const)
224SYCLREDUCTIONEXPR()
225#undef SYCLREDUCTIONEXPR
226
228template <typename OrigExpr, typename IndexExpr, typename FuncD, typename... Params>
229auto 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}
235}
236}
237
238
239#endif // UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_EXPR_CONSTRUCTOR_HPP
Namespace containing all symbols from the Eigen library.
Definition: AdolcForward:45
is a fixed-size collection of heterogeneous values \ztparam Ts... - the types of the elements that th...
Definition: TensorSyclTuple.h:40