wangwei
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 95ac055538
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '95ac055538'
${ noResults }
MegEngine/dnn/src/cuda/handle_create.cpp

248 lines
11 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/src/cuda/handle_create.cpp

  3.  * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")

  4.  *

  5.  * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.

  6.  *

  7.  * Unless required by applicable law or agreed to in writing,

  8.  * software distributed under the License is distributed on an

  9.  * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or

  10.  * implied.

  11.  */

  12. 

  13. // #include "src/common/handle_impl.h"

  14. 

  15. #include "src/cuda/adaptive_pooling/opr_impl.h"

  16. #include "src/cuda/add_update/opr_impl.h"

  17. #include "src/cuda/argmxx/opr_impl.h"

  18. #include "src/cuda/argsort/opr_impl.h"

  19. #include "src/cuda/batch_conv_bias/opr_impl.h"

  20. #include "src/cuda/batch_normalization/opr_impl.h"

  21. #include "src/cuda/batched_matrix_mul/opr_impl.h"

  22. #include "src/cuda/check_non_finite/opr_impl.h"

  23. #include "src/cuda/checksum/opr_impl.h"

  24. #include "src/cuda/concat/opr_impl.h"

  25. #include "src/cuda/cond_take/opr_impl.h"

  26. #include "src/cuda/conv_bias/opr_impl.h"

  27. #include "src/cuda/convolution/opr_impl.h"

  28. #include "src/cuda/convolution3d/opr_impl.h"

  29. #include "src/cuda/convpooling/opr_impl.h"

  30. #include "src/cuda/correlation/opr_impl.h"

  31. #include "src/cuda/cumsum/opr_impl.h"

  32. #include "src/cuda/cvt_color/opr_impl.h"

  33. #include "src/cuda/dct/opr_impl.h"

  34. #include "src/cuda/deformable_conv/opr_impl.h"

  35. #include "src/cuda/deformable_ps_roi_pooling/opr_impl.h"

  36. #include "src/cuda/diag/opr_impl.h"

  37. #include "src/cuda/dot/opr_impl.h"

  38. #include "src/cuda/dropout/opr_impl.h"

  39. #include "src/cuda/elemwise/opr_impl.h"

  40. #include "src/cuda/elemwise_multi_type/opr_impl.h"

  41. #include "src/cuda/eye/opr_impl.h"

  42. #include "src/cuda/fake_quant/opr_impl.h"

  43. #include "src/cuda/fill/opr_impl.h"

  44. #include "src/cuda/flip/opr_impl.h"

  45. #include "src/cuda/gaussian_blur/opr_impl.h"

  46. #include "src/cuda/group_local/opr_impl.h"

  47. #include "src/cuda/images2neibs/opr_impl.h"

  48. #include "src/cuda/indexing_multi_axis_vec/opr_impl.h"

  49. #include "src/cuda/indexing_one_hot/opr_impl.h"

  50. #include "src/cuda/layer_norm/opr_impl.h"

  51. #include "src/cuda/linspace/opr_impl.h"

  52. #include "src/cuda/local/opr_impl.h"

  53. #include "src/cuda/local_share/opr_impl.h"

  54. #include "src/cuda/lrn/opr_impl.h"

  55. #include "src/cuda/lsq/opr_impl.h"

  56. #include "src/cuda/mask_conv/opr_impl.h"

  57. #include "src/cuda/matrix_inverse/opr_impl.h"

  58. #include "src/cuda/matrix_mul/opr_impl.h"

  59. #include "src/cuda/max_tensor_diff/opr_impl.h"

  60. #include "src/cuda/mesh_indexing/opr_impl.h"

  61. #include "src/cuda/padding/opr_impl.h"

  62. #include "src/cuda/param_pack/opr_impl.h"

  63. #include "src/cuda/pooling/opr_impl.h"

  64. #include "src/cuda/powc/opr_impl.h"

  65. #include "src/cuda/reduce/opr_impl.h"

  66. #include "src/cuda/relayout/opr_impl.h"

  67. #include "src/cuda/relayout_format/opr_impl.h"

  68. #include "src/cuda/remap/opr_impl.h"

  69. #include "src/cuda/repeat/opr_impl.h"

  70. #include "src/cuda/resize/opr_impl.h"

  71. #include "src/cuda/rng/opr_impl.h"

  72. #include "src/cuda/roi_align/opr_impl.h"

  73. #include "src/cuda/roi_copy/opr_impl.h"

  74. #include "src/cuda/roi_pooling/opr_impl.h"

  75. #include "src/cuda/rotate/opr_impl.h"

  76. #include "src/cuda/separable_conv/opr_impl.h"

  77. #include "src/cuda/separable_filter/opr_impl.h"

  78. #include "src/cuda/sleep/opr_impl.h"

  79. #include "src/cuda/sliding_window_transpose/opr_impl.h"

  80. #include "src/cuda/softmax/opr_impl.h"

  81. #include "src/cuda/split/opr_impl.h"

  82. #include "src/cuda/svd/opr_impl.h"

  83. #include "src/cuda/tensor_remap/opr_impl.h"

  84. #include "src/cuda/tile/opr_impl.h"

  85. #include "src/cuda/topk/opr_impl.h"

  86. #include "src/cuda/tqt/opr_impl.h"

  87. #include "src/cuda/transpose/opr_impl.h"

  88. #include "src/cuda/type_cvt/opr_impl.h"

  89. #include "src/cuda/warp_affine/opr_impl.h"

  90. #include "src/cuda/warp_perspective/opr_impl.h"

  91. 

  92. namespace megdnn {

  93. namespace cuda {

  94. 

  95. // After Adding CUDA LSTM, the declaration of CUDA Backend should be restored

  96. // MEGDNN_FOREACH_OPR_CLASS(MEGDNN_SPECIALIZE_CREATE_OPERATOR)

  97. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ConvolutionForward);

  98. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ConvolutionBackwardData);

  99. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ConvolutionBackwardFilter);

  100. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ConvPoolingForward);

  101. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ConvBiasForward);

  102. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Images2NeibsForward);

  103. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Images2NeibsBackward);

  104. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SlidingWindowTransposeForward);

  105. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SlidingWindowTransposeBackward);

  106. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ElemwiseForward);

  107. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ElemwiseMultiType);

  108. MEGDNN_SPECIALIZE_CREATE_OPERATOR(AddUpdateForward);

  109. MEGDNN_SPECIALIZE_CREATE_OPERATOR(RelayoutForward);

  110. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PoolingForward);

  111. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PoolingBackward);

  112. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LocalForward);

  113. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LocalBackwardData);

  114. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LocalBackwardFilter);

  115. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LRNForward);

  116. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LRNBackward);

  117. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ROIPoolingForward);

  118. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ROIPoolingBackward);

  119. MEGDNN_SPECIALIZE_CREATE_OPERATOR(WarpPerspectiveForward);

  120. MEGDNN_SPECIALIZE_CREATE_OPERATOR(WarpPerspectiveBackwardData);

  121. MEGDNN_SPECIALIZE_CREATE_OPERATOR(WarpPerspectiveBackwardMat);

  122. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DotForward);

  123. MEGDNN_SPECIALIZE_CREATE_OPERATOR(MatrixInverse);

  124. MEGDNN_SPECIALIZE_CREATE_OPERATOR(MatrixMulForward);

  125. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BatchedMatrixMulForward);

  126. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SVDForward);

  127. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ReduceForward);

  128. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CondTake);

  129. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CumsumForward);

  130. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ArgmaxForward);

  131. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ArgminForward);

  132. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TransposeForward);

  133. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ConcatForward);

  134. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SplitForward);

  135. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TileForward);

  136. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TileBackward);

  137. MEGDNN_SPECIALIZE_CREATE_OPERATOR(RepeatForward);

  138. MEGDNN_SPECIALIZE_CREATE_OPERATOR(RepeatBackward);

  139. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ArgsortForward);

  140. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ArgsortBackward);

  141. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TypeCvt);

  142. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingRemapForward);

  143. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingRemapBackward);

  144. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ChecksumForward);

  145. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingOneHotForward);

  146. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingSetOneHotForward);

  147. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingMultiAxisVec);

  148. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingSetMultiAxisVec);

  149. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IndexingIncrMultiAxisVec);

  150. MEGDNN_SPECIALIZE_CREATE_OPERATOR(MeshIndexing);

  151. MEGDNN_SPECIALIZE_CREATE_OPERATOR(IncrMeshIndexing);

  152. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SetMeshIndexing);

  153. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BatchedMeshIndexing);

  154. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BatchedIncrMeshIndexing);

  155. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BatchedSetMeshIndexing);

  156. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Linspace);

  157. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Eye);

  158. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Diag);

  159. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SleepForward);

  160. MEGDNN_SPECIALIZE_CREATE_OPERATOR(UniformRNG);

  161. MEGDNN_SPECIALIZE_CREATE_OPERATOR(GaussianRNG);

  162. MEGDNN_SPECIALIZE_CREATE_OPERATOR(GammaRNG);

  163. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BetaRNG);

  164. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PoissonRNG);

  165. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PermutationRNG);

  166. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ShuffleRNGForward);

  167. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ShuffleRNGBackward);

  168. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SeparableConvForward);

  169. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SeparableFilterForward);

  170. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BNForward);

  171. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BNBackward);

  172. MEGDNN_SPECIALIZE_CREATE_OPERATOR(GroupLocalForward);

  173. MEGDNN_SPECIALIZE_CREATE_OPERATOR(GroupLocalBackwardData);

  174. MEGDNN_SPECIALIZE_CREATE_OPERATOR(GroupLocalBackwardFilter);

  175. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Flip);

  176. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Rotate);

  177. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ROICopy);

  178. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CvtColor);

  179. MEGDNN_SPECIALIZE_CREATE_OPERATOR(WarpAffine);

  180. MEGDNN_SPECIALIZE_CREATE_OPERATOR(GaussianBlur);

  181. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Resize);

  182. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ResizeBackward);

  183. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ParamPackConcat);

  184. MEGDNN_SPECIALIZE_CREATE_OPERATOR(MaxTensorDiff);

  185. MEGDNN_SPECIALIZE_CREATE_OPERATOR(MaskConvForward);

  186. MEGDNN_SPECIALIZE_CREATE_OPERATOR(MaskPropagate);

  187. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Convolution3DForward);

  188. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Convolution3DBackwardData);

  189. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Convolution3DBackwardFilter);

  190. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DeformableConvForward);

  191. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DeformableConvBackwardFilter);

  192. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DeformableConvBackwardData);

  193. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DeformablePSROIPoolingForward);

  194. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DeformablePSROIPoolingBackward);

  195. MEGDNN_SPECIALIZE_CREATE_OPERATOR(RelayoutFormat);

  196. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TopK);

  197. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PowC);

  198. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LocalShareForward);

  199. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LocalShareBackwardData);

  200. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LocalShareBackwardFilter);

  201. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ROIAlignForward);

  202. MEGDNN_SPECIALIZE_CREATE_OPERATOR(ROIAlignBackward);

  203. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CorrelationForward);

  204. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CorrelationBackwardData1);

  205. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CorrelationBackwardData2);

  206. MEGDNN_SPECIALIZE_CREATE_OPERATOR(BatchConvBiasForward);

  207. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Remap);

  208. MEGDNN_SPECIALIZE_CREATE_OPERATOR(RemapBackwardData);

  209. MEGDNN_SPECIALIZE_CREATE_OPERATOR(RemapBackwardMat);

  210. MEGDNN_SPECIALIZE_CREATE_OPERATOR(AdaptivePoolingForward);

  211. MEGDNN_SPECIALIZE_CREATE_OPERATOR(AdaptivePoolingBackward);

  212. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DctChannelSelectForward);

  213. MEGDNN_SPECIALIZE_CREATE_OPERATOR(FakeQuantForward);

  214. MEGDNN_SPECIALIZE_CREATE_OPERATOR(FakeQuantBackward);

  215. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TQTForward);

  216. MEGDNN_SPECIALIZE_CREATE_OPERATOR(TQTBackward);

  217. MEGDNN_SPECIALIZE_CREATE_OPERATOR(CheckNonFinite);

  218. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LSQForward);

  219. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LSQBackward);

  220. MEGDNN_SPECIALIZE_CREATE_OPERATOR(Fill);

  221. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PaddingForward);

  222. MEGDNN_SPECIALIZE_CREATE_OPERATOR(PaddingBackward);

  223. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LayerNormForward);

  224. MEGDNN_SPECIALIZE_CREATE_OPERATOR(LayerNormBackward);

  225. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DropoutForward);

  226. MEGDNN_SPECIALIZE_CREATE_OPERATOR(DropoutBackward);

  227. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SoftmaxForward);

  228. MEGDNN_SPECIALIZE_CREATE_OPERATOR(SoftmaxBackward);

  229. 

  230. template <typename Opr>

  231. std::unique_ptr<Opr> HandleImpl::create_operator() {

  232.     megdnn_throw("unsupported cuda opr");

  233.     return nullptr;

  234. }

  235. 

  236. #define MEGDNN_INST_CREATE_OPERATOR(opr) \

  237.     template std::unique_ptr<megdnn::opr> HandleImpl::create_operator();

  238. 

  239. #pragma GCC diagnostic push

  240. #pragma GCC diagnostic ignored "-Wpragmas"

  241. #pragma GCC diagnostic ignored "-Winstantiation-after-specialization"

  242. MEGDNN_FOREACH_OPR_CLASS(MEGDNN_INST_CREATE_OPERATOR)

  243. #pragma GCC diagnostic pop

  244. }  // namespace cuda

  245. }  // namespace megdnn

  246. 

  247. // vim: syntax=cpp.doxygen