/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/develop/projects/miopen/include/miopen/miopen.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/develop/projects/miopen/include/miopen/miopen.h Source File#

MIOpen: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/develop/projects/miopen/include/miopen/miopen.h Source File
miopen.h
Go to the documentation of this file.
1 /*******************************************************************************
2  *
3  * MIT License
4  *
5  * Copyright (c) 2023 Advanced Micro Devices, Inc.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in all
15  * copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  *
25  *******************************************************************************/
26 #ifndef MIOPEN_GUARD_MIOPEN_H_
27 #define MIOPEN_GUARD_MIOPEN_H_
28 
29 #ifdef __clang__
30 #pragma clang diagnostic push
31 #pragma clang diagnostic ignored "-Wextern-c-compat"
32 #endif
33 
34 #include <stddef.h>
35 #include <stdbool.h>
36 #include <miopen/config.h>
37 #include <miopen/export.h>
38 
39 #if MIOPEN_BACKEND_OPENCL
40 #define CL_TARGET_OPENCL_VERSION 120
41 #if defined(__APPLE__) || defined(__MACOSX)
42 #include <OpenCL/cl.h>
43 #else
44 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS
45 #include <CL/cl.h>
46 #endif
47 
48 #elif MIOPEN_BACKEND_HIP
49 #include <hip/hip_runtime_api.h>
50 #endif
51 
52 /*
53  * @defgroup convolutions
54  * @defgroup pooling
55  * @defgroup handle
56  * @defgroup layernorm
57  * @defgroup LRN
58  * @defgroup batchnorm
59  * @defgroup activation
60  * @defgroup tensor
61  * @defgroup softmax
62  * @defgroup RNN
63  * @defgroup fusion
64  * @defgroup LossFunction
65  * @defgroup TensorReduce
66  * @defgroup find2
67  * @defgroup ReduceExtreme
68  * @defgroup groupnorm
69  * @defgroup cat
70  * @defgroup SGD
71  * @defgroup getitem
72  * @defgroup ReduceCalculation
73  * @defgroup RotaryPositionalEmbeddings
74  * @defgroup ReLU
75  *
76  */
77 
79 #define MIOPEN_DECLARE_OBJECT(name) \
80  struct name \
81  { \
82  }; \
83  typedef struct name* name##_t;
84 
85 #ifdef __cplusplus
86 extern "C" {
87 #endif
88 
89 #if MIOPEN_BACKEND_OPENCL
90 typedef cl_command_queue miopenAcceleratorQueue_t;
91 #elif MIOPEN_BACKEND_HIP
92 typedef hipStream_t miopenAcceleratorQueue_t;
93 #endif
94 
98 MIOPEN_DECLARE_OBJECT(miopenHandle);
99 
108 typedef enum
109 {
110  miopenStatusSuccess = 0,
111  miopenStatusNotInitialized = 1,
112  miopenStatusInvalidValue = 2,
113  miopenStatusBadParm = 3,
114  miopenStatusAllocFailed = 4,
115  miopenStatusInternalError = 5,
116  miopenStatusNotImplemented = 6,
117  miopenStatusUnknownError = 7,
118  miopenStatusUnsupportedOp = 8,
119  miopenStatusGpuOperationsSkipped = 9,
120  miopenStatusVersionMismatch = 10,
121 } miopenStatus_t;
122 
123 typedef enum
124 {
125  // TODO:(LYM) temporary use Pedantic as default until TF32 is fully supported
126  miopenMathDefault = 0,
127  miopenMathPedantic =
128  1,
129 } miopenMathType_t;
130 
131 #ifdef MIOPEN_BETA_API
132 typedef enum
133 {
134  miopenF8RoundingModeStandard = 0,
135  miopenF8RoundingModeStochastic = 1,
136 } miopenF8RoundingMode_t;
137 #endif
138 
146 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);
147 
156 typedef void* (*miopenAllocatorFunction)(void* context, size_t sizeBytes);
157 
166 typedef void (*miopenDeallocatorFunction)(void* context, void* memory);
167 
181 MIOPEN_EXPORT miopenStatus_t miopenGetVersion(size_t* major, size_t* minor, size_t* patch);
182 
191 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);
192 
204 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,
205  miopenAcceleratorQueue_t stream);
206 
213 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);
214 
222 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,
223  miopenAcceleratorQueue_t streamID);
224 
232 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,
233  miopenAcceleratorQueue_t* streamID);
234 
251 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,
252  miopenAllocatorFunction allocator,
253  miopenDeallocatorFunction deallocator,
254  void* allocatorContext);
255 
267 MIOPEN_EXPORT miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float* time);
268 
276 MIOPEN_EXPORT miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable);
278 // CLOSEOUT HANDLE DOXYGEN GROUP
279 
287 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);
288 
296 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);
297 
304 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);
305 
313 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);
314 
322 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);
323 
331 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);
332 
339 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);
340 
344 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);
345 
349 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);
350 
354 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);
355 
359 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);
360 
364 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);
365 
369 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);
370 
375 typedef enum
376 {
377  miopenHalf = 0,
378  miopenFloat = 1,
379  miopenInt32 = 2,
380  miopenInt8 = 3,
381  // miopenInt8x4 = 4, /*!< Pack of 4x Int8 in NCHW_VECT_C format (Support discontinued) */
382  miopenBFloat16 = 5,
384  miopenDouble = 6,
385  miopenFloat8_fnuz = 7,
386  miopenBFloat8_fnuz = 8,
387  miopenInt64 = 9,
388 } miopenDataType_t;
389 
395 typedef enum
396 {
397  miopenTensorNCHW = 0,
398  miopenTensorNHWC = 1,
399  miopenTensorCHWN = 2,
400  miopenTensorNCHWc4 = 3,
401  miopenTensorNCHWc8 = 4,
402  miopenTensorCHWNc4 = 5,
403  miopenTensorCHWNc8 = 6,
404  miopenTensorNCDHW = 7,
405  miopenTensorNDHWC = 8,
406 } miopenTensorLayout_t;
407 
412 typedef enum
413 {
414  miopenIndexUint8 = 0,
415  miopenIndexUint16 = 1,
416  miopenIndexUint32 = 2,
417  miopenIndexUint64 = 3,
418 } miopenIndexType_t;
419 
424 typedef enum
425 {
426  miopenTensorOpAdd = 0,
427  miopenTensorOpMul = 1,
428  miopenTensorOpMin = 2,
429  miopenTensorOpMax = 3,
430 } miopenTensorOp_t;
431 
436 typedef enum
437 {
438  miopenConvolution = 0,
439  miopenTranspose = 1,
440  miopenGroupConv = 2,
441  miopenDepthwise = 3,
442 } miopenConvolutionMode_t;
443 
448 typedef enum
449 {
450  miopenPaddingDefault = 0,
451  miopenPaddingSame = 1,
452  miopenPaddingValid = 2,
453 } miopenPaddingMode_t;
454 
459 typedef enum
460 {
461  miopenPoolingMax = 0,
462  miopenPoolingAverage = 1,
463  miopenPoolingAverageInclusive = 2,
464 } miopenPoolingMode_t;
465 
472 typedef enum
473 {
474  miopenPoolingWorkspaceIndexMask = 0,
475  miopenPoolingWorkspaceIndexImage = 1,
476 } miopenPoolingWorkspaceIndexMode_t;
477 
482 typedef enum
483 {
484  miopenLRNWithinChannel = 0,
485  miopenLRNCrossChannel = 1,
486 } miopenLRNMode_t;
487 #ifdef MIOPEN_BETA_API
492 typedef enum
493 {
494  MIOPEN_ELEMENTWISE_AFFINE = 0,
495  MIOPEN_WEIGHT_BIAS =
496  1,
497  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =
498  2,
499  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,
501  MIOPEN_ELEMENTWISE_AFFINE_T5 =
502  4,
503  MIOPEN_WEIGHT_BIAS_T5 = 5,
505 } miopenNormMode_t;
506 #endif
511 typedef enum
512 {
513  miopenBNPerActivation = 0,
514  miopenBNSpatial = 1,
515 } miopenBatchNormMode_t;
516 
521 typedef enum
522 {
523  miopenActivationPASTHRU = 0,
524  miopenActivationLOGISTIC = 1,
525  miopenActivationTANH = 2,
526  miopenActivationRELU = 3,
527  miopenActivationSOFTRELU = 4,
528  miopenActivationABS = 5,
529  miopenActivationPOWER = 6,
530  miopenActivationCLIPPEDRELU =
531  7,
532  miopenActivationLEAKYRELU =
533  8,
534  miopenActivationELU =
535  9,
537  miopenActivationCLAMP = 10,
538 } miopenActivationMode_t;
539 
544 typedef enum
545 {
546  MIOPEN_SOFTMAX_FAST = 0,
547  MIOPEN_SOFTMAX_ACCURATE = 1,
548  MIOPEN_SOFTMAX_LOG = 2,
549 } miopenSoftmaxAlgorithm_t;
550 
555 typedef enum
556 {
557  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,
558  MIOPEN_SOFTMAX_MODE_CHANNEL =
559  1,
560 } miopenSoftmaxMode_t;
561 
569 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1
570 
575 typedef enum
576 {
577  MIOPEN_REDUCE_TENSOR_ADD = 0,
578  MIOPEN_REDUCE_TENSOR_MUL =
579  1,
580  MIOPEN_REDUCE_TENSOR_MIN =
581  2,
582  MIOPEN_REDUCE_TENSOR_MAX =
583  3,
584  MIOPEN_REDUCE_TENSOR_AMAX =
585  4,
586  MIOPEN_REDUCE_TENSOR_AVG =
587  5,
588  MIOPEN_REDUCE_TENSOR_NORM1 =
589  6,
590  MIOPEN_REDUCE_TENSOR_NORM2 = 7,
592  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =
593  // 8, /*!< the operation is same as MUL, but does not have the zero values considered */
594 } miopenReduceTensorOp_t;
595 
600 typedef enum
601 {
602  MIOPEN_NOT_PROPAGATE_NAN = 0,
603  MIOPEN_PROPAGATE_NAN = 1,
604 } miopenNanPropagation_t;
605 
610 typedef enum
611 {
612  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,
613  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,
614 } miopenReduceTensorIndices_t;
615 
620 typedef enum
621 {
622  MIOPEN_32BIT_INDICES = 0,
623  MIOPEN_64BIT_INDICES = 1,
624  MIOPEN_16BIT_INDICES = 2,
625  MIOPEN_8BIT_INDICES = 3,
626 } miopenIndicesType_t;
627 
632 typedef enum
633 {
634  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =
635  0,
638  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =
639  1,
641 #ifdef MIOPEN_BETA_API
642  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =
643  2,
647 #else
648 // miopenReserved1 = 2,
649 #endif
650  // TODO:(LYM) temporarily use Pedantic as default until TF32 is fully supported
651  MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE =
652  3,
653 } miopenConvolutionAttrib_t;
654 
661 typedef enum
662 {
663  miopenConvolutionFindModeNormal =
664  1,
665  miopenConvolutionFindModeFast =
666  2,
669  miopenConvolutionFindModeHybrid =
670  3,
673  // miopenConvolutionFindModeReserved_4 = 4, /*!< Reserved - do not use */
674  miopenConvolutionFindModeDynamicHybrid =
675  5,
679  miopenConvolutionFindModeTrustVerify = 6,
680  miopenConvolutionFindModeTrustVerifyFull = 7,
681  miopenConvolutionFindModeDefault =
682  miopenConvolutionFindModeDynamicHybrid
683 } miopenConvolutionFindMode_t;
684 
696 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);
697 
710 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(
711  miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w);
712 
723 MIOPEN_EXPORT miopenStatus_t
724 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,
725  miopenDataType_t dataType,
726  miopenTensorLayout_t tensorLayout,
727  const int* lens,
728  int num_lens);
748 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,
749  miopenDataType_t dataType,
750  int n,
751  int c,
752  int h,
753  int w,
754  int nStride,
755  int cStride,
756  int hStride,
757  int wStride);
758 
775 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
776  miopenDataType_t* dataType,
777  int* n,
778  int* c,
779  int* h,
780  int* w,
781  int* nStride,
782  int* cStride,
783  int* hStride,
784  int* wStride);
785 
796 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
797  miopenDataType_t dataType,
798  int nbDims,
799  const int* dimsA,
800  const int* stridesA);
801 
802 #ifdef MIOPEN_BETA_API
805 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,
806  miopenDataType_t dataType,
807  int nbDims,
808  const size_t* dimsA,
809  const size_t* stridesA);
810 #endif
811 
812 #ifdef MIOPEN_BETA_API
822 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,
823  miopenDataType_t cast_type);
824 #endif
825 
834 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,
835  int* size);
836 
845 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
846  miopenDataType_t* dataType,
847  int* dimsA,
848  int* stridesA);
849 
855 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);
856 
863 MIOPEN_EXPORT miopenStatus_t
864 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);
865 
871 MIOPEN_EXPORT miopenStatus_t
872 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);
873 
893 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,
894  miopenTensorOp_t tensorOp,
895  const void* alpha1,
896  const miopenTensorDescriptor_t aDesc,
897  const void* A,
898  const void* alpha2,
899  const miopenTensorDescriptor_t bDesc,
900  const void* B,
901  const void* beta,
902  const miopenTensorDescriptor_t cDesc,
903  void* C);
904 
915 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,
916  const miopenTensorDescriptor_t yDesc,
917  void* y,
918  const void* alpha);
919 
930 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,
931  const miopenTensorDescriptor_t yDesc,
932  void* y,
933  const void* alpha);
934 
941 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,
942  size_t* numBytes);
943 
961 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,
962  const void* alpha,
963  const miopenTensorDescriptor_t xDesc,
964  const void* x,
965  const void* beta,
966  const miopenTensorDescriptor_t yDesc,
967  void* y);
968 
970 // CLOSEOUT TENSOR DOXYGEN GROUP
971 
982 MIOPEN_EXPORT miopenStatus_t
983 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);
984 
1000 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
1001  miopenConvolutionMode_t c_mode,
1002  int pad_h,
1003  int pad_w,
1004  int stride_h,
1005  int stride_w,
1006  int dilation_h,
1007  int dilation_w);
1008 
1019 MIOPEN_EXPORT miopenStatus_t
1020 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1021  int spatialDim,
1022  const int* padA,
1023  const int* strideA,
1024  const int* dilationA,
1025  miopenConvolutionMode_t c_mode);
1026 
1033 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,
1034  int* spatialDim);
1035 
1051 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
1052  miopenConvolutionMode_t* c_mode,
1053  int* pad_h,
1054  int* pad_w,
1055  int* stride_h,
1056  int* stride_w,
1057  int* dilation_h,
1058  int* dilation_w);
1059 
1071 MIOPEN_EXPORT miopenStatus_t
1072 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1073  int requestedSpatialDim,
1074  int* spatialDim,
1075  int* padA,
1076  int* strideA,
1077  int* dilationA,
1078  miopenConvolutionMode_t* c_mode);
1079 
1086 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1087  int* groupCount);
1088 
1102 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1103  int groupCount);
1104 
1117 MIOPEN_EXPORT miopenStatus_t
1118 miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w);
1119 
1132 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(
1133  miopenConvolutionDescriptor_t convDesc, int spatialDim, const int* adjA);
1134 
1152 MIOPEN_EXPORT miopenStatus_t
1153 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1154  const miopenTensorDescriptor_t inputTensorDesc,
1155  const miopenTensorDescriptor_t filterDesc,
1156  int* n,
1157  int* c,
1158  int* h,
1159  int* w);
1160 
1174 MIOPEN_EXPORT miopenStatus_t
1175 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1176  const miopenTensorDescriptor_t inputTensorDesc,
1177  const miopenTensorDescriptor_t filterDesc,
1178  int* nDim,
1179  int* outputTensorDimA);
1180 
1186 MIOPEN_EXPORT miopenStatus_t
1187 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);
1188 
1195 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1196  const miopenConvolutionAttrib_t attr,
1197  int value);
1198 
1205 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1206  const miopenConvolutionAttrib_t attr,
1207  int* value);
1208 
1222 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,
1223  miopenConvolutionFindMode_t findMode);
1224 
1231 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(
1232  const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);
1233 
1238 typedef enum
1239 {
1240  miopenConvolutionFwdAlgoGEMM = 0,
1241  miopenConvolutionFwdAlgoDirect = 1,
1242  miopenConvolutionFwdAlgoFFT = 2,
1243  miopenConvolutionFwdAlgoWinograd = 3,
1244  miopenConvolutionFwdAlgoImplicitGEMM = 5,
1245 } miopenConvFwdAlgorithm_t;
1246 
1250 typedef enum
1251 {
1252  miopenConvolutionBwdWeightsAlgoGEMM = 0,
1253  miopenConvolutionBwdWeightsAlgoDirect = 1,
1254  miopenConvolutionBwdWeightsAlgoWinograd = 3,
1255  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,
1256 } miopenConvBwdWeightsAlgorithm_t;
1257 
1261 typedef enum
1262 {
1263  miopenConvolutionBwdDataAlgoGEMM = 0,
1264  miopenConvolutionBwdDataAlgoDirect = 1,
1265  miopenConvolutionBwdDataAlgoFFT = 2,
1266  miopenConvolutionBwdDataAlgoWinograd = 3,
1267  miopenTransposeBwdDataAlgoGEMM =
1268  4,
1269  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,
1270 } miopenConvBwdDataAlgorithm_t;
1271 
1275 typedef enum
1276 {
1277  miopenConvolutionAlgoGEMM = 0,
1278  miopenConvolutionAlgoDirect = 1,
1279  miopenConvolutionAlgoFFT = 2,
1280  miopenConvolutionAlgoWinograd = 3,
1281  miopenConvolutionAlgoImplicitGEMM = 5,
1282 } miopenConvAlgorithm_t;
1283 
1290 typedef struct
1291 {
1292  union
1293  {
1294  miopenConvFwdAlgorithm_t fwd_algo;
1295  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;
1297  miopenConvBwdDataAlgorithm_t
1298  bwd_data_algo;
1299  };
1300 
1301  float time;
1302  size_t memory;
1304 } miopenConvAlgoPerf_t;
1305 
1314 typedef struct
1315 {
1316  float time;
1319  size_t workspace_size;
1321  uint64_t solution_id;
1322  miopenConvAlgorithm_t algorithm;
1324 } miopenConvSolution_t;
1325 
1341 MIOPEN_EXPORT miopenStatus_t
1342 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,
1343  const miopenTensorDescriptor_t wDesc,
1344  const miopenTensorDescriptor_t xDesc,
1345  const miopenConvolutionDescriptor_t convDesc,
1346  const miopenTensorDescriptor_t yDesc,
1347  size_t* solutionCount);
1348 
1372 MIOPEN_EXPORT miopenStatus_t
1373 miopenConvolutionForwardGetSolution(miopenHandle_t handle,
1374  const miopenTensorDescriptor_t wDesc,
1375  const miopenTensorDescriptor_t xDesc,
1376  const miopenConvolutionDescriptor_t convDesc,
1377  const miopenTensorDescriptor_t yDesc,
1378  const size_t maxSolutionCount,
1379  size_t* solutionCount,
1380  miopenConvSolution_t* solutions);
1381 
1399 MIOPEN_EXPORT miopenStatus_t
1400 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,
1401  const miopenTensorDescriptor_t wDesc,
1402  const miopenTensorDescriptor_t xDesc,
1403  const miopenConvolutionDescriptor_t convDesc,
1404  const miopenTensorDescriptor_t yDesc,
1405  const uint64_t solution_id,
1406  size_t* workSpaceSize);
1407 
1425 MIOPEN_EXPORT miopenStatus_t
1426 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,
1427  const miopenTensorDescriptor_t wDesc,
1428  const miopenTensorDescriptor_t xDesc,
1429  const miopenConvolutionDescriptor_t convDesc,
1430  const miopenTensorDescriptor_t yDesc,
1431  const uint64_t solution_id);
1432 
1450 MIOPEN_EXPORT miopenStatus_t
1451 miopenConvolutionForwardImmediate(miopenHandle_t handle,
1452  const miopenTensorDescriptor_t wDesc,
1453  const void* w,
1454  const miopenTensorDescriptor_t xDesc,
1455  const void* x,
1456  const miopenConvolutionDescriptor_t convDesc,
1457  const miopenTensorDescriptor_t yDesc,
1458  void* y,
1459  void* workSpace,
1460  size_t workSpaceSize,
1461  const uint64_t solution_id);
1462 
1480 MIOPEN_EXPORT miopenStatus_t
1481 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,
1482  const miopenTensorDescriptor_t dyDesc,
1483  const miopenTensorDescriptor_t wDesc,
1484  const miopenConvolutionDescriptor_t convDesc,
1485  const miopenTensorDescriptor_t dxDesc,
1486  size_t* solutionCount);
1487 
1512 MIOPEN_EXPORT miopenStatus_t
1513 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,
1514  const miopenTensorDescriptor_t dyDesc,
1515  const miopenTensorDescriptor_t wDesc,
1516  const miopenConvolutionDescriptor_t convDesc,
1517  const miopenTensorDescriptor_t dxDesc,
1518  const size_t maxSolutionCount,
1519  size_t* solutionCount,
1520  miopenConvSolution_t* solutions);
1521 
1539 MIOPEN_EXPORT miopenStatus_t
1540 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,
1541  const miopenTensorDescriptor_t dyDesc,
1542  const miopenTensorDescriptor_t wDesc,
1543  const miopenConvolutionDescriptor_t convDesc,
1544  const miopenTensorDescriptor_t dxDesc,
1545  const uint64_t solution_id,
1546  size_t* workSpaceSize);
1547 
1566 MIOPEN_EXPORT miopenStatus_t
1567 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,
1568  const miopenTensorDescriptor_t dyDesc,
1569  const miopenTensorDescriptor_t wDesc,
1570  const miopenConvolutionDescriptor_t convDesc,
1571  const miopenTensorDescriptor_t dxDesc,
1572  const uint64_t solution_id);
1573 
1591 MIOPEN_EXPORT miopenStatus_t
1592 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,
1593  const miopenTensorDescriptor_t dyDesc,
1594  const void* dy,
1595  const miopenTensorDescriptor_t wDesc,
1596  const void* w,
1597  const miopenConvolutionDescriptor_t convDesc,
1598  const miopenTensorDescriptor_t dxDesc,
1599  void* dx,
1600  void* workSpace,
1601  size_t workSpaceSize,
1602  const uint64_t solution_id);
1603 
1621 MIOPEN_EXPORT miopenStatus_t
1622 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,
1623  const miopenTensorDescriptor_t dyDesc,
1624  const miopenTensorDescriptor_t xDesc,
1625  const miopenConvolutionDescriptor_t convDesc,
1626  const miopenTensorDescriptor_t dwDesc,
1627  size_t* solutionCount);
1628 
1652 MIOPEN_EXPORT miopenStatus_t
1653 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,
1654  const miopenTensorDescriptor_t dyDesc,
1655  const miopenTensorDescriptor_t xDesc,
1656  const miopenConvolutionDescriptor_t convDesc,
1657  const miopenTensorDescriptor_t dwDesc,
1658  const size_t maxSolutionCount,
1659  size_t* solutionCount,
1660  miopenConvSolution_t* solutions);
1661 
1679 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(
1680  miopenHandle_t handle,
1681  const miopenTensorDescriptor_t dyDesc,
1682  const miopenTensorDescriptor_t xDesc,
1683  const miopenConvolutionDescriptor_t convDesc,
1684  const miopenTensorDescriptor_t dwDesc,
1685  const uint64_t solution_id,
1686  size_t* workSpaceSize);
1687 
1705 MIOPEN_EXPORT miopenStatus_t
1706 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,
1707  const miopenTensorDescriptor_t dyDesc,
1708  const miopenTensorDescriptor_t xDesc,
1709  const miopenConvolutionDescriptor_t convDesc,
1710  const miopenTensorDescriptor_t dwDesc,
1711  const uint64_t solution_id);
1712 
1731 MIOPEN_EXPORT miopenStatus_t
1732 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,
1733  const miopenTensorDescriptor_t dyDesc,
1734  const void* dy,
1735  const miopenTensorDescriptor_t xDesc,
1736  const void* x,
1737  const miopenConvolutionDescriptor_t convDesc,
1738  const miopenTensorDescriptor_t dwDesc,
1739  void* dw,
1740  void* workSpace,
1741  size_t workSpaceSize,
1742  const uint64_t solution_id);
1743 
1770 MIOPEN_EXPORT miopenStatus_t
1771 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,
1772  const miopenTensorDescriptor_t wDesc,
1773  const miopenTensorDescriptor_t xDesc,
1774  const miopenConvolutionDescriptor_t convDesc,
1775  const miopenTensorDescriptor_t yDesc,
1776  size_t* workSpaceSize);
1777 
1821 MIOPEN_EXPORT miopenStatus_t
1822 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,
1823  const miopenTensorDescriptor_t xDesc,
1824  const void* x,
1825  const miopenTensorDescriptor_t wDesc,
1826  const void* w,
1827  const miopenConvolutionDescriptor_t convDesc,
1828  const miopenTensorDescriptor_t yDesc,
1829  void* y,
1830  const int requestAlgoCount,
1831  int* returnedAlgoCount,
1832  miopenConvAlgoPerf_t* perfResults,
1833  void* workSpace,
1834  size_t workSpaceSize,
1835  bool exhaustiveSearch);
1836 
1871 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,
1872  const void* alpha,
1873  const miopenTensorDescriptor_t xDesc,
1874  const void* x,
1875  const miopenTensorDescriptor_t wDesc,
1876  const void* w,
1877  const miopenConvolutionDescriptor_t convDesc,
1878  miopenConvFwdAlgorithm_t algo,
1879  const void* beta,
1880  const miopenTensorDescriptor_t yDesc,
1881  void* y,
1882  void* workSpace,
1883  size_t workSpaceSize);
1884 
1900 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,
1901  const void* alpha,
1902  const miopenTensorDescriptor_t bDesc,
1903  const void* b,
1904  const void* beta,
1905  const miopenTensorDescriptor_t yDesc,
1906  void* y);
1907 
1935 MIOPEN_EXPORT miopenStatus_t
1936 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,
1937  const miopenTensorDescriptor_t dyDesc,
1938  const miopenTensorDescriptor_t wDesc,
1939  const miopenConvolutionDescriptor_t convDesc,
1940  const miopenTensorDescriptor_t dxDesc,
1941  size_t* workSpaceSize);
1942 
1986 MIOPEN_EXPORT miopenStatus_t
1987 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,
1988  const miopenTensorDescriptor_t dyDesc,
1989  const void* dy,
1990  const miopenTensorDescriptor_t wDesc,
1991  const void* w,
1992  const miopenConvolutionDescriptor_t convDesc,
1993  const miopenTensorDescriptor_t dxDesc,
1994  void* dx,
1995  const int requestAlgoCount,
1996  int* returnedAlgoCount,
1997  miopenConvAlgoPerf_t* perfResults,
1998  void* workSpace,
1999  size_t workSpaceSize,
2000  bool exhaustiveSearch);
2001 
2035 MIOPEN_EXPORT miopenStatus_t
2036 miopenConvolutionBackwardData(miopenHandle_t handle,
2037  const void* alpha,
2038  const miopenTensorDescriptor_t dyDesc,
2039  const void* dy,
2040  const miopenTensorDescriptor_t wDesc,
2041  const void* w,
2042  const miopenConvolutionDescriptor_t convDesc,
2043  miopenConvBwdDataAlgorithm_t algo,
2044  const void* beta,
2045  const miopenTensorDescriptor_t dxDesc,
2046  void* dx,
2047  void* workSpace,
2048  size_t workSpaceSize);
2049 
2077 MIOPEN_EXPORT miopenStatus_t
2078 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,
2079  const miopenTensorDescriptor_t dyDesc,
2080  const miopenTensorDescriptor_t xDesc,
2081  const miopenConvolutionDescriptor_t convDesc,
2082  const miopenTensorDescriptor_t dwDesc,
2083  size_t* workSpaceSize);
2084 
2128 MIOPEN_EXPORT miopenStatus_t
2129 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,
2130  const miopenTensorDescriptor_t dyDesc,
2131  const void* dy,
2132  const miopenTensorDescriptor_t xDesc,
2133  const void* x,
2134  const miopenConvolutionDescriptor_t convDesc,
2135  const miopenTensorDescriptor_t dwDesc,
2136  void* dw,
2137  const int requestAlgoCount,
2138  int* returnedAlgoCount,
2139  miopenConvAlgoPerf_t* perfResults,
2140  void* workSpace,
2141  size_t workSpaceSize,
2142  bool exhaustiveSearch);
2143 
2177 MIOPEN_EXPORT miopenStatus_t
2178 miopenConvolutionBackwardWeights(miopenHandle_t handle,
2179  const void* alpha,
2180  const miopenTensorDescriptor_t dyDesc,
2181  const void* dy,
2182  const miopenTensorDescriptor_t xDesc,
2183  const void* x,
2184  const miopenConvolutionDescriptor_t convDesc,
2185  miopenConvBwdWeightsAlgorithm_t algo,
2186  const void* beta,
2187  const miopenTensorDescriptor_t dwDesc,
2188  void* dw,
2189  void* workSpace,
2190  size_t workSpaceSize);
2191 
2207 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,
2208  const void* alpha,
2209  const miopenTensorDescriptor_t dyDesc,
2210  const void* dy,
2211  const void* beta,
2212  const miopenTensorDescriptor_t dbDesc,
2213  void* db);
2214 
2216 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP
2217 
2218 // Pooling APIs
2229 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);
2230 
2239 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2240  miopenIndexType_t index_type);
2241 
2249 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2250  miopenIndexType_t* index_type);
2251 
2259 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(
2260  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);
2261 
2268 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(
2269  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);
2270 
2285 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2286  miopenPoolingMode_t mode,
2287  int windowHeight,
2288  int windowWidth,
2289  int pad_h,
2290  int pad_w,
2291  int stride_h,
2292  int stride_w);
2293 
2308 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2309  miopenPoolingMode_t* mode,
2310  int* windowHeight,
2311  int* windowWidth,
2312  int* pad_h,
2313  int* pad_w,
2314  int* stride_h,
2315  int* stride_w);
2316 
2331 MIOPEN_EXPORT miopenStatus_t
2332 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2333  const miopenTensorDescriptor_t tensorDesc,
2334  int* n,
2335  int* c,
2336  int* h,
2337  int* w);
2338 
2354 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2355  const miopenPoolingMode_t mode,
2356  int nbDims,
2357  const int* windowDimA,
2358  const int* padA,
2359  const int* stridesA);
2360 
2377 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2378  int nbDimsRequested,
2379  miopenPoolingMode_t* mode,
2380  int* nbDims,
2381  int* windowDimA,
2382  int* padA,
2383  int* stridesA);
2384 
2397 MIOPEN_EXPORT miopenStatus_t
2398 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2399  const miopenTensorDescriptor_t tensorDesc,
2400  int dims,
2401  int* tensorDimArr);
2402 
2415 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2416  size_t* workSpaceSize);
2417 
2430 MIOPEN_EXPORT miopenStatus_t
2431 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,
2432  const miopenTensorDescriptor_t yDesc,
2433  size_t* workSpaceSize);
2434 
2455 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,
2456  const miopenPoolingDescriptor_t poolDesc,
2457  const void* alpha,
2458  const miopenTensorDescriptor_t xDesc,
2459  const void* x,
2460  const void* beta,
2461  const miopenTensorDescriptor_t yDesc,
2462  void* y,
2463  bool do_backward,
2464  void* workSpace,
2465  size_t workSpaceSize);
2466 
2487 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,
2488  const miopenPoolingDescriptor_t poolDesc,
2489  const void* alpha,
2490  const miopenTensorDescriptor_t yDesc,
2491  const void* y,
2492  const miopenTensorDescriptor_t dyDesc,
2493  const void* dy,
2494  const miopenTensorDescriptor_t xDesc,
2495  const void* x,
2496  const void* beta,
2497  const miopenTensorDescriptor_t dxDesc,
2498  void* dx,
2499  void* workSpace);
2500 
2506 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);
2507 
2509 // CLOSEOUT POOLING DOXYGEN GROUP
2510 
2511 // LRN APIs
2521 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);
2522 
2536 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2537  miopenLRNMode_t mode,
2538  unsigned int lrnN,
2539  double lrnAlpha,
2540  double lrnBeta,
2541  double lrnK);
2542 
2555 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2556  miopenLRNMode_t* mode,
2557  unsigned int* lrnN,
2558  double* lrnAlpha,
2559  double* lrnBeta,
2560  double* lrnK);
2561 
2571 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2572  size_t* workSpaceSize);
2573 
2592 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,
2593  const miopenLRNDescriptor_t lrnDesc,
2594  const void* alpha,
2595  const miopenTensorDescriptor_t xDesc,
2596  const void* x,
2597  const void* beta,
2598  const miopenTensorDescriptor_t yDesc,
2599  void* y,
2600  bool do_backward,
2601  void* workSpace);
2602 
2620 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,
2621  const miopenLRNDescriptor_t lrnDesc,
2622  const void* alpha,
2623  const miopenTensorDescriptor_t yDesc,
2624  const void* y,
2625  const miopenTensorDescriptor_t dyDesc,
2626  const void* dy,
2627  const miopenTensorDescriptor_t xDesc,
2628  const void* x,
2629  const void* beta,
2630  const miopenTensorDescriptor_t dxDesc,
2631  void* dx,
2632  const void* workSpace);
2633 
2639 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);
2640 
2642 // CLOSEOUT LRN DOXYGEN GROUP
2643 
2644 #ifdef MIOPEN_BETA_API
2645 // LayerNorm APIs
2670 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,
2671  miopenNormMode_t mode,
2672  const miopenTensorDescriptor_t xDesc,
2673  const void* x,
2674  const miopenTensorDescriptor_t weightDesc,
2675  const void* weight,
2676  const miopenTensorDescriptor_t biasDesc,
2677  const void* bias,
2678  const float epsilon,
2679  const int32_t normalized_dim,
2680  const miopenTensorDescriptor_t yDesc,
2681  void* y,
2682  const miopenTensorDescriptor_t meanDesc,
2683  void* mean,
2684  const miopenTensorDescriptor_t rstdDesc,
2685  void* rstd);
2686 
2704 MIOPEN_EXPORT miopenStatus_t
2705 miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle,
2706  miopenNormMode_t mode,
2707  const miopenTensorDescriptor_t dyDesc,
2708  const miopenTensorDescriptor_t xDesc,
2709  const miopenTensorDescriptor_t weightDesc,
2710  const miopenTensorDescriptor_t meanDesc,
2711  const miopenTensorDescriptor_t rstdDesc,
2712  const int32_t normalized_dim,
2713  const miopenTensorDescriptor_t dxDesc,
2714  const miopenTensorDescriptor_t dwDesc,
2715  const miopenTensorDescriptor_t dbDesc,
2716  size_t* sizeInBytes);
2717 
2743 MIOPEN_EXPORT miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle,
2744  miopenNormMode_t mode,
2745  void* workspace,
2746  size_t workspaceSizeInBytes,
2747  const miopenTensorDescriptor_t dyDesc,
2748  const void* dy,
2749  const miopenTensorDescriptor_t xDesc,
2750  const void* x,
2751  const miopenTensorDescriptor_t weightDesc,
2752  const void* weight,
2753  const miopenTensorDescriptor_t meanDesc,
2754  const void* mean,
2755  const miopenTensorDescriptor_t rstdDesc,
2756  const void* rstd,
2757  const int32_t normalized_dim,
2758  const miopenTensorDescriptor_t dxDesc,
2759  void* dx,
2760  const miopenTensorDescriptor_t dwDesc,
2761  void* dw,
2762  const miopenTensorDescriptor_t dbDesc,
2763  void* db);
2764 
2766 // CLOSEOUT LAYERNORM DOXYGEN GROUP
2767 #endif
2768 
2769 #ifdef MIOPEN_BETA_API
2770 // Cat APIs
2786 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,
2787  const int32_t xCount,
2788  const miopenTensorDescriptor_t* xDescs,
2789  const void* const* xs,
2790  const miopenTensorDescriptor_t yDesc,
2791  void* y,
2792  const int32_t dim);
2793 
2795 // CLOSEOUT CAT DOXYGEN GROUP
2796 #endif
2797 
2798 // Batch-Normalization APIs
2820 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,
2821  const miopenTensorDescriptor_t xDesc,
2822  miopenBatchNormMode_t bn_mode);
2823 
2862 MIOPEN_EXPORT miopenStatus_t
2863 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,
2864  miopenBatchNormMode_t bn_mode,
2865  void* alpha,
2866  void* beta,
2867  const miopenTensorDescriptor_t xDesc,
2868  const void* x,
2869  const miopenTensorDescriptor_t yDesc,
2870  void* y,
2871  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
2872  void* bnScale,
2873  void* bnBias,
2874  double expAvgFactor,
2875  void* resultRunningMean,
2876  void* resultRunningVariance,
2877  double epsilon,
2878  void* resultSaveMean,
2879  void* resultSaveInvVariance);
2920 MIOPEN_EXPORT miopenStatus_t
2921 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,
2922  miopenBatchNormMode_t bn_mode,
2923  void* alpha,
2924  void* beta,
2925  const miopenTensorDescriptor_t xDesc,
2926  const void* x,
2927  const miopenTensorDescriptor_t yDesc,
2928  void* y,
2929  const miopenTensorDescriptor_t scaleDesc,
2930  const miopenTensorDescriptor_t biasVarDesc,
2931  const miopenTensorDescriptor_t savedMeanDesc,
2932  const miopenTensorDescriptor_t savedVarDesc,
2933  void* bnScale,
2934  void* bnBias,
2935  double expAvgFactor,
2936  void* resultRunningMean,
2937  void* resultRunningVariance,
2938  double epsilon,
2939  void* resultSaveMean,
2940  void* resultSaveInvVariance);
2983 MIOPEN_EXPORT miopenStatus_t
2984 miopenBatchNormalizationForwardTraining_V3(miopenHandle_t handle,
2985  miopenBatchNormMode_t bn_mode,
2986  void* alpha,
2987  void* beta,
2988  const miopenTensorDescriptor_t xDesc,
2989  const void* x,
2990  const miopenTensorDescriptor_t yDesc,
2991  void* y,
2992  const miopenTensorDescriptor_t scaleDesc,
2993  const miopenTensorDescriptor_t biasVarDesc,
2994  const miopenTensorDescriptor_t savedMeanDesc,
2995  const miopenTensorDescriptor_t savedVarDesc,
2996  void* bnScale,
2997  void* bnBias,
2998  double expAvgFactor,
2999  const void* prevResultRunningMean,
3000  const void* prevResultRunningVariance,
3001  void* nextResultRunningMean,
3002  void* nextResultRunningVariance,
3003  double epsilon,
3004  void* resultSaveMean,
3005  void* resultSaveInvVariance);
3047 MIOPEN_EXPORT miopenStatus_t
3048 miopenBatchNormForwardTrainingActivation(miopenHandle_t handle,
3049  miopenBatchNormMode_t bn_mode,
3050  void* alpha,
3051  void* beta,
3052  const miopenTensorDescriptor_t xDesc,
3053  const void* x,
3054  const miopenTensorDescriptor_t yDesc,
3055  void* y,
3056  const miopenTensorDescriptor_t scaleDesc,
3057  const miopenTensorDescriptor_t biasVarDesc,
3058  const miopenTensorDescriptor_t savedMeanDesc,
3059  const miopenTensorDescriptor_t savedVarDesc,
3060  void* bnScale,
3061  void* bnBias,
3062  double expAvgFactor,
3063  void* resultRunningMean,
3064  void* resultRunningVariance,
3065  double epsilon,
3066  void* resultSaveMean,
3067  void* resultSaveInvVariance,
3068  const miopenActivationDescriptor_t activDesc);
3069 
3113 MIOPEN_EXPORT miopenStatus_t
3114 miopenBatchNormForwardTrainingActivation_V2(miopenHandle_t handle,
3115  miopenBatchNormMode_t bn_mode,
3116  void* alpha,
3117  void* beta,
3118  const miopenTensorDescriptor_t xDesc,
3119  const void* x,
3120  const miopenTensorDescriptor_t yDesc,
3121  void* y,
3122  const miopenTensorDescriptor_t scaleDesc,
3123  const miopenTensorDescriptor_t biasVarDesc,
3124  const miopenTensorDescriptor_t savedMeanDesc,
3125  const miopenTensorDescriptor_t savedVarDesc,
3126  void* bnScale,
3127  void* bnBias,
3128  double expAvgFactor,
3129  const void* prevResultRunningMean,
3130  const void* prevResultRunningVariance,
3131  void* nextResultRunningMean,
3132  void* nextResultRunningVariance,
3133  double epsilon,
3134  void* resultSaveMean,
3135  void* resultSaveInvVariance,
3136  const miopenActivationDescriptor_t activDesc);
3137 
3167 MIOPEN_EXPORT miopenStatus_t
3168 miopenBatchNormalizationForwardInference(miopenHandle_t handle,
3169  miopenBatchNormMode_t bn_mode,
3170  void* alpha,
3171  void* beta,
3172  const miopenTensorDescriptor_t xDesc,
3173  const void* x,
3174  const miopenTensorDescriptor_t yDesc,
3175  void* y,
3176  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
3177  void* bnScale,
3178  void* bnBias,
3179  void* estimatedMean,
3180  void* estimatedVariance,
3181  double epsilon);
3182 
3214 MIOPEN_EXPORT miopenStatus_t
3215 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,
3216  miopenBatchNormMode_t bn_mode,
3217  void* alpha,
3218  void* beta,
3219  const miopenTensorDescriptor_t xDesc,
3220  const void* x,
3221  const miopenTensorDescriptor_t yDesc,
3222  void* y,
3223  const miopenTensorDescriptor_t scaleDesc,
3224  const miopenTensorDescriptor_t biasDesc,
3225  const miopenTensorDescriptor_t estMeanDesc,
3226  const miopenTensorDescriptor_t estVarianceDesc,
3227  void* bnScale,
3228  void* bnBias,
3229  void* estimatedMean,
3230  void* estimatedVariance,
3231  double epsilon);
3232 
3261 MIOPEN_EXPORT miopenStatus_t miopenBatchNormalizationForwardInferenceInvVariance(
3262  miopenHandle_t handle,
3263  miopenBatchNormMode_t bn_mode,
3264  void* alpha,
3265  void* beta,
3266  const miopenTensorDescriptor_t xDesc,
3267  const void* x,
3268  const miopenTensorDescriptor_t yDesc,
3269  void* y,
3270  const miopenTensorDescriptor_t scaleDesc,
3271  const miopenTensorDescriptor_t biasDesc,
3272  const miopenTensorDescriptor_t estMeanDesc,
3273  const miopenTensorDescriptor_t estInvVarianceDesc,
3274  void* bnScale,
3275  void* bnBias,
3276  void* estimatedMean,
3277  void* estimatedInvVariance);
3278 
3309 MIOPEN_EXPORT miopenStatus_t miopenBatchNormForwardInferenceActivationInvVariance(
3310  miopenHandle_t handle,
3311  miopenBatchNormMode_t bn_mode,
3312  void* alpha,
3313  void* beta,
3314  const miopenTensorDescriptor_t xDesc,
3315  const void* x,
3316  const miopenTensorDescriptor_t yDesc,
3317  void* y,
3318  const miopenTensorDescriptor_t scaleDesc,
3319  const miopenTensorDescriptor_t biasDesc,
3320  const miopenTensorDescriptor_t estMeanDesc,
3321  const miopenTensorDescriptor_t estInvVarianceDesc,
3322  void* bnScale,
3323  void* bnBias,
3324  void* estimatedMean,
3325  void* estimatedInvVariance,
3326  const miopenActivationDescriptor_t activDesc);
3327 
3360 MIOPEN_EXPORT miopenStatus_t
3361 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,
3362  miopenBatchNormMode_t bn_mode,
3363  void* alpha,
3364  void* beta,
3365  const miopenTensorDescriptor_t xDesc,
3366  const void* x,
3367  const miopenTensorDescriptor_t yDesc,
3368  void* y,
3369  const miopenTensorDescriptor_t scaleDesc,
3370  const miopenTensorDescriptor_t biasDesc,
3371  const miopenTensorDescriptor_t estMeanDesc,
3372  const miopenTensorDescriptor_t estVarianceDesc,
3373  void* bnScale,
3374  void* bnBias,
3375  void* estimatedMean,
3376  void* estimatedVariance,
3377  double epsilon,
3378  const miopenActivationDescriptor_t activDesc);
3379 
3414 MIOPEN_EXPORT miopenStatus_t
3415 miopenBatchNormalizationBackward(miopenHandle_t handle,
3416  miopenBatchNormMode_t bn_mode,
3417  const void* alphaDataDiff,
3418  const void* betaDataDiff,
3419  const void* alphaParamDiff,
3420  const void* betaParamDiff,
3421  const miopenTensorDescriptor_t xDesc,
3422  const void* x,
3423  const miopenTensorDescriptor_t dyDesc,
3424  const void* dy,
3425  const miopenTensorDescriptor_t dxDesc,
3426  void* dx,
3427  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,
3428  const void* bnScale,
3429  void* resultBnScaleDiff,
3430  void* resultBnBiasDiff,
3431  double epsilon,
3432  const void* savedMean,
3433  const void* savedInvVariance);
3434 
3473 MIOPEN_EXPORT miopenStatus_t
3474 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,
3475  miopenBatchNormMode_t bn_mode,
3476  const void* alphaDataDiff,
3477  const void* betaDataDiff,
3478  const void* alphaParamDiff,
3479  const void* betaParamDiff,
3480  const miopenTensorDescriptor_t xDesc,
3481  const void* x,
3482  const miopenTensorDescriptor_t dyDesc,
3483  const void* dy,
3484  const miopenTensorDescriptor_t dxDesc,
3485  void* dx,
3486  const miopenTensorDescriptor_t scaleDesc,
3487  const miopenTensorDescriptor_t biasDesc,
3488  const miopenTensorDescriptor_t savedMeanDesc,
3489  const miopenTensorDescriptor_t savedVarDesc,
3490  const void* bnScale,
3491  void* resultBnScaleDiff,
3492  void* resultBnBiasDiff,
3493  double epsilon,
3494  const void* savedMean,
3495  const void* savedInvVariance);
3496 
3537 MIOPEN_EXPORT miopenStatus_t
3538 miopenBatchNormBackwardActivation(miopenHandle_t handle,
3539  miopenBatchNormMode_t bn_mode,
3540  const void* alphaDataDiff,
3541  const void* betaDataDiff,
3542  const void* alphaParamDiff,
3543  const void* betaParamDiff,
3544  const miopenTensorDescriptor_t xDesc,
3545  const void* x,
3546  const miopenTensorDescriptor_t dyDesc,
3547  const void* dy,
3548  const miopenTensorDescriptor_t dxDesc,
3549  void* dx,
3550  const miopenTensorDescriptor_t scaleDesc,
3551  const miopenTensorDescriptor_t biasDesc,
3552  const miopenTensorDescriptor_t savedMeanDesc,
3553  const miopenTensorDescriptor_t savedVarianceDesc,
3554  const void* bnScale,
3555  const void* bnBias,
3556  void* resultBnScaleDiff,
3557  void* resultBnBiasDiff,
3558  double epsilon,
3559  const void* savedMean,
3560  const void* savedInvVariance,
3561  const miopenActivationDescriptor_t activDesc);
3563 // CLOSEOUT BATCHNORM DOXYGEN GROUP
3564 
3565 // Activation APIs
3575 MIOPEN_EXPORT miopenStatus_t
3576 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);
3577 
3589 MIOPEN_EXPORT miopenStatus_t
3590 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3591  miopenActivationMode_t mode,
3592  double activAlpha,
3593  double activBeta,
3594  double activGamma);
3595 
3607 MIOPEN_EXPORT miopenStatus_t
3608 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3609  miopenActivationMode_t* mode,
3610  double* activAlpha,
3611  double* activBeta,
3612  double* activGamma);
3613 
3626 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,
3627  const miopenActivationDescriptor_t activDesc,
3628  const void* alpha,
3629  const miopenTensorDescriptor_t xDesc,
3630  const void* x,
3631  const void* beta,
3632  const miopenTensorDescriptor_t yDesc,
3633  void* y);
3634 
3651 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,
3652  const miopenActivationDescriptor_t activDesc,
3653  const void* alpha,
3654  const miopenTensorDescriptor_t yDesc,
3655  const void* y,
3656  const miopenTensorDescriptor_t dyDesc,
3657  const void* dy,
3658  const miopenTensorDescriptor_t xDesc,
3659  const void* x,
3660  const void* beta,
3661  const miopenTensorDescriptor_t dxDesc,
3662  void* dx);
3663 
3669 MIOPEN_EXPORT miopenStatus_t
3670 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);
3671 
3673 // CLOSEOUT ACTIVATION DOXYGEN GROUP
3674 
3675 #ifdef MIOPEN_BETA_API
3691 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,
3692  const miopenTensorDescriptor_t inputDesc,
3693  const void* input,
3694  const miopenTensorDescriptor_t outputDesc,
3695  void* output,
3696  const uint32_t dim);
3697 
3710 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,
3711  const miopenTensorDescriptor_t inputDesc,
3712  const void* input,
3713  const miopenTensorDescriptor_t outputGradDesc,
3714  const void* outputGrad,
3715  const miopenTensorDescriptor_t inputGradDesc,
3716  void* inputGrad,
3717  const uint32_t dim);
3718 
3720 // CLOSEOUT ACTIVATION DOXYGEN GROUP
3721 #endif // MIOPEN_BETA_API
3722 
3723 // Softmax APIs
3741 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,
3742  const void* alpha,
3743  const miopenTensorDescriptor_t xDesc,
3744  const void* x,
3745  const void* beta,
3746  const miopenTensorDescriptor_t yDesc,
3747  void* y);
3748 
3764 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,
3765  const void* alpha,
3766  const miopenTensorDescriptor_t yDesc,
3767  const void* y,
3768  const miopenTensorDescriptor_t dyDesc,
3769  const void* dy,
3770  const void* beta,
3771  const miopenTensorDescriptor_t dxDesc,
3772  void* dx);
3773 
3787 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,
3788  const void* alpha,
3789  const miopenTensorDescriptor_t xDesc,
3790  const void* x,
3791  const void* beta,
3792  const miopenTensorDescriptor_t yDesc,
3793  void* y,
3794  miopenSoftmaxAlgorithm_t algorithm,
3795  miopenSoftmaxMode_t mode);
3796 
3812 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,
3813  const void* alpha,
3814  const miopenTensorDescriptor_t yDesc,
3815  const void* y,
3816  const miopenTensorDescriptor_t dyDesc,
3817  const void* dy,
3818  const void* beta,
3819  const miopenTensorDescriptor_t dxDesc,
3820  void* dx,
3821  miopenSoftmaxAlgorithm_t algorithm,
3822  miopenSoftmaxMode_t mode);
3823 
3825 // CLOSEOUT SOFTMAX DOXYGEN GROUP
3826 
3830 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);
3831 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);
3832 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);
3833 
3842 typedef enum
3843 {
3844  miopenVerticalFusion = 0,
3845  miopenHorizontalFusion = 1,
3846 } miopenFusionDirection_t;
3847 
3855 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,
3856  const miopenFusionDirection_t fuseDirection,
3857  const miopenTensorDescriptor_t inputDesc);
3858 
3864 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);
3865 
3872 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,
3873  miopenFusionPlanDescriptor_t fusePlanDesc);
3874 
3885 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,
3886  const int op_idx,
3887  miopenFusionOpDescriptor_t* op);
3888 
3896 MIOPEN_EXPORT miopenStatus_t
3897 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,
3898  miopenFusionPlanDescriptor_t fusePlanDesc,
3899  size_t* workSpaceSize,
3900  miopenConvFwdAlgorithm_t algo);
3901 
3919 MIOPEN_EXPORT miopenStatus_t
3920 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,
3921  const int requestAlgoCount,
3922  int* returnedAlgoCount,
3923  miopenConvFwdAlgorithm_t* returnedAlgos);
3924 
3934 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(
3935  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);
3936 
3945 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3946  miopenFusionOpDescriptor_t* convOp,
3947  miopenConvolutionDescriptor_t convDesc,
3948  const miopenTensorDescriptor_t wDesc);
3949 
3950 //---
3951 
3952 // Activation forward create ops ---
3960 MIOPEN_EXPORT miopenStatus_t
3961 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3962  miopenFusionOpDescriptor_t* activFwdOp,
3963  miopenActivationMode_t mode);
3964 
3965 // Activation backward create ops ---
3973 MIOPEN_EXPORT miopenStatus_t
3974 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3975  miopenFusionOpDescriptor_t* activBwdOp,
3976  miopenActivationMode_t mode);
3977 
3978 // Bias create ops ---
3986 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3987  miopenFusionOpDescriptor_t* biasOp,
3988  const miopenTensorDescriptor_t bDesc);
3989 
3990 // Batch normalization create ops ---
3999 MIOPEN_EXPORT miopenStatus_t
4000 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,
4001  miopenFusionOpDescriptor_t* bnOp,
4002  const miopenBatchNormMode_t bn_mode,
4003  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);
4004 
4014 MIOPEN_EXPORT miopenStatus_t
4015 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,
4016  miopenFusionOpDescriptor_t* bnFwdOp,
4017  const miopenBatchNormMode_t bn_mode,
4018  bool runningMeanVariance);
4019 
4027 MIOPEN_EXPORT miopenStatus_t
4028 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
4029  miopenFusionOpDescriptor_t* bnBwdOp,
4030  const miopenBatchNormMode_t bn_mode);
4031 
4032 //---
4038 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);
4039 
4045 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);
4046 
4047 // Convolution set arguments ---
4057 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,
4058  const miopenFusionOpDescriptor_t convOp,
4059  const void* alpha,
4060  const void* beta,
4061  const void* w);
4062 // Activation set arguments ---
4074 MIOPEN_EXPORT miopenStatus_t
4075 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,
4076  const miopenFusionOpDescriptor_t activFwdOp,
4077  const void* alpha,
4078  const void* beta,
4079  double activAlpha,
4080  double activBeta,
4081  double activGamma);
4082 
4096 MIOPEN_EXPORT miopenStatus_t
4097 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,
4098  const miopenFusionOpDescriptor_t activBwdOp,
4099  const void* alpha,
4100  const void* beta,
4101  const void* y,
4102  const void* reserved,
4103  double activAlpha,
4104  double activBeta,
4105  double activGamma);
4106 
4107 // Batch Normalization set arguments ---
4121 MIOPEN_EXPORT miopenStatus_t
4122 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,
4123  const miopenFusionOpDescriptor_t bnOp,
4124  const void* alpha,
4125  const void* beta,
4126  const void* bnScale,
4127  const void* bnBias,
4128  const void* estimatedMean,
4129  const void* estimatedVariance,
4130  double epsilon);
4131 
4148 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,
4149  const miopenFusionOpDescriptor_t bnOp,
4150  const void* alpha,
4151  const void* beta,
4152  const void* bnScale,
4153  const void* bnBias,
4154  void* savedMean,
4155  void* savedInvVariance,
4156  void* runningMean,
4157  void* runningVariance,
4158  double expAvgFactor,
4159  double epsilon);
4160 
4176 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,
4177  const miopenFusionOpDescriptor_t bnOp,
4178  const void* alpha,
4179  const void* beta,
4180  const void* x,
4181  const void* bnScale,
4182  const void* bnBias,
4183  void* resultBnScaleDiff,
4184  void* resultBnBiasDiff,
4185  const void* savedMean,
4186  const void* savedInvVariance);
4187 
4188 // Bias forward set arguments ---
4198 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,
4199  const miopenFusionOpDescriptor_t biasOp,
4200  const void* alpha,
4201  const void* beta,
4202  const void* bias);
4203 
4218 MIOPEN_EXPORT miopenStatus_t
4219 miopenExecuteFusionPlan(const miopenHandle_t handle,
4220  const miopenFusionPlanDescriptor_t fusePlanDesc,
4221  const miopenTensorDescriptor_t inputDesc,
4222  const void* input,
4223  const miopenTensorDescriptor_t outputDesc,
4224  void* output,
4225  miopenOperatorArgs_t args);
4226 
4241 MIOPEN_EXPORT miopenStatus_t
4242 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,
4243  const miopenFusionPlanDescriptor_t fusePlanDesc,
4244  const miopenTensorDescriptor_t inputDesc,
4245  const void* input,
4246  const miopenTensorDescriptor_t outputDesc,
4247  void* output,
4248  miopenOperatorArgs_t args,
4249  void* workspace,
4250  size_t workspaceSize);
4251 
4275 MIOPEN_EXPORT miopenStatus_t
4276 miopenConvolutionBiasActivationForward(miopenHandle_t handle,
4277  const void* alpha1,
4278  const miopenTensorDescriptor_t xDesc,
4279  const void* x,
4280  const miopenTensorDescriptor_t wDesc,
4281  const void* w,
4282  const miopenConvolutionDescriptor_t convDesc,
4283  miopenConvFwdAlgorithm_t algo,
4284  void* workspace,
4285  size_t workspaceSizeInBytes,
4286  const void* alpha2,
4287  const miopenTensorDescriptor_t zDesc,
4288  const void* z,
4289  const miopenTensorDescriptor_t biasDesc,
4290  const void* bias,
4291  const miopenActivationDescriptor_t activationDesc,
4292  const miopenTensorDescriptor_t yDesc,
4293  void* y);
4295 // CLOSEOUT FUSION DOXYGEN GROUP
4296 
4305 typedef enum
4306 {
4307  miopenRNNRELU = 0,
4308  miopenRNNTANH = 1,
4309  miopenLSTM = 2,
4310  miopenGRU = 3,
4311 } miopenRNNMode_t;
4312 
4316 typedef enum
4317 {
4318  miopenRNNlinear = 0,
4319  miopenRNNskip = 1,
4320 } miopenRNNInputMode_t;
4321 
4325 typedef enum
4326 {
4327  miopenRNNdefault = 0,
4329  miopenRNNfundamental = 1,
4331  miopenRNNroundedDynamic = 2,
4333 } miopenRNNAlgo_t;
4334 
4338 typedef enum
4339 {
4340  miopenRNNunidirection = 0,
4341  miopenRNNbidirection = 1,
4342 } miopenRNNDirectionMode_t;
4343 
4347 typedef enum
4348 {
4349  miopenRNNNoBias = 0,
4350  miopenRNNwithBias = 1,
4351 } miopenRNNBiasMode_t;
4352 
4356 typedef enum
4357 {
4358  miopenRNNAlgoGEMM = 0,
4359 } miopenRNNGEMMalgoMode_t;
4360 
4364 typedef enum
4365 {
4366  miopenRNNIONotPadded = 0,
4367  miopenRNNIOWithPadding = 1,
4368 } miopenRNNPaddingMode_t;
4369 
4373 typedef enum
4374 {
4375  miopenRNNTraining = 0,
4376  miopenRNNInference = 1,
4377 } miopenRNNFWDMode_t;
4378 
4382 typedef enum
4383 {
4384  miopenRNNDataUnknownLayout = 0,
4385  miopenRNNDataSeqMajorNotPadded = 1,
4386  miopenRNNDataSeqMajorPadded = 2,
4387  miopenRNNDataBatchMajorPadded = 3,
4388 } miopenRNNBaseLayout_t;
4389 
4396 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);
4397 
4410 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
4411  miopenRNNMode_t* rnnMode,
4412  miopenRNNAlgo_t* algoMode,
4413  miopenRNNInputMode_t* inputMode,
4414  miopenRNNDirectionMode_t* dirMode,
4415  miopenRNNBiasMode_t* biasMode,
4416  int* hiddenSize,
4417  int* layer);
4418 
4435 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
4436  int* hiddenSize,
4437  int* layer,
4438  miopenDropoutDescriptor_t* dropoutDesc,
4439  miopenRNNInputMode_t* inputMode,
4440  miopenRNNDirectionMode_t* dirMode,
4441  miopenRNNMode_t* rnnMode,
4442  miopenRNNBiasMode_t* biasMode,
4443  miopenRNNAlgo_t* algoMode,
4444  miopenDataType_t* dataType);
4445 
4451 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);
4452 
4468 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
4469  const int hsize,
4470  const int nlayers,
4471  miopenRNNInputMode_t inMode,
4472  miopenRNNDirectionMode_t direction,
4473  miopenRNNMode_t rnnMode,
4474  miopenRNNBiasMode_t biasMode,
4475  miopenRNNAlgo_t algo,
4476  miopenDataType_t dataType);
4477 
4496 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
4497  const int hsize,
4498  const int nlayers,
4499  miopenDropoutDescriptor_t dropoutDesc,
4500  miopenRNNInputMode_t inMode,
4501  miopenRNNDirectionMode_t direction,
4502  miopenRNNMode_t rnnMode,
4503  miopenRNNBiasMode_t biasMode,
4504  miopenRNNAlgo_t algo,
4505  miopenDataType_t dataType);
4506 
4521 MIOPEN_EXPORT miopenStatus_t
4522 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
4523  miopenDataType_t dataType,
4524  miopenRNNBaseLayout_t layout,
4525  int maxSequenceLen,
4526  int batchSize,
4527  int vectorSize,
4528  const int* sequenceLenArray,
4529  void* paddingMarker);
4530 
4549 MIOPEN_EXPORT miopenStatus_t
4550 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
4551  miopenDataType_t* dataType,
4552  miopenRNNBaseLayout_t* layout,
4553  int* maxSequenceLen,
4554  int* batchSize,
4555  int* vectorSize,
4556  int sequenceLenArrayLimit,
4557  int* sequenceLenArray,
4558  void* paddingMarker);
4559 
4576 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,
4577  const miopenRNNDescriptor_t rnnDesc,
4578  const int sequenceLen,
4579  const miopenTensorDescriptor_t* xDesc,
4580  size_t* numBytes);
4581 
4598 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,
4599  miopenRNNDescriptor_t rnnDesc,
4600  const int sequenceLen,
4601  const miopenTensorDescriptor_t* xDesc,
4602  size_t* numBytes);
4603 
4620 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,
4621  miopenRNNDescriptor_t rnnDesc,
4622  miopenSeqTensorDescriptor_t xDesc,
4623  miopenRNNFWDMode_t fwdMode,
4624  size_t* workSpaceSize,
4625  size_t* reserveSpaceSize);
4626 
4639 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,
4640  miopenRNNDescriptor_t rnnDesc,
4641  miopenTensorDescriptor_t xDesc,
4642  size_t* numBytes,
4643  miopenDataType_t dtype);
4644 
4657 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,
4658  miopenRNNDescriptor_t rnnDesc,
4659  miopenTensorDescriptor_t xDesc,
4660  miopenTensorDescriptor_t wDesc,
4661  miopenDataType_t dtype);
4662 
4680 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,
4681  miopenRNNDescriptor_t rnnDesc,
4682  const int seqLen,
4683  miopenTensorDescriptor_t* xDesc,
4684  size_t* numBytes);
4685 
4698 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,
4699  miopenRNNDescriptor_t rnnDesc,
4700  const int seqLen,
4701  miopenTensorDescriptor_t* xDesc,
4702  size_t* numBytes);
4703 
4744 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,
4745  miopenRNNDescriptor_t rnnDesc,
4746  const int layer,
4747  miopenTensorDescriptor_t xDesc,
4748  const int paramID,
4749  size_t* numBytes);
4750 
4788 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,
4789  miopenRNNDescriptor_t rnnDesc,
4790  const int layer,
4791  const int biasID,
4792  size_t* numBytes);
4793 
4852 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,
4853  miopenRNNDescriptor_t rnnDesc,
4854  const int layer,
4855  miopenTensorDescriptor_t xDesc,
4856  miopenTensorDescriptor_t wDesc,
4857  const void* w,
4858  const int paramID,
4859  miopenTensorDescriptor_t paramDesc,
4860  void* layerParam);
4861 
4919 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,
4920  miopenRNNDescriptor_t rnnDesc,
4921  const int layer,
4922  miopenTensorDescriptor_t xDesc,
4923  miopenTensorDescriptor_t wDesc,
4924  const void* w,
4925  const int biasID,
4926  miopenTensorDescriptor_t biasDesc,
4927  void* layerBias);
4928 
4983 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,
4984  const int layer,
4985  miopenTensorDescriptor_t xDesc,
4986  const int paramID,
4987  miopenTensorDescriptor_t paramDesc,
4988  size_t* layerParamOffset);
4989 
5040 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,
5041  const int layer,
5042  miopenTensorDescriptor_t xDesc,
5043  const int biasID,
5044  miopenTensorDescriptor_t biasDesc,
5045  size_t* layerBiasOffset);
5046 
5099 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,
5100  miopenRNNDescriptor_t rnnDesc,
5101  const int layer,
5102  miopenTensorDescriptor_t xDesc,
5103  miopenTensorDescriptor_t wDesc,
5104  void* w,
5105  const int paramID,
5106  miopenTensorDescriptor_t paramDesc,
5107  const void* layerParam);
5108 
5159 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,
5160  miopenRNNDescriptor_t rnnDesc,
5161  const int layer,
5162  miopenTensorDescriptor_t xDesc,
5163  miopenTensorDescriptor_t wDesc,
5164  void* w,
5165  const int biasID,
5166  miopenTensorDescriptor_t biasDesc,
5167  const void* layerBias);
5168 
5180 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
5181  miopenRNNPaddingMode_t paddingMode);
5182 
5190 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
5191  miopenRNNPaddingMode_t* paddingMode);
5192 
5243 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,
5244  const miopenRNNDescriptor_t rnnDesc,
5245  miopenRNNFWDMode_t fwdMode,
5246  const miopenSeqTensorDescriptor_t xDesc,
5247  const void* x,
5248  const miopenTensorDescriptor_t hDesc,
5249  const void* hx,
5250  void* hy,
5251  const miopenTensorDescriptor_t cDesc,
5252  const void* cx,
5253  void* cy,
5254  const miopenSeqTensorDescriptor_t yDesc,
5255  void* y,
5256  const void* w,
5257  size_t weightSpaceSize,
5258  void* workSpace,
5259  size_t workSpaceNumBytes,
5260  void* reserveSpace,
5261  size_t reserveSpaceNumBytes);
5262 
5312 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,
5313  const miopenRNNDescriptor_t rnnDesc,
5314  const miopenSeqTensorDescriptor_t yDesc,
5315  const void* y,
5316  const void* dy,
5317  const miopenTensorDescriptor_t hDesc,
5318  const void* hx,
5319  const void* dhy,
5320  void* dhx,
5321  const miopenTensorDescriptor_t cDesc,
5322  const void* cx,
5323  const void* dcy,
5324  void* dcx,
5325  const miopenSeqTensorDescriptor_t xDesc,
5326  void* dx,
5327  const void* w,
5328  size_t weightSpaceSize,
5329  void* workSpace,
5330  size_t workSpaceNumBytes,
5331  void* reserveSpace,
5332  size_t reserveSpaceNumBytes);
5333 
5367 MIOPEN_EXPORT miopenStatus_t
5368 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,
5369  const miopenRNNDescriptor_t rnnDesc,
5370  const miopenSeqTensorDescriptor_t xDesc,
5371  const void* x,
5372  const miopenTensorDescriptor_t hDesc,
5373  const void* hx,
5374  const miopenSeqTensorDescriptor_t yDesc,
5375  const void* y,
5376  void* dw,
5377  size_t weightSpaceSize,
5378  void* workSpace,
5379  size_t workSpaceNumBytes,
5380  const void* reserveSpace,
5381  size_t reserveSpaceNumBytes);
5382 
5440 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,
5441  const miopenRNNDescriptor_t rnnDesc,
5442  const int sequenceLen,
5443  const miopenTensorDescriptor_t* xDesc,
5444  const void* x,
5445  const miopenTensorDescriptor_t hxDesc,
5446  const void* hx,
5447  const miopenTensorDescriptor_t cxDesc,
5448  const void* cx,
5449  const miopenTensorDescriptor_t wDesc,
5450  const void* w,
5451  const miopenTensorDescriptor_t* yDesc,
5452  void* y,
5453  const miopenTensorDescriptor_t hyDesc,
5454  void* hy,
5455  const miopenTensorDescriptor_t cyDesc,
5456  void* cy,
5457  void* workSpace,
5458  size_t workSpaceNumBytes,
5459  void* reserveSpace,
5460  size_t reserveSpaceNumBytes);
5461 
5534 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,
5535  const miopenRNNDescriptor_t rnnDesc,
5536  const int sequenceLen,
5537  const miopenTensorDescriptor_t* yDesc,
5538  const void* y,
5539  const miopenTensorDescriptor_t* dyDesc,
5540  const void* dy,
5541  const miopenTensorDescriptor_t dhyDesc,
5542  const void* dhy,
5543  const miopenTensorDescriptor_t dcyDesc,
5544  const void* dcy,
5545  const miopenTensorDescriptor_t wDesc,
5546  const void* w,
5547  const miopenTensorDescriptor_t hxDesc,
5548  const void* hx,
5549  const miopenTensorDescriptor_t cxDesc,
5550  const void* cx,
5551  const miopenTensorDescriptor_t* dxDesc,
5552  void* dx,
5553  const miopenTensorDescriptor_t dhxDesc,
5554  void* dhx,
5555  const miopenTensorDescriptor_t dcxDesc,
5556  void* dcx,
5557  void* workSpace,
5558  size_t workSpaceNumBytes,
5559  void* reserveSpace,
5560  size_t reserveSpaceNumBytes);
5561 
5598 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,
5599  const miopenRNNDescriptor_t rnnDesc,
5600  const int sequenceLen,
5601  const miopenTensorDescriptor_t* xDesc,
5602  const void* x,
5603  const miopenTensorDescriptor_t hxDesc,
5604  const void* hx,
5605  const miopenTensorDescriptor_t* yDesc,
5606  const void* y,
5607  const miopenTensorDescriptor_t dwDesc,
5608  void* dw,
5609  void* workSpace,
5610  size_t workSpaceNumBytes,
5611  const void* reserveSpace,
5612  size_t reserveSpaceNumBytes);
5613 
5669 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,
5670  miopenRNNDescriptor_t rnnDesc,
5671  const int sequenceLen,
5672  const miopenTensorDescriptor_t* xDesc,
5673  const void* x,
5674  const miopenTensorDescriptor_t hxDesc,
5675  const void* hx,
5676  const miopenTensorDescriptor_t cxDesc,
5677  const void* cx,
5678  const miopenTensorDescriptor_t wDesc,
5679  const void* w,
5680  const miopenTensorDescriptor_t* yDesc,
5681  void* y,
5682  const miopenTensorDescriptor_t hyDesc,
5683  void* hy,
5684  const miopenTensorDescriptor_t cyDesc,
5685  void* cy,
5686  void* workSpace,
5687  size_t workSpaceNumBytes);
5688 
5690 // CLOSEOUT RNN DOXYGEN GROUP
5691 
5700 typedef enum
5701 {
5702  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,
5703 } miopenCTCLossAlgo_t;
5704 
5711 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);
5712 
5722 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5723  miopenDataType_t* dataType,
5724  int* blank_label_id,
5725  bool* apply_softmax_layer);
5726 
5732 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);
5733 
5743 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5744  miopenDataType_t dataType,
5745  const int blank_label_id,
5746  bool apply_softmax_layer);
5747 
5764 MIOPEN_EXPORT miopenStatus_t
5765 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,
5766  const miopenTensorDescriptor_t probsDesc,
5767  const miopenTensorDescriptor_t gradientsDesc,
5768  const int* labels,
5769  const int* labelLengths,
5770  const int* inputLengths,
5771  miopenCTCLossAlgo_t algo,
5772  const miopenCTCLossDescriptor_t ctcLossDesc,
5773  size_t* workSpaceSize);
5774 
5794 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,
5795  const miopenTensorDescriptor_t probsDesc,
5796  const void* probs,
5797  const int* labels,
5798  const int* labelLengths,
5799  const int* inputLengths,
5800  void* losses,
5801  const miopenTensorDescriptor_t gradientsDesc,
5802  void* gradients,
5803  miopenCTCLossAlgo_t algo,
5804  const miopenCTCLossDescriptor_t ctcLossDesc,
5805  void* workSpace,
5806  size_t workSpaceSize);
5807 
5809 // CLOSEOUT LossFunction DOXYGEN GROUP
5810 
5811 // Dropout APIs
5820 typedef enum
5821 {
5822  MIOPEN_RNG_PSEUDO_XORWOW = 0,
5823 } miopenRNGType_t;
5824 
5830 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);
5831 
5837 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);
5838 
5847 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,
5848  size_t* reserveSpaceSizeInBytes);
5849 
5858 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,
5859  size_t* stateSizeInBytes);
5860 
5877 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5878  miopenHandle_t handle,
5879  float* dropout,
5880  void** states,
5881  unsigned long long* seed,
5882  bool* use_mask,
5883  bool* state_evo,
5884  miopenRNGType_t* rng_mode);
5885 
5908 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5909  miopenHandle_t handle,
5910  float dropout,
5911  void* states,
5912  size_t stateSizeInBytes,
5913  unsigned long long seed,
5914  bool use_mask,
5915  bool state_evo,
5916  miopenRNGType_t rng_mode);
5917 
5937 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5938  miopenHandle_t handle,
5939  float dropout,
5940  void* states,
5941  size_t stateSizeInBytes,
5942  unsigned long long seed,
5943  bool use_mask,
5944  bool state_evo,
5945  miopenRNGType_t rng_mode);
5946 
5964 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,
5965  const miopenDropoutDescriptor_t dropoutDesc,
5966  const miopenTensorDescriptor_t noise_shape,
5967  const miopenTensorDescriptor_t xDesc,
5968  const void* x,
5969  const miopenTensorDescriptor_t yDesc,
5970  void* y,
5971  void* reserveSpace,
5972  size_t reserveSpaceSizeInBytes);
5973 
5991 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,
5992  const miopenDropoutDescriptor_t dropoutDesc,
5993  const miopenTensorDescriptor_t noise_shape,
5994  const miopenTensorDescriptor_t dyDesc,
5995  const void* dy,
5996  const miopenTensorDescriptor_t dxDesc,
5997  void* dx,
5998  void* reserveSpace,
5999  size_t reserveSpaceSizeInBytes);
6000 
6002 // CLOSEOUT DROPOUT DOXYGEN GROUP
6003 
6004 // TensorReduce APIs
6015 MIOPEN_EXPORT miopenStatus_t
6016 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);
6017 
6023 MIOPEN_EXPORT miopenStatus_t
6024 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);
6025 
6038 MIOPEN_EXPORT miopenStatus_t
6039 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,
6040  miopenReduceTensorOp_t reduceTensorOp,
6041  miopenDataType_t reduceTensorCompType,
6042  miopenNanPropagation_t reduceTensorNanOpt,
6043  miopenReduceTensorIndices_t reduceTensorIndices,
6044  miopenIndicesType_t reduceTensorIndicesType);
6045 
6061 MIOPEN_EXPORT miopenStatus_t
6062 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,
6063  miopenReduceTensorOp_t* reduceTensorOp,
6064  miopenDataType_t* reduceTensorCompType,
6065  miopenNanPropagation_t* reduceTensorNanOpt,
6066  miopenReduceTensorIndices_t* reduceTensorIndices,
6067  miopenIndicesType_t* reduceTensorIndicesType);
6068 
6078 MIOPEN_EXPORT miopenStatus_t
6079 miopenGetReductionIndicesSize(miopenHandle_t handle,
6080  const miopenReduceTensorDescriptor_t reduceTensorDesc,
6081  const miopenTensorDescriptor_t aDesc,
6082  const miopenTensorDescriptor_t cDesc,
6083  size_t* sizeInBytes);
6084 
6094 MIOPEN_EXPORT miopenStatus_t
6095 miopenGetReductionWorkspaceSize(miopenHandle_t handle,
6096  const miopenReduceTensorDescriptor_t reduceTensorDesc,
6097  const miopenTensorDescriptor_t aDesc,
6098  const miopenTensorDescriptor_t cDesc,
6099  size_t* sizeInBytes);
6100 
6124 MIOPEN_EXPORT miopenStatus_t
6125 miopenReduceTensor(miopenHandle_t handle,
6126  const miopenReduceTensorDescriptor_t reduceTensorDesc,
6127  void* indices,
6128  size_t indicesSizeInBytes,
6129  void* workspace,
6130  size_t workspaceSizeInBytes,
6131  const void* alpha,
6132  const miopenTensorDescriptor_t aDesc,
6133  const void* A,
6134  const void* beta,
6135  const miopenTensorDescriptor_t cDesc,
6136  void* C);
6137 
6139 // CLOSEOUT TensorReduce DOXYGEN GROUP
6140 
6141 // Find 2.0 API
6152 MIOPEN_DECLARE_OBJECT(miopenProblem);
6153 
6157 typedef enum
6158 {
6159  miopenProblemDirectionForward = 0,
6160  miopenProblemDirectionBackward = 1,
6161  miopenProblemDirectionBackwardWeights = 2,
6162 #ifdef MIOPEN_BETA_API
6163  miopenProblemDirectionInference = 4,
6164 #endif
6165 } miopenProblemDirection_t;
6166 
6170 typedef enum
6171 {
6172  miopenTensorArgumentIdInvalid = 0,
6173  miopenTensorConvolutionX = 1,
6174  miopenTensorConvolutionW = 2,
6175  miopenTensorConvolutionY = 3,
6176 
6177  miopenTensorMhaK = 4,
6178  miopenTensorMhaQ = 5,
6179  miopenTensorMhaV = 6,
6180  miopenTensorMhaDescaleK = 7,
6181  miopenTensorMhaDescaleQ = 8,
6182  miopenTensorMhaDescaleV = 9,
6183  miopenTensorMhaDescaleS = 10,
6184  miopenTensorMhaScaleS = 11,
6185  miopenTensorMhaScaleO = 12,
6186  miopenTensorMhaDropoutProbability = 13,
6187  miopenTensorMhaDropoutSeed = 14,
6188  miopenTensorMhaDropoutOffset = 15,
6189  miopenTensorMhaO = 16,
6190  miopenTensorMhaAmaxO = 17,
6191  miopenTensorMhaAmaxS = 18,
6192  miopenTensorMhaM = 19,
6193  miopenTensorMhaZInv = 20,
6194  miopenTensorMhaDO = 21,
6195  miopenTensorMhaDescaleO = 22,
6196  miopenTensorMhaDescaleDO = 23,
6197  miopenTensorMhaDescaleDS = 24,
6198  miopenTensorMhaScaleDS = 25,
6199  miopenTensorMhaScaleDQ = 26,
6200  miopenTensorMhaScaleDK = 27,
6201  miopenTensorMhaScaleDV = 28,
6202  miopenTensorMhaDQ = 29,
6203  miopenTensorMhaDK = 30,
6204  miopenTensorMhaDV = 31,
6205  miopenTensorMhaAmaxDQ = 32,
6206  miopenTensorMhaAmaxDK = 33,
6207  miopenTensorMhaAmaxDV = 34,
6208  miopenTensorMhaAmaxDS = 35,
6209  miopenTensorMhaBias = 36,
6210 
6211 #ifdef MIOPEN_BETA_API
6212  miopenTensorActivationX = 37,
6213  miopenTensorActivationY = 38,
6214  miopenTensorActivationDX = 39,
6215  miopenTensorActivationDY = 40,
6216  miopenTensorBiasX = 41,
6217  miopenTensorBiasY = 42,
6218  miopenTensorBias = 43,
6219  miopenTensorSoftmaxX = 44,
6220  miopenTensorSoftmaxY = 45,
6221  miopenTensorSoftmaxDX = 46,
6222  miopenTensorSoftmaxDY = 47,
6223  miopenTensorBatchnormX = 48,
6224  miopenTensorBatchnormY = 49,
6225  miopenTensorBatchnormRunningMean = 50,
6226  miopenTensorBatchnormRunningVariance = 51,
6227  miopenTensorBatchnormSavedMean = 52,
6228  miopenTensorBatchnormSavedVariance = 53,
6229  miopenTensorBatchnormScale = 54,
6230  miopenTensorBatchnormScaleDiff = 55,
6231  miopenTensorBatchnormEstimatedMean = 56,
6232  miopenTensorBatchnormEstimatedVariance = 57,
6233  miopenTensorBatchnormBias = 58,
6234  miopenTensorBatchnormBiasDiff = 59,
6235  miopenTensorBatchnormDX = 60,
6236  miopenTensorBatchnormDY = 61,
6237 #endif
6238 
6239  miopenTensorArgumentIsScalar = 1U << 31,
6240 
6241  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,
6242 #ifdef MIOPEN_BETA_API
6243  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,
6244  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,
6245 #endif
6246 } miopenTensorArgumentId_t;
6247 
6251 typedef enum
6252 {
6253  miopenFindResultsOrderByTime = 0,
6254  miopenFindResultsOrderByWorkspaceSize = 1,
6255 } miopenFindResultsOrder_t;
6256 
6264 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,
6265  miopenConvolutionDescriptor_t operatorDesc,
6266  miopenProblemDirection_t direction);
6267 
6279 typedef enum
6280 {
6281  miopenMhaMaskNone = 0,
6282  miopenMhaMaskCausal = 1,
6283 } miopenMhaMask_t;
6284 
6285 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,
6286  miopenMhaDescriptor_t operatorDesc,
6287  miopenProblemDirection_t direction);
6288 
6295 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);
6296 
6306 MIOPEN_EXPORT miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale);
6307 
6317 MIOPEN_EXPORT miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float* scale);
6318 
6325 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);
6326 
6338 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,
6339  float alpha,
6340  float beta,
6341  miopenSoftmaxAlgorithm_t algorithm,
6342  miopenSoftmaxMode_t mode);
6343 
6355 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,
6356  float* alpha,
6357  float* beta,
6358  miopenSoftmaxAlgorithm_t* algorithm,
6359  miopenSoftmaxMode_t* mode);
6360 
6366 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);
6367 
6375 MIOPEN_EXPORT miopenStatus_t
6376 miopenSetProblemTensorDescriptor(miopenProblem_t problem,
6377  miopenTensorArgumentId_t id,
6378  const miopenTensorDescriptor_t descriptor);
6379 
6382 MIOPEN_DECLARE_OBJECT(miopenFindOptions);
6383 
6389 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);
6390 
6396 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);
6397 
6404 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value);
6405 
6412 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,
6413  miopenFindResultsOrder_t value);
6414 
6422 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,
6423  size_t value);
6424 
6432 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,
6433  void* buffer,
6434  size_t size);
6435 
6444 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,
6445  miopenTensorArgumentId_t id,
6446  void* buffer);
6447 
6455 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,
6456  unsigned attach);
6457 
6460 MIOPEN_DECLARE_OBJECT(miopenSolution);
6461 
6473 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,
6474  miopenProblem_t problem,
6475  miopenFindOptions_t options,
6476  miopenSolution_t* solutions,
6477  size_t* numSolutions,
6478  size_t maxSolutions);
6479 
6482 struct miopenTensorArgument_t
6483 {
6484  /* @brief Identifier of the tensor argument.
6485  */
6486  miopenTensorArgumentId_t id;
6487  /* @brief Tensor descriptor to override the value stored in the solution.
6488  *
6489  * Some solvers may support overriding input and output tensor descriptors, but right now there
6490  * is no way to tell from the API. Intended for the future use.
6491  */
6492  miopenTensorDescriptor_t* descriptor;
6493  /* @brief Pointer to the device memory buffer to use for the operation or to the host memory if
6494  * the value is scalar.
6495  */
6496  void* buffer;
6497 };
6498 
6510 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,
6511  miopenSolution_t solution,
6512  size_t nInputs,
6513  const miopenTensorArgument_t* tensors,
6514  void* workspace,
6515  size_t workspaceSize);
6516 
6522 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);
6523 
6531 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,
6532  const char* data,
6533  size_t size);
6534 
6541 MIOPEN_EXPORT miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data);
6542 
6549 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size);
6550 
6557 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,
6558  size_t* workspaceSize);
6559 
6566 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time);
6567 
6574 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,
6575  uint64_t* solverId);
6576 
6583 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,
6584  miopenConvAlgorithm_t* result);
6585 
6586 #ifdef MIOPEN_BETA_API
6587 
6596 MIOPEN_EXPORT miopenStatus_t
6597 miopenCreateActivationProblem(miopenProblem_t* problem,
6598  miopenActivationDescriptor_t operatorDesc,
6599  miopenProblemDirection_t direction);
6600 
6609 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,
6610  miopenBatchNormMode_t mode,
6611  bool runningMeanVariance,
6612  miopenProblemDirection_t direction);
6613 
6633 MIOPEN_EXPORT miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2);
6634 
6642 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,
6643  miopenProblemDirection_t direction);
6644 
6653 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,
6654  miopenSoftmaxDescriptor_t operatorDesc,
6655  miopenProblemDirection_t direction);
6656 
6657 #endif
6658 
6660 // CLOSEOUT find2 DOXYGEN GROUP
6661 
6662 #ifdef MIOPEN_BETA_API
6663 
6668 typedef enum
6669 {
6670  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,
6671  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =
6672  1,
6673 } miopenReduceCalculationNanPropagation_t;
6674 
6675 // ReduceCalculation APIs
6684 typedef enum
6685 {
6686  MIOPEN_REDUCE_CALCULATION_PROD =
6687  1,
6688  MIOPEN_REDUCE_CALCULATION_SUM =
6689  2,
6690 } miopenReduceCalculationOp_t;
6691 
6701 MIOPEN_EXPORT miopenStatus_t
6702 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,
6703  const miopenTensorDescriptor_t xDesc,
6704  const int32_t dim,
6705  const miopenReduceCalculationOp_t reduceCalculationOp,
6706  const miopenTensorDescriptor_t reduceDesc,
6707  size_t* sizeInBytes);
6708 
6722 MIOPEN_EXPORT miopenStatus_t
6723 miopenReduceCalculationForward(miopenHandle_t handle,
6724  miopenReduceCalculationNanPropagation_t nanPropagation,
6725  void* workspace,
6726  size_t workspaceSizeInBytes,
6727  const miopenTensorDescriptor_t xDesc,
6728  const void* x,
6729  const int32_t dim,
6730  const miopenReduceCalculationOp_t reduceCalculationOp,
6731  const miopenTensorDescriptor_t reduceDesc,
6732  void* y);
6733 
6735 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP
6736 #endif // MIOPEN_BETA_API
6737 
6738 #ifdef MIOPEN_BETA_API
6739 
6744 typedef enum
6745 {
6746  MIOPEN_REDUCE_EXTREME_ARGMIN =
6747  1,
6748  MIOPEN_REDUCE_EXTREME_ARGMAX =
6749  2,
6750  MIOPEN_REDUCE_EXTREME_MIN =
6751  3,
6752  MIOPEN_REDUCE_EXTREME_MAX =
6753  4,
6754 } miopenReduceExtremeOp_t;
6755 
6756 // ReduceExtreme APIs
6776 MIOPEN_EXPORT miopenStatus_t
6777 miopenReduceExtremeForward(miopenHandle_t handle,
6778  const miopenTensorDescriptor_t xDesc,
6779  const void* x,
6780  const int32_t dim,
6781  const miopenReduceExtremeOp_t reduceExtremeOp,
6782  const miopenTensorDescriptor_t yDesc,
6783  void* y,
6784  const miopenTensorDescriptor_t indiceDesc,
6785  void* indice);
6786 
6788 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP
6789 #endif // MIOPEN_BETA_API
6790 
6791 #ifdef MIOPEN_BETA_API
6792 // GroupNorm APIs
6817 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,
6818  miopenNormMode_t mode,
6819  const miopenTensorDescriptor_t xDesc,
6820  const void* x,
6821  const miopenTensorDescriptor_t weightDesc,
6822  const void* weight,
6823  const miopenTensorDescriptor_t biasDesc,
6824  const void* bias,
6825  const uint64_t num_groups,
6826  const float epsilon,
6827  const miopenTensorDescriptor_t yDesc,
6828  void* y,
6829  const miopenTensorDescriptor_t meanDesc,
6830  void* mean,
6831  const miopenTensorDescriptor_t rstdDesc,
6832  void* rstd);
6833 
6835 // CLOSEOUT groupnorm DOXYGEN GROUP
6836 #endif // MIOPEN_BETA_API
6837 
6838 #ifdef MIOPEN_BETA_API
6839 // LayerNorm APIs
6866 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,
6867  miopenNormMode_t mode,
6868  const miopenTensorDescriptor_t xDesc,
6869  const void* x,
6870  const miopenTensorDescriptor_t x2Desc,
6871  const void* x2,
6872  const miopenTensorDescriptor_t weightDesc,
6873  const void* weight,
6874  const miopenTensorDescriptor_t biasDesc,
6875  const void* bias,
6876  const float epsilon,
6877  const int32_t normalized_dim,
6878  const miopenTensorDescriptor_t yDesc,
6879  void* y,
6880  const miopenTensorDescriptor_t meanDesc,
6881  void* mean,
6882  const miopenTensorDescriptor_t rstdDesc,
6883  void* rstd);
6884 
6886 // CLOSEOUT LAYERNORM DOXYGEN GROUP
6887 #endif // MIOPEN_BETA_API
6888 
6889 #ifdef MIOPEN_BETA_API
6890 // LayerNorm APIs
6910 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,
6911  miopenNormMode_t mode,
6912  const miopenTensorDescriptor_t xDesc,
6913  const void* x,
6914  const miopenTensorDescriptor_t weightDesc,
6915  const void* weight,
6916  const float epsilon,
6917  const miopenTensorDescriptor_t yDesc,
6918  void* y,
6919  const miopenTensorDescriptor_t rstdDesc,
6920  void* rstd);
6921 
6936 MIOPEN_EXPORT miopenStatus_t
6937 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,
6938  miopenNormMode_t mode,
6939  const miopenTensorDescriptor_t dyDesc,
6940  const miopenTensorDescriptor_t xDesc,
6941  const miopenTensorDescriptor_t weightDesc,
6942  const miopenTensorDescriptor_t rstdDesc,
6943  const miopenTensorDescriptor_t dxDesc,
6944  const miopenTensorDescriptor_t dwDesc,
6945  size_t* sizeInBytes);
6946 
6967 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,
6968  miopenNormMode_t mode,
6969  void* workspace,
6970  size_t workspaceSizeInBytes,
6971  const miopenTensorDescriptor_t dyDesc,
6972  const void* dy,
6973  const miopenTensorDescriptor_t xDesc,
6974  const void* x,
6975  const miopenTensorDescriptor_t weightDesc,
6976  const void* weight,
6977  const miopenTensorDescriptor_t rstdDesc,
6978  const void* rstd,
6979  const miopenTensorDescriptor_t dxDesc,
6980  void* dx,
6981  const miopenTensorDescriptor_t dwDesc,
6982  void* dw);
6984 // CLOSEOUT LAYERNORM DOXYGEN GROUP
6985 #endif // MIOPEN_BETA_API
6986 
6987 #ifdef MIOPEN_BETA_API
6988 // Graph API
7000 typedef enum
7001 {
7002  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,
7003  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,
7004  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,
7005  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,
7006  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,
7007  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,
7008  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,
7009  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,
7010  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,
7011  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,
7012  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,
7013  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,
7014  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,
7015  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
7016  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,
7017  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,
7018  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,
7019  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,
7020  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,
7021  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,
7022  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,
7023  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,
7024  MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,
7025  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,
7026  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,
7027  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,
7028  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,
7029  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,
7030  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,
7031  MIOPEN_BACKEND_RNG_DESCRIPTOR,
7032  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,
7033  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,
7034 } miopenBackendDescriptorType_t;
7035 
7043 typedef enum
7044 {
7045  MIOPEN_ATTR_POINTWISE_MODE = 0,
7046  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,
7047  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,
7048  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,
7049  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,
7050  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,
7051  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,
7052  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,
7053  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,
7054  MIOPEN_ATTR_POINTWISE_AXIS = 9,
7055 
7056  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,
7057  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,
7058  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,
7059  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,
7060  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,
7061  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,
7062  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,
7063 
7064  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,
7065  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,
7066  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,
7067  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,
7068 
7069  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,
7070  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,
7071  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,
7072 
7073  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,
7074  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,
7075  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,
7076  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,
7077  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,
7078  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,
7079 
7080  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,
7081  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,
7082  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,
7083  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,
7084 
7085  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,
7086  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,
7087 
7088  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,
7089  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,
7090  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,
7091  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,
7092  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,
7093  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,
7094  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,
7095  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,
7096  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,
7097  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,
7098  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,
7099  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,
7100  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,
7101  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,
7102  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,
7103  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,
7104  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,
7105  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,
7106  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,
7107  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,
7108  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,
7109  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,
7110  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,
7111  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,
7112  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,
7113  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,
7114  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,
7115 
7116  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,
7117  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,
7118  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,
7119  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,
7120  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,
7121 
7122  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,
7123  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,
7124  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,
7125  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,
7126  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,
7127  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,
7128  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,
7129  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,
7130  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,
7131  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,
7132  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,
7133  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,
7134  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,
7135  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,
7136  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,
7137  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,
7138  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,
7139 
7140  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,
7141  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,
7142  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,
7143 
7144  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,
7145  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,
7146  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,
7147  MIOPEN_ATTR_TENSOR_STRIDES = 903,
7148  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,
7149  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,
7150  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,
7151  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,
7152  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,
7153  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,
7154  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,
7155 
7156  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,
7157  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,
7158  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,
7159  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,
7160 
7161  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,
7162  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,
7163 
7164  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,
7165  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,
7166  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,
7167  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,
7168 
7169  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,
7170  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,
7171  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,
7172  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,
7173  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,
7174  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,
7175  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,
7176 
7177  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,
7178  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,
7179 
7180  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,
7181  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,
7182  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,
7183  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,
7184  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,
7185  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,
7186  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,
7187  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,
7188 
7189  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,
7190  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,
7191 
7192  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,
7193  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,
7194  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,
7195 
7196  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,
7197  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,
7198  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,
7199  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,
7200  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,
7201  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,
7202  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,
7203  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,
7204  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,
7205  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,
7206  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,
7207 
7208  MIOPEN_ATTR_RESAMPLE_MODE = 1700,
7209  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,
7210  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,
7211  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,
7212  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,
7213  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,
7214  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,
7215  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,
7216  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,
7217 
7218  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,
7219  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,
7220  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,
7221  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,
7222  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,
7223  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,
7224 
7225  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,
7226  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,
7227  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,
7228  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,
7229  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,
7230  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,
7231  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,
7232  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,
7233 
7234  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,
7235  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,
7236  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,
7237  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,
7238 
7239  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,
7240  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,
7241  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,
7242  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,
7243  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,
7244 
7245  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,
7246  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,
7247  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,
7248  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,
7249  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,
7250  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,
7251  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,
7252  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,
7253  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,
7254  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,
7255  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,
7256  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,
7257  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,
7258  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,
7259  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,
7260 
7261  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,
7262  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,
7263  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,
7264  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,
7265  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,
7266  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,
7267  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,
7268  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,
7269  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,
7270  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,
7271  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,
7272 
7273  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,
7274  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,
7275 
7276  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,
7277  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,
7278  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,
7279  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,
7280  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,
7281  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,
7282 
7283  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,
7284  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,
7285  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,
7286  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,
7287 
7288 } miopenBackendAttributeName_t;
7289 
7297 typedef enum
7298 {
7299  MIOPEN_TYPE_HANDLE = 0,
7300  MIOPEN_TYPE_DATA_TYPE,
7301  MIOPEN_TYPE_BOOLEAN,
7302  MIOPEN_TYPE_INT64,
7303  MIOPEN_TYPE_FLOAT,
7304  MIOPEN_TYPE_DOUBLE,
7305  MIOPEN_TYPE_VOID_PTR,
7306  MIOPEN_TYPE_CONVOLUTION_MODE,
7307  MIOPEN_TYPE_HEUR_MODE,
7308  MIOPEN_TYPE_KNOB_TYPE,
7309  MIOPEN_TYPE_NAN_PROPOGATION,
7310  MIOPEN_TYPE_NUMERICAL_NOTE,
7311  MIOPEN_TYPE_LAYOUT_TYPE,
7312  MIOPEN_TYPE_ATTRIB_NAME,
7313  MIOPEN_TYPE_POINTWISE_MODE,
7314  MIOPEN_TYPE_BACKEND_DESCRIPTOR,
7315  MIOPEN_TYPE_GENSTATS_MODE,
7316  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,
7317  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,
7318  MIOPEN_TYPE_BEHAVIOR_NOTE,
7319  MIOPEN_TYPE_TENSOR_REORDERING_MODE,
7320  MIOPEN_TYPE_RESAMPLE_MODE,
7321  MIOPEN_TYPE_PADDING_MODE,
7322  MIOPEN_TYPE_INT32,
7323  MIOPEN_TYPE_CHAR,
7324  MIOPEN_TYPE_SIGNAL_MODE,
7325  MIOPEN_TYPE_FRACTION,
7326  MIOPEN_TYPE_NORM_MODE,
7327  MIOPEN_TYPE_NORM_FWD_PHASE,
7328  MIOPEN_TYPE_RNG_DISTRIBUTION
7329 } miopenBackendAttributeType_t;
7330 
7336 typedef enum
7337 {
7339  MIOPEN_POINTWISE_ADD,
7340 
7343  MIOPEN_POINTWISE_ADD_SQUARE,
7344 
7346  MIOPEN_POINTWISE_DIV,
7347 
7349  MIOPEN_POINTWISE_MAX,
7350 
7352  MIOPEN_POINTWISE_MIN,
7353 
7356  MIOPEN_POINTWISE_MOD,
7357 
7359  MIOPEN_POINTWISE_MUL,
7360 
7362  MIOPEN_POINTWISE_POW,
7363 
7365  MIOPEN_POINTWISE_SUB,
7366 
7368  MIOPEN_POINTWISE_ABS,
7369 
7371  MIOPEN_POINTWISE_CEIL,
7372 
7374  MIOPEN_POINTWISE_COS,
7375 
7377  MIOPEN_POINTWISE_EXP,
7378 
7380  MIOPEN_POINTWISE_FLOOR,
7381 
7383  MIOPEN_POINTWISE_LOG,
7384 
7386  MIOPEN_POINTWISE_NEG,
7387 
7389  MIOPEN_POINTWISE_RSQRT,
7390 
7392  MIOPEN_POINTWISE_SIN,
7393 
7395  MIOPEN_POINTWISE_SQRT,
7396 
7398  MIOPEN_POINTWISE_TAN,
7399 
7401  MIOPEN_POINTWISE_ERF,
7402 
7406  MIOPEN_POINTWISE_IDENTITY,
7407 
7409  MIOPEN_POINTWISE_RELU_FWD,
7410 
7412  MIOPEN_POINTWISE_TANH_FWD,
7413 
7415  MIOPEN_POINTWISE_SIGMOID_FWD,
7416 
7418  MIOPEN_POINTWISE_ELU_FWD,
7419 
7422  MIOPEN_POINTWISE_GELU_FWD,
7423 
7425  MIOPEN_POINTWISE_SOFTPLUS_FWD,
7426 
7428  MIOPEN_POINTWISE_SWISH_FWD,
7429 
7433  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,
7434 
7437  MIOPEN_POINTWISE_RELU_BWD,
7438 
7440  MIOPEN_POINTWISE_TANH_BWD,
7441 
7443  MIOPEN_POINTWISE_SIGMOID_BWD,
7444 
7447  MIOPEN_POINTWISE_ELU_BWD,
7448 
7451  MIOPEN_POINTWISE_GELU_BWD,
7452 
7454  MIOPEN_POINTWISE_SOFTPLUS_BWD,
7455 
7457  MIOPEN_POINTWISE_SWISH_BWD,
7458 
7464  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,
7465 
7467  MIOPEN_POINTWISE_CMP_EQ,
7468 
7470  MIOPEN_POINTWISE_CMP_NEQ,
7471 
7473  MIOPEN_POINTWISE_CMP_GT,
7474 
7477  MIOPEN_POINTWISE_CMP_GE,
7478 
7480  MIOPEN_POINTWISE_CMP_LT,
7481 
7484  MIOPEN_POINTWISE_CMP_LE,
7485 
7487  MIOPEN_POINTWISE_LOGICAL_AND,
7488 
7490  MIOPEN_POINTWISE_LOGICAL_OR,
7491 
7493  MIOPEN_POINTWISE_LOGICAL_NOT,
7494 
7496  MIOPEN_POINTWISE_GEN_INDEX,
7497 
7500  MIOPEN_POINTWISE_BINARY_SELECT,
7501 
7504  MIOPEN_POINTWISE_RECIPROCAL
7505 } miopenPointwiseMode_t;
7506 
7512 typedef enum
7513 {
7514  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,
7515  MIOPEN_RNG_DISTRIBUTION_UNIFORM,
7516  MIOPEN_RNG_DISTRIBUTION_NORMAL,
7517 } miopenRngDistribution_t;
7518 
7519 typedef enum
7520 {
7521  /* IDENTITY alpha = 1.0 and beta = 0.0 */
7522  /* SCALE alpha = 4.2 and beta = 0.0 */
7523  /* BILINEAR alpha = 3.2 and beta = 1.1 */
7524  /* ERROR_STATE alpha = 0.0 and beta = 3.1 */
7525 
7526  DEFAULT = 0, /* alpha = 1.0 and beta = 0.0.*/
7527  SCALE = 1, /* alpha with some value and beta 0.0*/
7528  BILINEAR = 2, /* both alpha and beta with some value*/
7529  ERROR_STATE = 3, /* alpha 0.0 and beta with some value, this should not occur.
7530  But used to check for errors.*/
7531 } miopenAlphaBetaCase_t;
7536 typedef enum
7537 {
7538  MIOPEN_HEUR_MODE_INSTANT = 0,
7539  MIOPEN_HEUR_MODE_B = 1,
7540  MIOPEN_HEUR_MODE_FALLBACK = 2,
7541  MIOPEN_HEUR_MODE_A = 3,
7542  MIOPEN_HEUR_MODES_COUNT = 4,
7543 } miopenBackendHeurMode_t;
7544 
7557 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)
7558 
7559 
7572 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(
7573  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);
7574 
7604 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,
7605  miopenBackendAttributeName_t attributeName,
7606  miopenBackendAttributeType_t attributeType,
7607  int64_t elementCount,
7608  void* arrayOfElements);
7609 
7626 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);
7627 
7662 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,
7663  miopenBackendAttributeName_t attributeName,
7664  miopenBackendAttributeType_t attributeType,
7665  int64_t requestedElementCount,
7666  int64_t* elementCount,
7667  void* arrayOfElements);
7668 
7688 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,
7689  miopenBackendDescriptor_t executionPlan,
7690  miopenBackendDescriptor_t variantPack);
7691 
7708 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);
7709 
7727 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,
7728  miopenBackendDescriptorType_t descriptorType,
7729  size_t sizeInBytes);
7730 
7732 // CLOSEOUT BackendAPI DOXYGEN GROUP
7733 #endif // MIOPEN_BETA_API
7734 
7735 #ifdef MIOPEN_BETA_API
7736 // FusedAdam APIs
7879 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,
7880  const miopenTensorDescriptor_t paramDesc,
7881  void* param,
7882  const miopenTensorDescriptor_t gradDesc,
7883  const void* grad,
7884  const miopenTensorDescriptor_t expAvgDesc,
7885  void* expAvg,
7886  const miopenTensorDescriptor_t expAvgSqDesc,
7887  void* expAvgSq,
7888  const miopenTensorDescriptor_t maxExpAvgSqDesc,
7889  void* maxExpAvgSq,
7890  const miopenTensorDescriptor_t stateStepDesc,
7891  void* stateStep,
7892  const unsigned int state_step,
7893  const float lr,
7894  const float beta1,
7895  const float beta2,
7896  const float weight_decay,
7897  const float eps,
7898  const bool amsgrad,
7899  const bool maximize,
7900  const bool adamw,
7901  const miopenTensorDescriptor_t gradScaleDesc,
7902  const void* gradScale,
7903  const miopenTensorDescriptor_t foundInfDesc,
7904  const void* foundInf);
7905 
8046 MIOPEN_EXPORT miopenStatus_t
8047 miopenFusedAdamWithOutput(miopenHandle_t handle,
8048  const miopenTensorDescriptor_t paramInDesc,
8049  void* paramIn,
8050  const miopenTensorDescriptor_t paramOutDesc,
8051  void* paramOut,
8052  const miopenTensorDescriptor_t paramOutFloat16Desc,
8053  void* paramOutFloat16,
8054  const miopenTensorDescriptor_t gradInDesc,
8055  const void* gradIn,
8056  const miopenTensorDescriptor_t expAvgInDesc,
8057  void* expAvgIn,
8058  const miopenTensorDescriptor_t expAvgOutDesc,
8059  void* expAvgOut,
8060  const miopenTensorDescriptor_t expAvgSqInDesc,
8061  void* expAvgSqIn,
8062  const miopenTensorDescriptor_t expAvgSqOutDesc,
8063  void* expAvgSqOut,
8064  const miopenTensorDescriptor_t maxExpAvgSqInDesc,
8065  void* maxExpAvgSqIn,
8066  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,
8067  void* maxExpAvgSqOut,
8068  const miopenTensorDescriptor_t stateStepInDesc,
8069  void* stateStepIn,
8070  const miopenTensorDescriptor_t stateStepOutDesc,
8071  void* stateStepOut,
8072  const unsigned int state_step,
8073  const float lr,
8074  const float beta1,
8075  const float beta2,
8076  const float weight_decay,
8077  const float eps,
8078  const bool amsgrad,
8079  const bool maximize,
8080  const bool adamw,
8081  const miopenTensorDescriptor_t gradScaleDesc,
8082  const void* gradScale,
8083  const miopenTensorDescriptor_t foundInfDesc,
8084  const void* foundInf);
8085 
8087 // CLOSEOUT SGD DOXYGEN GROUP
8088 #endif // MIOPEN_BETA_API
8089 
8090 #ifdef MIOPEN_BETA_API
8091 // TransformersAdamW APIs
8182 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,
8183  const miopenTensorDescriptor_t paramDesc,
8184  void* param,
8185  const miopenTensorDescriptor_t gradDesc,
8186  const void* grad,
8187  const miopenTensorDescriptor_t expAvgDesc,
8188  void* expAvg,
8189  const miopenTensorDescriptor_t expAvgSqDesc,
8190  void* expAvgSq,
8191  const miopenTensorDescriptor_t stateStepDesc,
8192  void* stateStep,
8193  const unsigned int state_step,
8194  const float lr,
8195  const float beta1,
8196  const float beta2,
8197  const float weight_decay,
8198  const float eps,
8199  const bool correct_bias,
8200  const miopenTensorDescriptor_t gradScaleDesc,
8201  const void* gradScale,
8202  const miopenTensorDescriptor_t foundInfDesc,
8203  const void* foundInf);
8204 
8331 MIOPEN_EXPORT miopenStatus_t
8332 miopenTransformersAdamWWithOutput(miopenHandle_t handle,
8333  const miopenTensorDescriptor_t paramInDesc,
8334  void* paramIn,
8335  const miopenTensorDescriptor_t paramOutDesc,
8336  void* paramOut,
8337  const miopenTensorDescriptor_t paramOutFloat16Desc,
8338  void* paramOutFloat16,
8339  const miopenTensorDescriptor_t gradInDesc,
8340  const void* gradIn,
8341  const miopenTensorDescriptor_t expAvgInDesc,
8342  void* expAvgIn,
8343  const miopenTensorDescriptor_t expAvgOutDesc,
8344  void* expAvgOut,
8345  const miopenTensorDescriptor_t expAvgSqInDesc,
8346  void* expAvgSqIn,
8347  const miopenTensorDescriptor_t expAvgSqOutDesc,
8348  void* expAvgSqOut,
8349  const miopenTensorDescriptor_t stateStepInDesc,
8350  void* stateStepIn,
8351  const miopenTensorDescriptor_t stateStepOutDesc,
8352  void* stateStepOut,
8353  const unsigned int state_step,
8354  const float lr,
8355  const float beta1,
8356  const float beta2,
8357  const float weight_decay,
8358  const float eps,
8359  const float step_size,
8360  const bool correct_bias,
8361  const miopenTensorDescriptor_t gradScaleDesc,
8362  const void* gradScale,
8363  const miopenTensorDescriptor_t foundInfDesc,
8364  const void* foundInf);
8365 
8367 // CLOSEOUT SGD DOXYGEN GROUP
8368 #endif // MIOPEN_BETA_API
8369 
8370 #ifdef MIOPEN_BETA_API
8371 // GetItem APIs
8384 MIOPEN_EXPORT miopenStatus_t
8385 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,
8386  uint32_t indexCount,
8387  const miopenTensorDescriptor_t* indexDescs,
8388  size_t* sizeInBytes);
8389 
8414 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,
8415  void* workspace,
8416  size_t workspaceSizeInBytes,
8417  const miopenTensorDescriptor_t dyDesc,
8418  const void* dy,
8419  uint32_t indexCount,
8420  const miopenTensorDescriptor_t* indexDescs,
8421  const void* const* indexs,
8422  const miopenTensorDescriptor_t dxDesc,
8423  void* dx,
8424  const miopenTensorDescriptor_t errorDesc,
8425  void* error,
8426  uint32_t dimCount,
8427  const int32_t* dims,
8428  uint32_t sliceCount,
8429  const int32_t* slices,
8430  uint32_t offset);
8431 
8433 // CLOSEOUT GETITEM DOXYGEN GROUP
8434 #endif // MIOPEN_BETA_API
8435 
8436 #ifdef MIOPEN_BETA_API
8437 // RotaryPositionalEmbeddings APIs
8455 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,
8456  const miopenTensorDescriptor_t xDesc,
8457  const void* x,
8458  const miopenTensorDescriptor_t cosDesc,
8459  const void* cos,
8460  const miopenTensorDescriptor_t sinDesc,
8461  const void* sin,
8462  const miopenTensorDescriptor_t yDesc,
8463  void* y);
8464 
8478 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,
8479  const miopenTensorDescriptor_t dyDesc,
8480  const void* dy,
8481  const miopenTensorDescriptor_t cosDesc,
8482  const void* cos,
8483  const miopenTensorDescriptor_t sinDesc,
8484  const void* sin,
8485  const miopenTensorDescriptor_t dxDesc,
8486  void* dx);
8488 // CLOSEOUT ROPE DOXYGEN GROUP
8489 // kthvalue APIs
8510 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,
8511  miopenTensorDescriptor_t inputDesc,
8512  const void* input,
8513  miopenTensorDescriptor_t outputDesc,
8514  void* output,
8515  miopenTensorDescriptor_t indicesDesc,
8516  size_t* indices,
8517  size_t k,
8518  int32_t dim = -1,
8519  bool keepDim = false);
8520 
8522 // CLOSEOUT kthvalue DOXYGEN GROUP
8523 #endif // MIOPEN_BETA_API
8524 
8525 #ifdef MIOPEN_BETA_API
8539 MIOPEN_EXPORT miopenStatus_t
8540 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,
8541  miopenTensorDescriptor_t inputDesc,
8542  miopenTensorDescriptor_t weightDesc,
8543  size_t* sizeInBytes);
8544 
8561 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,
8562  void* workspace,
8563  size_t workspaceSizeInBytes,
8564  miopenTensorDescriptor_t inputDesc,
8565  const void* input,
8566  miopenTensorDescriptor_t weightDesc,
8567  const void* weight,
8568  miopenTensorDescriptor_t doutputDesc,
8569  const void* doutput,
8570  miopenTensorDescriptor_t dinputDesc,
8571  void* dinput,
8572  miopenTensorDescriptor_t dweightDesc,
8573  void* dweight);
8574 
8576 // CLOSEOUT RELU DOXYGEN GROUP
8577 #endif // MIOPEN_BETA_API
8578 
8579 #ifdef MIOPEN_BETA_API
8580 
8585 typedef enum
8586 {
8587  MIOPEN_LOSS_REDUCTION_NONE = 0,
8588  MIOPEN_LOSS_REDUCTION_SUM = 1,
8589  MIOPEN_LOSS_REDUCTION_MEAN = 2,
8591 } miopenLossReductionMode_t;
8592 
8593 // SoftMarginLoss APIs
8611 MIOPEN_EXPORT miopenStatus_t
8612 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8613  miopenTensorDescriptor_t inputDesc,
8614  miopenTensorDescriptor_t targetDesc,
8615  miopenTensorDescriptor_t outputDesc,
8616  miopenLossReductionMode_t reduction,
8617  size_t* sizeInBytes);
8618 
8635 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,
8636  miopenTensorDescriptor_t inputDesc,
8637  const void* input,
8638  miopenTensorDescriptor_t targetDesc,
8639  const void* target,
8640  miopenTensorDescriptor_t outputDesc,
8641  void* output,
8642  miopenLossReductionMode_t reduction,
8643  void* workspace = nullptr,
8644  size_t workspaceSizeInBytes = 0);
8645 
8660 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,
8661  miopenTensorDescriptor_t inputDesc,
8662  const void* input,
8663  miopenTensorDescriptor_t targetDesc,
8664  const void* target,
8665  miopenTensorDescriptor_t doutputDesc,
8666  const void* doutput,
8667  miopenTensorDescriptor_t dinputDesc,
8668  void* dinput,
8669  miopenLossReductionMode_t reduction);
8670 
8672 // CLOSEOUT LossFunction DOXYGEN GROUP
8673 #endif
8674 
8675 #ifdef MIOPEN_BETA_API
8676 // MultiMarginLoss APIs
8700 MIOPEN_EXPORT miopenStatus_t
8701 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8702  miopenTensorDescriptor_t inputDesc,
8703  miopenTensorDescriptor_t targetDesc,
8704  miopenTensorDescriptor_t weightDesc,
8705  miopenTensorDescriptor_t outputDesc,
8706  long p,
8707  float margin,
8708  miopenLossReductionMode_t reduction,
8709  size_t* sizeInBytes);
8710 
8738 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,
8739  miopenTensorDescriptor_t inputDesc,
8740  const void* input,
8741  miopenTensorDescriptor_t targetDesc,
8742  const void* target,
8743  miopenTensorDescriptor_t weightDesc,
8744  const void* weight,
8745  miopenTensorDescriptor_t outputDesc,
8746  void* output,
8747  long p,
8748  float margin,
8749  miopenLossReductionMode_t reduction,
8750  void* workspace,
8751  size_t workspaceSizeInBytes);
8752 
8754 // CLOSEOUT LossFunction DOXYGEN GROUP
8755 #endif // MIOPEN_BETA_API
8756 
8768 typedef enum
8769 {
8770  miopenTuningPolicyNone = 1,
8771  miopenTuningPolicyDbUpdate = 2,
8772  miopenTuningPolicySearch =
8773  3,
8774  miopenTuningPolicySearchDbUpdate = 4,
8775  miopenTuningPolicyDbClean = 5,
8776 } miopenTuningPolicy_t;
8777 
8786 MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,
8787  miopenTuningPolicy_t newValue);
8788 
8796 MIOPEN_EXPORT miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle,
8797  miopenTuningPolicy_t* value);
8798 
8799 #ifdef __cplusplus
8800 }
8801 #endif
8802 
8803 #ifdef __clang__
8804 #pragma clang diagnostic pop
8805 #endif
8806 
8807 #endif // MIOPEN_GUARD_MIOPEN_H_
miopenCreateOpActivationBackward
miopenStatus_t miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *activBwdOp, miopenActivationMode_t mode)
Creates a backward activation operator.
miopenCreateOpBatchNormForward
miopenStatus_t miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnFwdOp, const miopenBatchNormMode_t bn_mode, bool runningMeanVariance)
Creates a forward training batch normalization operator.
miopenFusionPlanConvolutionGetAlgo
miopenStatus_t miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, const int requestAlgoCount, int *returnedAlgoCount, miopenConvFwdAlgorithm_t *returnedAlgos)
Returns the supported algorithms for the convolution operator in the Fusion Plan.
miopenFusionPlanGetWorkSpaceSize
miopenStatus_t miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle, miopenFusionPlanDescriptor_t fusePlanDesc, size_t *workSpaceSize, miopenConvFwdAlgorithm_t algo)
Query the workspace size required for the fusion plan.
miopenFusionPlanConvolutionSetAlgo
miopenStatus_t miopenFusionPlanConvolutionSetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo)
Requests the fusion runtime to choose a particular algorithm for the added convolution operation.
miopenCreateOpBatchNormInference
miopenStatus_t miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnOp, const miopenBatchNormMode_t bn_mode, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc)
Creates a forward inference batch normalization operator.
miopenSetOpArgsBiasForward
miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t biasOp, const void *alpha, const void *beta, const void *bias)
Sets the arguments for forward bias op.
miopenCreateOpConvForward
miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *convOp, miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t wDesc)
Creates forward convolution operator.
miopenSetOpArgsBatchNormInference
miopenStatus_t miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *bnScale, const void *bnBias, const void *estimatedMean, const void *estimatedVariance, double epsilon)
Sets the arguments for inference batch normalization op.
miopenSetOpArgsBatchNormForward
miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *bnScale, const void *bnBias, void *savedMean, void *savedInvVariance, void *runningMean, void *runningVariance, double expAvgFactor, double epsilon)
Sets the arguments for forward batch normalization op.
miopenExecuteFusionPlan
miopenStatus_t miopenExecuteFusionPlan(const miopenHandle_t handle, const miopenFusionPlanDescriptor_t fusePlanDesc, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, miopenOperatorArgs_t args)
Executes the fusion plan. Only compatible with NHWC/NDHWC tensor layouts.
miopenFusionPlanGetOp
miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc, const int op_idx, miopenFusionOpDescriptor_t *op)
Allows access to the operators in a fusion plan.
miopenDestroyFusionPlan
miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc)
Destroy the fusion plan descriptor object.
miopenCreateOpActivationForward
miopenStatus_t miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *activFwdOp, miopenActivationMode_t mode)
Creates a forward activation operator.
miopenExecuteFusionPlan_v2
miopenStatus_t miopenExecuteFusionPlan_v2(const miopenHandle_t handle, const miopenFusionPlanDescriptor_t fusePlanDesc, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, miopenOperatorArgs_t args, void *workspace, size_t workspaceSize)
Executes the fusion plan with a workspace buffer for layout transformations.
miopenFusionDirection_t
miopenFusionDirection_t
Kernel fusion direction in the network.
Definition: miopen.h:3843
miopenSetOpArgsActivBackward
miopenStatus_t miopenSetOpArgsActivBackward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t activBwdOp, const void *alpha, const void *beta, const void *y, const void *reserved, double activAlpha, double activBeta, double activGamma)
Sets the arguments for backward activation op.
miopenCompileFusionPlan
miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle, miopenFusionPlanDescriptor_t fusePlanDesc)
Compiles the fusion plan.
miopenSetOpArgsBatchNormBackward
miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *x, const void *bnScale, const void *bnBias, void *resultBnScaleDiff, void *resultBnBiasDiff, const void *savedMean, const void *savedInvVariance)
Sets the arguments for backward batch normalization op.
miopenSetOpArgsActivForward
miopenStatus_t miopenSetOpArgsActivForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t activFwdOp, const void *alpha, const void *beta, double activAlpha, double activBeta, double activGamma)
Sets the arguments for forward activation op.
miopenDestroyOperatorArgs
miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args)
Destroys an operator argument object.
miopenCreateOpBatchNormBackward
miopenStatus_t miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnBwdOp, const miopenBatchNormMode_t bn_mode)
Creates a back propagation batch normalization operator.
miopenCreateOperatorArgs
miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t *args)
Creates an operator argument object.
miopenSetOpArgsConvForward
miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t convOp, const void *alpha, const void *beta, const void *w)
Sets the arguments for forward convolution op.
miopenConvolutionBiasActivationForward
miopenStatus_t miopenConvolutionBiasActivationForward(miopenHandle_t handle, const void *alpha1, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvFwdAlgorithm_t algo, void *workspace, size_t workspaceSizeInBytes, const void *alpha2, const miopenTensorDescriptor_t zDesc, const void *z, const miopenTensorDescriptor_t biasDesc, const void *bias, const miopenActivationDescriptor_t activationDesc, const miopenTensorDescriptor_t yDesc, void *y)
Prepares and executes the Convlution+Bias+Activation Fusion.
miopenCreateFusionPlan
miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t *fusePlanDesc, const miopenFusionDirection_t fuseDirection, const miopenTensorDescriptor_t inputDesc)
Creates the kenrel fusion plan descriptor object.
miopenCreateOpBiasForward
miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *biasOp, const miopenTensorDescriptor_t bDesc)
Creates a forward bias operator.
miopenHorizontalFusion
@ miopenHorizontalFusion
Definition: miopen.h:3845
miopenVerticalFusion
@ miopenVerticalFusion
Definition: miopen.h:3844
miopenBackendExecute
miopenStatus_t miopenBackendExecute(miopenHandle_t handle, miopenBackendDescriptor_t executionPlan, miopenBackendDescriptor_t variantPack)
Executes a graph.
miopenBackendHeurMode_t
miopenBackendHeurMode_t
Operation mode of CUDNN_BACKEND_ENGINEHEUR_DESCRIPTOR.
Definition: miopen.h:7537
miopenPointwiseMode_t
miopenPointwiseMode_t
Intended pointwise math operation for a pointwise operation descriptor.
Definition: miopen.h:7337
miopenBackendFinalize
miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor)
Finalizes a backend descriptor.
miopenBackendInitialize
miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor, miopenBackendDescriptorType_t descriptorType, size_t sizeInBytes)
Repurposes an instance of miopenBackendDescriptor_t.
miopenBackendAttributeName_t
miopenBackendAttributeName_t
Backend Descriptor's Attribute.
Definition: miopen.h:7044
miopenRngDistribution_t
miopenRngDistribution_t
Distribution for random number generation.
Definition: miopen.h:7513
miopenBackendDescriptorType_t
miopenBackendDescriptorType_t
Descriptor type.
Definition: miopen.h:7001
miopenBackendSetAttribute
miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor, miopenBackendAttributeName_t attributeName, miopenBackendAttributeType_t attributeType, int64_t elementCount, void *arrayOfElements)
Sets an attribute of a descriptor.
miopenBackendGetAttribute
miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor, miopenBackendAttributeName_t attributeName, miopenBackendAttributeType_t attributeType, int64_t requestedElementCount, int64_t *elementCount, void *arrayOfElements)
Retrieves backend descriptor's attribute.
miopenBackendCreateDescriptor
miopenStatus_t miopenBackendCreateDescriptor(miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t *descriptor)
Backend descriptor.
miopenAlphaBetaCase_t
miopenAlphaBetaCase_t
Definition: miopen.h:7520
miopenBackendDestroyDescriptor
miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor)
Destroys an instance of miopenBackendDescriptor_t.
miopenBackendAttributeType_t
miopenBackendAttributeType_t
Data type of an attribute of a backend descriptor.
Definition: miopen.h:7298
MIOPEN_HEUR_MODE_INSTANT
@ MIOPEN_HEUR_MODE_INSTANT
Definition: miopen.h:7538
MIOPEN_HEUR_MODE_A
@ MIOPEN_HEUR_MODE_A
Definition: miopen.h:7541
MIOPEN_HEUR_MODE_B
@ MIOPEN_HEUR_MODE_B
Definition: miopen.h:7539
MIOPEN_HEUR_MODES_COUNT
@ MIOPEN_HEUR_MODES_COUNT
Definition: miopen.h:7542
MIOPEN_HEUR_MODE_FALLBACK
@ MIOPEN_HEUR_MODE_FALLBACK
Definition: miopen.h:7540
MIOPEN_POINTWISE_SOFTPLUS_FWD
@ MIOPEN_POINTWISE_SOFTPLUS_FWD
Definition: miopen.h:7425
MIOPEN_POINTWISE_ELU_FWD
@ MIOPEN_POINTWISE_ELU_FWD
Definition: miopen.h:7418
MIOPEN_POINTWISE_RELU_FWD
@ MIOPEN_POINTWISE_RELU_FWD
Definition: miopen.h:7409
MIOPEN_POINTWISE_DIV
@ MIOPEN_POINTWISE_DIV
Definition: miopen.h:7346
MIOPEN_POINTWISE_SIGMOID_BWD
@ MIOPEN_POINTWISE_SIGMOID_BWD
Definition: miopen.h:7443
MIOPEN_POINTWISE_POW
@ MIOPEN_POINTWISE_POW
Definition: miopen.h:7362
MIOPEN_POINTWISE_MOD
@ MIOPEN_POINTWISE_MOD
Definition: miopen.h:7356
MIOPEN_POINTWISE_SQRT
@ MIOPEN_POINTWISE_SQRT
Definition: miopen.h:7395
MIOPEN_POINTWISE_BINARY_SELECT
@ MIOPEN_POINTWISE_BINARY_SELECT
Definition: miopen.h:7500
MIOPEN_POINTWISE_GELU_BWD
@ MIOPEN_POINTWISE_GELU_BWD
Definition: miopen.h:7451
MIOPEN_POINTWISE_MIN
@ MIOPEN_POINTWISE_MIN
Definition: miopen.h:7352
MIOPEN_POINTWISE_CMP_NEQ
@ MIOPEN_POINTWISE_CMP_NEQ
Definition: miopen.h:7470
MIOPEN_POINTWISE_FLOOR
@ MIOPEN_POINTWISE_FLOOR
Definition: miopen.h:7380
MIOPEN_POINTWISE_RSQRT
@ MIOPEN_POINTWISE_RSQRT
Definition: miopen.h:7389
MIOPEN_POINTWISE_CMP_EQ
@ MIOPEN_POINTWISE_CMP_EQ
Definition: miopen.h:7467
MIOPEN_POINTWISE_CMP_GE
@ MIOPEN_POINTWISE_CMP_GE
Definition: miopen.h:7477
MIOPEN_POINTWISE_ADD_SQUARE
@ MIOPEN_POINTWISE_ADD_SQUARE
Definition: miopen.h:7343
MIOPEN_POINTWISE_ERF
@ MIOPEN_POINTWISE_ERF
Definition: miopen.h:7401
MIOPEN_POINTWISE_SWISH_FWD
@ MIOPEN_POINTWISE_SWISH_FWD
Definition: miopen.h:7428
MIOPEN_POINTWISE_LOG
@ MIOPEN_POINTWISE_LOG
Definition: miopen.h:7383
MIOPEN_POINTWISE_SUB
@ MIOPEN_POINTWISE_SUB
Definition: miopen.h:7365
MIOPEN_POINTWISE_NEG
@ MIOPEN_POINTWISE_NEG
Definition: miopen.h:7386
MIOPEN_POINTWISE_LOGICAL_AND
@ MIOPEN_POINTWISE_LOGICAL_AND
Definition: miopen.h:7487
MIOPEN_POINTWISE_SWISH_BWD
@ MIOPEN_POINTWISE_SWISH_BWD
Definition: miopen.h:7457
MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
Definition: miopen.h:7433
MIOPEN_POINTWISE_SIN
@ MIOPEN_POINTWISE_SIN
Definition: miopen.h:7392
MIOPEN_POINTWISE_RECIPROCAL
@ MIOPEN_POINTWISE_RECIPROCAL
Definition: miopen.h:7504
MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
Definition: miopen.h:7464
MIOPEN_POINTWISE_GELU_FWD
@ MIOPEN_POINTWISE_GELU_FWD
Definition: miopen.h:7422
MIOPEN_POINTWISE_ABS
@ MIOPEN_POINTWISE_ABS
Definition: miopen.h:7368
MIOPEN_POINTWISE_CMP_LT
@ MIOPEN_POINTWISE_CMP_LT
Definition: miopen.h:7480
MIOPEN_POINTWISE_EXP
@ MIOPEN_POINTWISE_EXP
Definition: miopen.h:7377
MIOPEN_POINTWISE_GEN_INDEX
@ MIOPEN_POINTWISE_GEN_INDEX
Definition: miopen.h:7496
MIOPEN_POINTWISE_CEIL
@ MIOPEN_POINTWISE_CEIL
Definition: miopen.h:7371
MIOPEN_POINTWISE_LOGICAL_NOT
@ MIOPEN_POINTWISE_LOGICAL_NOT
Definition: miopen.h:7493
MIOPEN_POINTWISE_SIGMOID_FWD
@ MIOPEN_POINTWISE_SIGMOID_FWD
Definition: miopen.h:7415
MIOPEN_POINTWISE_SOFTPLUS_BWD
@ MIOPEN_POINTWISE_SOFTPLUS_BWD
Definition: miopen.h:7454
MIOPEN_POINTWISE_LOGICAL_OR
@ MIOPEN_POINTWISE_LOGICAL_OR
Definition: miopen.h:7490
MIOPEN_POINTWISE_TAN
@ MIOPEN_POINTWISE_TAN
Definition: miopen.h:7398
MIOPEN_POINTWISE_ELU_BWD
@ MIOPEN_POINTWISE_ELU_BWD
Definition: miopen.h:7447
MIOPEN_POINTWISE_IDENTITY
@ MIOPEN_POINTWISE_IDENTITY
Definition: miopen.h:7406
MIOPEN_POINTWISE_CMP_LE
@ MIOPEN_POINTWISE_CMP_LE
Definition: miopen.h:7484
MIOPEN_POINTWISE_COS
@ MIOPEN_POINTWISE_COS
Definition: miopen.h:7374
MIOPEN_POINTWISE_TANH_BWD
@ MIOPEN_POINTWISE_TANH_BWD
Definition: miopen.h:7440
MIOPEN_POINTWISE_MUL
@ MIOPEN_POINTWISE_MUL
Definition: miopen.h:7359
MIOPEN_POINTWISE_TANH_FWD
@ MIOPEN_POINTWISE_TANH_FWD
Definition: miopen.h:7412
MIOPEN_POINTWISE_RELU_BWD
@ MIOPEN_POINTWISE_RELU_BWD
Definition: miopen.h:7437
MIOPEN_POINTWISE_ADD
@ MIOPEN_POINTWISE_ADD
Definition: miopen.h:7339
MIOPEN_POINTWISE_MAX
@ MIOPEN_POINTWISE_MAX
Definition: miopen.h:7349
MIOPEN_POINTWISE_CMP_GT
@ MIOPEN_POINTWISE_CMP_GT
Definition: miopen.h:7473
MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
Definition: miopen.h:7261
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
Definition: miopen.h:7091
MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
Definition: miopen.h:7215
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
Definition: miopen.h:7218
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
Definition: miopen.h:7097
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
Definition: miopen.h:7088
MIOPEN_ATTR_OPERATION_SIGNAL_MODE
@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE
Definition: miopen.h:7239
MIOPEN_ATTR_OPERATION_RNG_DESC
@ MIOPEN_ATTR_OPERATION_RNG_DESC
Definition: miopen.h:7285
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
Definition: miopen.h:7089
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
Definition: miopen.h:7202
MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
Definition: miopen.h:7264
MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
Definition: miopen.h:7252
MIOPEN_ATTR_OPERATIONGRAPH_OPS
@ MIOPEN_ATTR_OPERATIONGRAPH_OPS
Definition: miopen.h:7141
MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
Definition: miopen.h:7165
MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
Definition: miopen.h:7060
MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
Definition: miopen.h:7243
MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
Definition: miopen.h:7268
MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
Definition: miopen.h:7271
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
Definition: miopen.h:7232
MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
Definition: miopen.h:7061
MIOPEN_ATTR_REDUCTION_OPERATOR
@ MIOPEN_ATTR_REDUCTION_OPERATOR
Definition: miopen.h:7189
MIOPEN_ATTR_OPERATION_MATMUL_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_DESC
Definition: miopen.h:7183
MIOPEN_ATTR_CONVOLUTION_DILATIONS
@ MIOPEN_ATTR_CONVOLUTION_DILATIONS
Definition: miopen.h:7058
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
Definition: miopen.h:7226
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
Definition: miopen.h:7110
MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
Definition: miopen.h:7210
MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
Definition: miopen.h:7076
MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
Definition: miopen.h:7248
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
Definition: miopen.h:7130
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
Definition: miopen.h:7198
MIOPEN_ATTR_KNOB_INFO_TYPE
@ MIOPEN_ATTR_KNOB_INFO_TYPE
Definition: miopen.h:7164
MIOPEN_ATTR_LAYOUT_INFO_TYPES
@ MIOPEN_ATTR_LAYOUT_INFO_TYPES
Definition: miopen.h:7162
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
Definition: miopen.h:7124
MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
Definition: miopen.h:7140
MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
Definition: miopen.h:7265
MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
Definition: miopen.h:7280
MIOPEN_ATTR_POINTWISE_MATH_PREC
@ MIOPEN_ATTR_POINTWISE_MATH_PREC
Definition: miopen.h:7046
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
Definition: miopen.h:7186
MIOPEN_ATTR_OPERATION_GENSTATS_MODE
@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE
Definition: miopen.h:7116
MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
Definition: miopen.h:7086
MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
Definition: miopen.h:7158
MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
Definition: miopen.h:7193
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
Definition: miopen.h:7101
MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
Definition: miopen.h:7159
MIOPEN_ATTR_TENSOR_IS_BY_VALUE
@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE
Definition: miopen.h:7152
MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
Definition: miopen.h:7245
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
Definition: miopen.h:7090
MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
Definition: miopen.h:7122
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
Definition: miopen.h:7255
MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
Definition: miopen.h:7273
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
Definition: miopen.h:7231
MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
Definition: miopen.h:7107
MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
Definition: miopen.h:7156
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
Definition: miopen.h:7201
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
Definition: miopen.h:7221
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
Definition: miopen.h:7126
MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
Definition: miopen.h:7241
MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
Definition: miopen.h:7240
MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
Definition: miopen.h:7114
MIOPEN_ATTR_ENGINEHEUR_RESULTS
@ MIOPEN_ATTR_ENGINEHEUR_RESULTS
Definition: miopen.h:7066
MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
Definition: miopen.h:7144
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
Definition: miopen.h:7104
MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
Definition: miopen.h:7136
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
Definition: miopen.h:7206
MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
Definition: miopen.h:7117
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
Definition: miopen.h:7254
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
Definition: miopen.h:7134
MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
Definition: miopen.h:7073
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
Definition: miopen.h:7200
MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
Definition: miopen.h:7237
MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
Definition: miopen.h:7267
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
Definition: miopen.h:7095
MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
Definition: miopen.h:7075
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
Definition: miopen.h:7098
MIOPEN_ATTR_TENSOR_VECTOR_COUNT
@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT
Definition: miopen.h:7148
MIOPEN_ATTR_OPERATION_MATMUL_CDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC
Definition: miopen.h:7182
MIOPEN_ATTR_REDUCTION_COMP_TYPE
@ MIOPEN_ATTR_REDUCTION_COMP_TYPE
Definition: miopen.h:7190
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
Definition: miopen.h:7229
MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
Definition: miopen.h:7149
MIOPEN_ATTR_TENSOR_DIMENSIONS
@ MIOPEN_ATTR_TENSOR_DIMENSIONS
Definition: miopen.h:7146
MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
Definition: miopen.h:7119
MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
Definition: miopen.h:7236
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
Definition: miopen.h:7111
MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
Definition: miopen.h:7172
MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
Definition: miopen.h:7174
MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
Definition: miopen.h:7078
MIOPEN_ATTR_RESAMPLE_STRIDES
@ MIOPEN_ATTR_RESAMPLE_STRIDES
Definition: miopen.h:7213
MIOPEN_ATTR_POINTWISE_ELU_ALPHA
@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA
Definition: miopen.h:7051
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
Definition: miopen.h:7257
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
Definition: miopen.h:7227
MIOPEN_ATTR_OPERATION_RNG_SEED
@ MIOPEN_ATTR_OPERATION_RNG_SEED
Definition: miopen.h:7284
MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
Definition: miopen.h:7262
MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
Definition: miopen.h:7112
MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
Definition: miopen.h:7235
MIOPEN_ATTR_RESAMPLE_MODE
@ MIOPEN_ATTR_RESAMPLE_MODE
Definition: miopen.h:7208
MIOPEN_ATTR_RNG_DISTRIBUTION
@ MIOPEN_ATTR_RNG_DISTRIBUTION
Definition: miopen.h:7276
MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
Definition: miopen.h:7263
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
Definition: miopen.h:7185
MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
Definition: miopen.h:7246
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
Definition: miopen.h:7050
MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
Definition: miopen.h:7274
MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
Definition: miopen.h:7157
MIOPEN_ATTR_POINTWISE_AXIS
@ MIOPEN_ATTR_POINTWISE_AXIS
Definition: miopen.h:7054
MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
Definition: miopen.h:7258
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
Definition: miopen.h:7048
MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
Definition: miopen.h:7169
MIOPEN_ATTR_OPERATION_MATMUL_BDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC
Definition: miopen.h:7181
MIOPEN_ATTR_TENSOR_DATA_TYPE
@ MIOPEN_ATTR_TENSOR_DATA_TYPE
Definition: miopen.h:7145
MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
Definition: miopen.h:7242
MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
Definition: miopen.h:7166
MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
Definition: miopen.h:7251
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
Definition: miopen.h:7223
MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
Definition: miopen.h:7212
MIOPEN_ATTR_MATMUL_COMP_TYPE
@ MIOPEN_ATTR_MATMUL_COMP_TYPE
Definition: miopen.h:7177
MIOPEN_ATTR_TENSOR_UNIQUE_ID
@ MIOPEN_ATTR_TENSOR_UNIQUE_ID
Definition: miopen.h:7150
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
Definition: miopen.h:7204
MIOPEN_ATTR_OPERATION_CONCAT_AXIS
@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS
Definition: miopen.h:7234
MIOPEN_ATTR_OPERATION_RNG_YDESC
@ MIOPEN_ATTR_OPERATION_RNG_YDESC
Definition: miopen.h:7283
MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
Definition: miopen.h:7170
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
Definition: miopen.h:7096
MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
Definition: miopen.h:7065
MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
Definition: miopen.h:7154
MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
Definition: miopen.h:7052
MIOPEN_ATTR_TENSOR_IS_VIRTUAL
@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL
Definition: miopen.h:7151
MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
Definition: miopen.h:7071
MIOPEN_ATTR_MATMUL_PADDING_VALUE
@ MIOPEN_ATTR_MATMUL_PADDING_VALUE
Definition: miopen.h:7178
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
Definition: miopen.h:7138
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
Definition: miopen.h:7133
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
Definition: miopen.h:7092
MIOPEN_ATTR_KNOB_INFO_STRIDE
@ MIOPEN_ATTR_KNOB_INFO_STRIDE
Definition: miopen.h:7167
MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
Definition: miopen.h:7214
MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
Definition: miopen.h:7109
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
Definition: miopen.h:7219
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
Definition: miopen.h:7199
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
Definition: miopen.h:7099
MIOPEN_ATTR_CONVOLUTION_CONV_MODE
@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE
Definition: miopen.h:7057
MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
Definition: miopen.h:7192
MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
Definition: miopen.h:7077
MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
Definition: miopen.h:7123
MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
Definition: miopen.h:7175
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
Definition: miopen.h:7135
MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
Definition: miopen.h:7085
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
Definition: miopen.h:7225
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
Definition: miopen.h:7128
MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
Definition: miopen.h:7113
MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
Definition: miopen.h:7253
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
Definition: miopen.h:7205
MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
Definition: miopen.h:7286
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
Definition: miopen.h:7093
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
Definition: miopen.h:7129
MIOPEN_ATTR_ENGINE_LAYOUT_INFO
@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO
Definition: miopen.h:7173
MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
Definition: miopen.h:7080
MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
Definition: miopen.h:7056
MIOPEN_ATTR_RESAMPLE_COMP_TYPE
@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE
Definition: miopen.h:7209
MIOPEN_ATTR_ENGINECFG_ENGINE
@ MIOPEN_ATTR_ENGINECFG_ENGINE
Definition: miopen.h:7069
MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
Definition: miopen.h:7211
MIOPEN_ATTR_RESAMPLE_PADDING_MODE
@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE
Definition: miopen.h:7216
MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
Definition: miopen.h:7062
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
Definition: miopen.h:7256
MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
Definition: miopen.h:7118
MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
Definition: miopen.h:7249
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
Definition: miopen.h:7125
MIOPEN_ATTR_ENGINE_KNOB_INFO
@ MIOPEN_ATTR_ENGINE_KNOB_INFO
Definition: miopen.h:7171
MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
Definition: miopen.h:7184
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
Definition: miopen.h:7103
MIOPEN_ATTR_TENSOR_REORDERING_MODE
@ MIOPEN_ATTR_TENSOR_REORDERING_MODE
Definition: miopen.h:7153
MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
Definition: miopen.h:7081
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
Definition: miopen.h:7187
MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
Definition: miopen.h:7106
MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
Definition: miopen.h:7278
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
Definition: miopen.h:7082
MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
Definition: miopen.h:7161
MIOPEN_ATTR_ENGINEHEUR_MODE
@ MIOPEN_ATTR_ENGINEHEUR_MODE
Definition: miopen.h:7064
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
Definition: miopen.h:7228
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
Definition: miopen.h:7230
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
Definition: miopen.h:7137
MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
Definition: miopen.h:7108
MIOPEN_ATTR_POINTWISE_MODE
@ MIOPEN_ATTR_POINTWISE_MODE
Definition: miopen.h:7045
MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
Definition: miopen.h:7070
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
Definition: miopen.h:7105
MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
Definition: miopen.h:7270
MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
Definition: miopen.h:7047
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
Definition: miopen.h:7083
MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
Definition: miopen.h:7049
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
Definition: miopen.h:7203
MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
Definition: miopen.h:7281
MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
Definition: miopen.h:7067
MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
Definition: miopen.h:7127
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
Definition: miopen.h:7131
MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
Definition: miopen.h:7277
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
Definition: miopen.h:7196
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
Definition: miopen.h:7197
MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
Definition: miopen.h:7259
MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
Definition: miopen.h:7250
MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
Definition: miopen.h:7120
MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
Definition: miopen.h:7074
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
Definition: miopen.h:7222
MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
Definition: miopen.h:7269
MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
Definition: miopen.h:7266
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
Definition: miopen.h:7094
MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
Definition: miopen.h:7279
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
Definition: miopen.h:7102
MIOPEN_ATTR_TENSOR_STRIDES
@ MIOPEN_ATTR_TENSOR_STRIDES
Definition: miopen.h:7147
MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
Definition: miopen.h:7059
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
Definition: miopen.h:7100
MIOPEN_ATTR_POINTWISE_SWISH_BETA
@ MIOPEN_ATTR_POINTWISE_SWISH_BETA
Definition: miopen.h:7053
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
Definition: miopen.h:7220
MIOPEN_ATTR_OPERATION_REDUCTION_DESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC
Definition: miopen.h:7194
MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
Definition: miopen.h:7247
MIOPEN_ATTR_OPERATION_MATMUL_ADESC
@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC
Definition: miopen.h:7180
MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
Definition: miopen.h:7142
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
Definition: miopen.h:7132
MIOPEN_RNG_DISTRIBUTION_BERNOULLI
@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI
Definition: miopen.h:7514
MIOPEN_RNG_DISTRIBUTION_UNIFORM
@ MIOPEN_RNG_DISTRIBUTION_UNIFORM
Definition: miopen.h:7515
MIOPEN_RNG_DISTRIBUTION_NORMAL
@ MIOPEN_RNG_DISTRIBUTION_NORMAL
Definition: miopen.h:7516
MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
Definition: miopen.h:7012
MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
Definition: miopen.h:7030
MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
Definition: miopen.h:7004
MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
Definition: miopen.h:7028
MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
Definition: miopen.h:7023
MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
Definition: miopen.h:7002
MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
Definition: miopen.h:7025
MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
Definition: miopen.h:7009
MIOPEN_BACKEND_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_RNG_DESCRIPTOR
Definition: miopen.h:7031
MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
Definition: miopen.h:7020
MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
Definition: miopen.h:7019
MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
Definition: miopen.h:7005
MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
Definition: miopen.h:7024
MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
Definition: miopen.h:7010
MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
Definition: miopen.h:7021
MIOPEN_BACKEND_TENSOR_DESCRIPTOR
@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR
Definition: miopen.h:7032
MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
Definition: miopen.h:7022
MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
Definition: miopen.h:7027
MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
Definition: miopen.h:7015
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
Definition: miopen.h:7014
MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
Definition: miopen.h:7007
MIOPEN_BACKEND_ENGINE_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR
Definition: miopen.h:7003
MIOPEN_BACKEND_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR
Definition: miopen.h:7011
MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
Definition: miopen.h:7016
MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
Definition: miopen.h:7033
MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
Definition: miopen.h:7029
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
Definition: miopen.h:7013
MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
Definition: miopen.h:7017
MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
Definition: miopen.h:7018
MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
Definition: miopen.h:7026
MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
Definition: miopen.h:7006
MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
Definition: miopen.h:7008
SCALE
@ SCALE
Definition: miopen.h:7527
BILINEAR
@ BILINEAR
Definition: miopen.h:7528
DEFAULT
@ DEFAULT
Definition: miopen.h:7526
ERROR_STATE
@ ERROR_STATE
Definition: miopen.h:7529
MIOPEN_TYPE_RNG_DISTRIBUTION
@ MIOPEN_TYPE_RNG_DISTRIBUTION
Definition: miopen.h:7328
MIOPEN_TYPE_FLOAT
@ MIOPEN_TYPE_FLOAT
Definition: miopen.h:7303
MIOPEN_TYPE_NUMERICAL_NOTE
@ MIOPEN_TYPE_NUMERICAL_NOTE
Definition: miopen.h:7310
MIOPEN_TYPE_RESAMPLE_MODE
@ MIOPEN_TYPE_RESAMPLE_MODE
Definition: miopen.h:7320
MIOPEN_TYPE_INT32
@ MIOPEN_TYPE_INT32
Definition: miopen.h:7322
MIOPEN_TYPE_POINTWISE_MODE
@ MIOPEN_TYPE_POINTWISE_MODE
Definition: miopen.h:7313
MIOPEN_TYPE_HANDLE
@ MIOPEN_TYPE_HANDLE
Definition: miopen.h:7299
MIOPEN_TYPE_HEUR_MODE
@ MIOPEN_TYPE_HEUR_MODE
Definition: miopen.h:7307
MIOPEN_TYPE_CONVOLUTION_MODE
@ MIOPEN_TYPE_CONVOLUTION_MODE
Definition: miopen.h:7306
MIOPEN_TYPE_TENSOR_REORDERING_MODE
@ MIOPEN_TYPE_TENSOR_REORDERING_MODE
Definition: miopen.h:7319
MIOPEN_TYPE_BOOLEAN
@ MIOPEN_TYPE_BOOLEAN
Definition: miopen.h:7301
MIOPEN_TYPE_NORM_MODE
@ MIOPEN_TYPE_NORM_MODE
Definition: miopen.h:7326
MIOPEN_TYPE_FRACTION
@ MIOPEN_TYPE_FRACTION
Definition: miopen.h:7325
MIOPEN_TYPE_BACKEND_DESCRIPTOR
@ MIOPEN_TYPE_BACKEND_DESCRIPTOR
Definition: miopen.h:7314
MIOPEN_TYPE_ATTRIB_NAME
@ MIOPEN_TYPE_ATTRIB_NAME
Definition: miopen.h:7312
MIOPEN_TYPE_BEHAVIOR_NOTE
@ MIOPEN_TYPE_BEHAVIOR_NOTE
Definition: miopen.h:7318
MIOPEN_TYPE_DATA_TYPE
@ MIOPEN_TYPE_DATA_TYPE
Definition: miopen.h:7300
MIOPEN_TYPE_NAN_PROPOGATION
@ MIOPEN_TYPE_NAN_PROPOGATION
Definition: miopen.h:7309
MIOPEN_TYPE_DOUBLE
@ MIOPEN_TYPE_DOUBLE
Definition: miopen.h:7304
MIOPEN_TYPE_SIGNAL_MODE
@ MIOPEN_TYPE_SIGNAL_MODE
Definition: miopen.h:7324
MIOPEN_TYPE_CHAR
@ MIOPEN_TYPE_CHAR
Definition: miopen.h:7323
MIOPEN_TYPE_PADDING_MODE
@ MIOPEN_TYPE_PADDING_MODE
Definition: miopen.h:7321
MIOPEN_TYPE_INT64
@ MIOPEN_TYPE_INT64
Definition: miopen.h:7302
MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
Definition: miopen.h:7317
MIOPEN_TYPE_LAYOUT_TYPE
@ MIOPEN_TYPE_LAYOUT_TYPE
Definition: miopen.h:7311
MIOPEN_TYPE_GENSTATS_MODE
@ MIOPEN_TYPE_GENSTATS_MODE
Definition: miopen.h:7315
MIOPEN_TYPE_VOID_PTR
@ MIOPEN_TYPE_VOID_PTR
Definition: miopen.h:7305
MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
Definition: miopen.h:7316
MIOPEN_TYPE_KNOB_TYPE
@ MIOPEN_TYPE_KNOB_TYPE
Definition: miopen.h:7308
MIOPEN_TYPE_NORM_FWD_PHASE
@ MIOPEN_TYPE_NORM_FWD_PHASE
Definition: miopen.h:7327
miopenSetLRNDescriptor
miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc, miopenLRNMode_t mode, unsigned int lrnN, double lrnAlpha, double lrnBeta, double lrnK)
Sets a LRN layer descriptor details.
miopenCreateLRNDescriptor
miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t *lrnDesc)
Creates a local response normalization (LRN) layer descriptor.
miopenGetLRNDescriptor
miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc, miopenLRNMode_t *mode, unsigned int *lrnN, double *lrnAlpha, double *lrnBeta, double *lrnK)
Gets a LRN layer descriptor details.
miopenLRNBackward
miopenStatus_t miopenLRNBackward(miopenHandle_t handle, const miopenLRNDescriptor_t lrnDesc, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, const void *workSpace)
Execute a LRN backward layer.
miopenLRNGetWorkSpaceSize
miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)
Determine the workspace requirements.
miopenLRNMode_t
miopenLRNMode_t
Definition: miopen.h:483
miopenLRNForward
miopenStatus_t miopenLRNForward(miopenHandle_t handle, const miopenLRNDescriptor_t lrnDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, bool do_backward, void *workSpace)
Execute a LRN forward layer.
miopenDestroyLRNDescriptor
miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc)
Destroys the LRN descriptor object.
miopenGetCTCLossWorkspaceSize
miopenStatus_t miopenGetCTCLossWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t probsDesc, const miopenTensorDescriptor_t gradientsDesc, const int *labels, const int *labelLengths, const int *inputLengths, miopenCTCLossAlgo_t algo, const miopenCTCLossDescriptor_t ctcLossDesc, size_t *workSpaceSize)
Query the amount of memory required to execute miopenCTCLoss.
miopenGetSoftMarginLossForwardWorkspaceSize
miopenStatus_t miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, miopenTensorDescriptor_t targetDesc, miopenTensorDescriptor_t outputDesc, miopenLossReductionMode_t reduction, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the SoftMarginLossForward call.
miopenLossReductionMode_t
miopenLossReductionMode_t
Definition: miopen.h:8586
miopenGetMultiMarginLossForwardWorkspaceSize
miopenStatus_t miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, miopenTensorDescriptor_t targetDesc, miopenTensorDescriptor_t weightDesc, miopenTensorDescriptor_t outputDesc, long p, float margin, miopenLossReductionMode_t reduction, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the MultiMarginLossForward call.
miopenCTCLossAlgo_t
miopenCTCLossAlgo_t
Definition: miopen.h:5701
miopenSetCTCLossDescriptor
miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc, miopenDataType_t dataType, const int blank_label_id, bool apply_softmax_layer)
Set the details of a CTC loss function descriptor.
miopenCTCLoss
miopenStatus_t miopenCTCLoss(miopenHandle_t handle, const miopenTensorDescriptor_t probsDesc, const void *probs, const int *labels, const int *labelLengths, const int *inputLengths, void *losses, const miopenTensorDescriptor_t gradientsDesc, void *gradients, miopenCTCLossAlgo_t algo, const miopenCTCLossDescriptor_t ctcLossDesc, void *workSpace, size_t workSpaceSize)
Execute forward inference for CTCLoss layer.
miopenGetCTCLossDescriptor
miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc, miopenDataType_t *dataType, int *blank_label_id, bool *apply_softmax_layer)
Retrieves a CTC loss function descriptor's details.
miopenCreateCTCLossDescriptor
miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t *ctcLossDesc)
Create a CTC loss function Descriptor.
miopenMultiMarginLossForward
miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t targetDesc, const void *target, miopenTensorDescriptor_t weightDesc, const void *weight, miopenTensorDescriptor_t outputDesc, void *output, long p, float margin, miopenLossReductionMode_t reduction, void *workspace, size_t workspaceSizeInBytes)
Execute a MultiMarginLoss forward layer.
miopenSoftMarginLossBackward
miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t targetDesc, const void *target, miopenTensorDescriptor_t doutputDesc, const void *doutput, miopenTensorDescriptor_t dinputDesc, void *dinput, miopenLossReductionMode_t reduction)
Execute a SoftMarginLoss backward layer.
miopenSoftMarginLossForward
miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t targetDesc, const void *target, miopenTensorDescriptor_t outputDesc, void *output, miopenLossReductionMode_t reduction, void *workspace=nullptr, size_t workspaceSizeInBytes=0)
Execute a SoftMarginLoss forward layer.
miopenDestroyCTCLossDescriptor
miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc)
Destroys a CTC loss function descriptor object.
MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC
@ MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC
Definition: miopen.h:5702
miopenRNNMode_t
miopenRNNMode_t
Definition: miopen.h:4306
miopenGetRNNDescriptor_V2
miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc, int *hiddenSize, int *layer, miopenDropoutDescriptor_t *dropoutDesc, miopenRNNInputMode_t *inputMode, miopenRNNDirectionMode_t *dirMode, miopenRNNMode_t *rnnMode, miopenRNNBiasMode_t *biasMode, miopenRNNAlgo_t *algoMode, miopenDataType_t *dataType)
Retrieves a RNN layer descriptor's details version 2. This version enables retrieving information of ...
miopenRNNInputMode_t
miopenRNNInputMode_t
Definition: miopen.h:4317
miopenSetRNNLayerBias
miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, void *w, const int biasID, miopenTensorDescriptor_t biasDesc, const void *layerBias)
Sets a bias for a specific layer in an RNN stack.
miopenRNNBackwardWeightsSeqTensor
miopenStatus_t miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const miopenSeqTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t hDesc, const void *hx, const miopenSeqTensorDescriptor_t yDesc, const void *y, void *dw, size_t weightSpaceSize, void *workSpace, size_t workSpaceNumBytes, const void *reserveSpace, size_t reserveSpaceNumBytes)
Execute backward weights for recurrent layer.
miopenGetRNNParamsSize
miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, miopenTensorDescriptor_t xDesc, size_t *numBytes, miopenDataType_t dtype)
Query the amount of parameter memory required for RNN training.
miopenGetRNNLayerBiasOffset
miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, const int biasID, miopenTensorDescriptor_t biasDesc, size_t *layerBiasOffset)
Gets a bias index offset for a specific layer in an RNN stack.
miopenGetRNNLayerParamOffset
miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, const int paramID, miopenTensorDescriptor_t paramDesc, size_t *layerParamOffset)
Gets an index offset for a specific weight matrix for a layer in the RNN stack.
miopenRNNDirectionMode_t
miopenRNNDirectionMode_t
Definition: miopen.h:4339
miopenRNNBackwardSeqData
miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const miopenSeqTensorDescriptor_t yDesc, const void *y, const void *dy, const miopenTensorDescriptor_t hDesc, const void *hx, const void *dhy, void *dhx, const miopenTensorDescriptor_t cDesc, const void *cx, const void *dcy, void *dcx, const miopenSeqTensorDescriptor_t xDesc, void *dx, const void *w, size_t weightSpaceSize, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)
Execute backward data for recurrent layer.
miopenRNNBiasMode_t
miopenRNNBiasMode_t
Definition: miopen.h:4348
miopenGetRNNLayerBias
miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, const void *w, const int biasID, miopenTensorDescriptor_t biasDesc, void *layerBias)
Gets a bias for a specific layer in an RNN stack.
miopenRNNBackwardWeights
miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, const void *x, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t *yDesc, const void *y, const miopenTensorDescriptor_t dwDesc, void *dw, void *workSpace, size_t workSpaceNumBytes, const void *reserveSpace, size_t reserveSpaceNumBytes)
Execute backward weights for recurrent layer.
miopenGetRNNTrainingReserveSize
miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, size_t *numBytes)
Query the amount of memory required for RNN training.
miopenGetRNNLayerBiasSize
miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, const int biasID, size_t *numBytes)
Gets the number of bytes of a bias.
miopenSetRNNDescriptor
miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc, const int hsize, const int nlayers, miopenRNNInputMode_t inMode, miopenRNNDirectionMode_t direction, miopenRNNMode_t rnnMode, miopenRNNBiasMode_t biasMode, miopenRNNAlgo_t algo, miopenDataType_t dataType)
Set the details of the RNN descriptor.
miopenRNNBaseLayout_t
miopenRNNBaseLayout_t
Definition: miopen.h:4383
miopenRNNBackwardData
miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *yDesc, const void *y, const miopenTensorDescriptor_t *dyDesc, const void *dy, const miopenTensorDescriptor_t dhyDesc, const void *dhy, const miopenTensorDescriptor_t dcyDesc, const void *dcy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t cxDesc, const void *cx, const miopenTensorDescriptor_t *dxDesc, void *dx, const miopenTensorDescriptor_t dhxDesc, void *dhx, const miopenTensorDescriptor_t dcxDesc, void *dcx, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)
Execute backward data for recurrent layer.
miopenGetRNNDescriptor
miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc, miopenRNNMode_t *rnnMode, miopenRNNAlgo_t *algoMode, miopenRNNInputMode_t *inputMode, miopenRNNDirectionMode_t *dirMode, miopenRNNBiasMode_t *biasMode, int *hiddenSize, int *layer)
Retrieves a RNN layer descriptor's details.
miopenRNNAlgo_t
miopenRNNAlgo_t
Definition: miopen.h:4326
miopenGetRNNTempSpaceSizes
miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, miopenSeqTensorDescriptor_t xDesc, miopenRNNFWDMode_t fwdMode, size_t *workSpaceSize, size_t *reserveSpaceSize)
Query the amount of additional memory required for this RNN layer execution.
miopenGetRNNPaddingMode
miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc, miopenRNNPaddingMode_t *paddingMode)
This function retrieves the RNN padding mode from the RNN descriptor.
miopenRNNForward
miopenStatus_t miopenRNNForward(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, miopenRNNFWDMode_t fwdMode, const miopenSeqTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t hDesc, const void *hx, void *hy, const miopenTensorDescriptor_t cDesc, const void *cx, void *cy, const miopenSeqTensorDescriptor_t yDesc, void *y, const void *w, size_t weightSpaceSize, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)
Execute forward training for recurrent layer.
miopenGetRNNDataSeqTensorDescriptor
miopenStatus_t miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc, miopenDataType_t *dataType, miopenRNNBaseLayout_t *layout, int *maxSequenceLen, int *batchSize, int *vectorSize, int sequenceLenArrayLimit, int *sequenceLenArray, void *paddingMarker)
Get shape of RNN seqData tensor.
miopenGetRNNInputTensorSize
miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int seqLen, miopenTensorDescriptor_t *xDesc, size_t *numBytes)
Obtain the size in bytes of the RNN input tensor.
miopenRNNFWDMode_t
miopenRNNFWDMode_t
Definition: miopen.h:4374
miopenSetRNNLayerParam
miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, void *w, const int paramID, miopenTensorDescriptor_t paramDesc, const void *layerParam)
Sets a weight matrix for a specific layer in an RNN stack.
miopenGetRNNLayerParamSize
miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, const int paramID, size_t *numBytes)
Gets the number of bytes of a parameter matrix.
miopenCreateRNNDescriptor
miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t *rnnDesc)
Create a RNN layer Descriptor.
miopenRNNGEMMalgoMode_t
miopenRNNGEMMalgoMode_t
Definition: miopen.h:4357
miopenGetRNNLayerParam
miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, const void *w, const int paramID, miopenTensorDescriptor_t paramDesc, void *layerParam)
Gets a weight matrix for a specific layer in an RNN stack.
miopenGetRNNWorkspaceSize
miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, size_t *numBytes)
Query the amount of memory required to execute the RNN layer.
miopenSetRNNDataSeqTensorDescriptor
miopenStatus_t miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc, miopenDataType_t dataType, miopenRNNBaseLayout_t layout, int maxSequenceLen, int batchSize, int vectorSize, const int *sequenceLenArray, void *paddingMarker)
Set shape of RNN seqData tensor.
miopenGetRNNParamsDescriptor
miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, miopenDataType_t dtype)
Obtain a weight tensor descriptor for RNNs.
miopenRNNForwardTraining
miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, const void *x, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t cxDesc, const void *cx, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t *yDesc, void *y, const miopenTensorDescriptor_t hyDesc, void *hy, const miopenTensorDescriptor_t cyDesc, void *cy, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)
Execute forward training for recurrent layer.
miopenRNNPaddingMode_t
miopenRNNPaddingMode_t
Definition: miopen.h:4365
miopenSetRNNDescriptor_V2
miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc, const int hsize, const int nlayers, miopenDropoutDescriptor_t dropoutDesc, miopenRNNInputMode_t inMode, miopenRNNDirectionMode_t direction, miopenRNNMode_t rnnMode, miopenRNNBiasMode_t biasMode, miopenRNNAlgo_t algo, miopenDataType_t dataType)
Set the details of the RNN descriptor version 2. This version enables the use of dropout in rnn.
miopenDestroyRNNDescriptor
miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc)
Destroys the tensor descriptor object.
miopenGetRNNHiddenTensorSize
miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int seqLen, miopenTensorDescriptor_t *xDesc, size_t *numBytes)
Obtain the size in bytes of the RNN hidden tensor.
miopenSetRNNPaddingMode
miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc, miopenRNNPaddingMode_t paddingMode)
Sets a bias for a specific layer in an RNN stack.
miopenRNNForwardInference
miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, const void *x, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t cxDesc, const void *cx, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t *yDesc, void *y, const miopenTensorDescriptor_t hyDesc, void *hy, const miopenTensorDescriptor_t cyDesc, void *cy, void *workSpace, size_t workSpaceNumBytes)
Execute forward inference for RNN layer.
miopenRNNTANH
@ miopenRNNTANH
Definition: miopen.h:4308
miopenLSTM
@ miopenLSTM
Definition: miopen.h:4309
miopenGRU
@ miopenGRU
Definition: miopen.h:4310
miopenRNNRELU
@ miopenRNNRELU
Definition: miopen.h:4307
miopenRNNlinear
@ miopenRNNlinear
Definition: miopen.h:4318
miopenRNNskip
@ miopenRNNskip
Definition: miopen.h:4319
miopenRNNbidirection
@ miopenRNNbidirection
Definition: miopen.h:4341
miopenRNNunidirection
@ miopenRNNunidirection
Definition: miopen.h:4340
miopenRNNwithBias
@ miopenRNNwithBias
Definition: miopen.h:4350
miopenRNNNoBias
@ miopenRNNNoBias
Definition: miopen.h:4349
miopenRNNDataSeqMajorPadded
@ miopenRNNDataSeqMajorPadded
Definition: miopen.h:4386
miopenRNNDataSeqMajorNotPadded
@ miopenRNNDataSeqMajorNotPadded
Definition: miopen.h:4385
miopenRNNDataBatchMajorPadded
@ miopenRNNDataBatchMajorPadded
Definition: miopen.h:4387
miopenRNNDataUnknownLayout
@ miopenRNNDataUnknownLayout
Definition: miopen.h:4384
miopenRNNroundedDynamic
@ miopenRNNroundedDynamic
Definition: miopen.h:4331
miopenRNNfundamental
@ miopenRNNfundamental
Definition: miopen.h:4329
miopenRNNdefault
@ miopenRNNdefault
Definition: miopen.h:4327
miopenRNNTraining
@ miopenRNNTraining
Definition: miopen.h:4375
miopenRNNInference
@ miopenRNNInference
Definition: miopen.h:4376
miopenRNNAlgoGEMM
@ miopenRNNAlgoGEMM
Definition: miopen.h:4358
miopenRNNIOWithPadding
@ miopenRNNIOWithPadding
Definition: miopen.h:4367
miopenRNNIONotPadded
@ miopenRNNIONotPadded
Definition: miopen.h:4366
miopenGetPReLUBackwardWorkspaceSize
miopenStatus_t miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, miopenTensorDescriptor_t weightDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the PReLU backward call.
miopenPReLUBackward
miopenStatus_t miopenPReLUBackward(miopenHandle_t handle, void *workspace, size_t workspaceSizeInBytes, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t weightDesc, const void *weight, miopenTensorDescriptor_t doutputDesc, const void *doutput, miopenTensorDescriptor_t dinputDesc, void *dinput, miopenTensorDescriptor_t dweightDesc, void *dweight)
Execute a PReLU backward layer.
miopenReduceExtremeForward
miopenStatus_t miopenReduceExtremeForward(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const void *x, const int32_t dim, const miopenReduceExtremeOp_t reduceExtremeOp, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t indiceDesc, void *indice)
Find the the extreme (minimum, maximum) value and index of a tensor across Dimension.
miopenReduceExtremeOp_t
miopenReduceExtremeOp_t
Definition: miopen.h:6745
miopenRoPEBackward
miopenStatus_t miopenRoPEBackward(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t cosDesc, const void *cos, const miopenTensorDescriptor_t sinDesc, const void *sin, const miopenTensorDescriptor_t dxDesc, void *dx)
Execute a rope backward layer.
miopenRoPEForward
miopenStatus_t miopenRoPEForward(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t cosDesc, const void *cos, const miopenTensorDescriptor_t sinDesc, const void *sin, const miopenTensorDescriptor_t yDesc, void *y)
Execute a rope forward layer.
miopenFusedAdam
miopenStatus_t miopenFusedAdam(miopenHandle_t handle, const miopenTensorDescriptor_t paramDesc, void *param, const miopenTensorDescriptor_t gradDesc, const void *grad, const miopenTensorDescriptor_t expAvgDesc, void *expAvg, const miopenTensorDescriptor_t expAvgSqDesc, void *expAvgSq, const miopenTensorDescriptor_t maxExpAvgSqDesc, void *maxExpAvgSq, const miopenTensorDescriptor_t stateStepDesc, void *stateStep, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const bool amsgrad, const bool maximize, const bool adamw, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)
Perform Fused Adam optimization for a single tensor (Adaptive Moment Estimation).
miopenTransformersAdamW
miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle, const miopenTensorDescriptor_t paramDesc, void *param, const miopenTensorDescriptor_t gradDesc, const void *grad, const miopenTensorDescriptor_t expAvgDesc, void *expAvg, const miopenTensorDescriptor_t expAvgSqDesc, void *expAvgSq, const miopenTensorDescriptor_t stateStepDesc, void *stateStep, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const bool correct_bias, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)
Implements Adam algorithm with weight decay fix as introduced in Decoupled Weight Decay Regularizatio...
miopenFusedAdamWithOutput
miopenStatus_t miopenFusedAdamWithOutput(miopenHandle_t handle, const miopenTensorDescriptor_t paramInDesc, void *paramIn, const miopenTensorDescriptor_t paramOutDesc, void *paramOut, const miopenTensorDescriptor_t paramOutFloat16Desc, void *paramOutFloat16, const miopenTensorDescriptor_t gradInDesc, const void *gradIn, const miopenTensorDescriptor_t expAvgInDesc, void *expAvgIn, const miopenTensorDescriptor_t expAvgOutDesc, void *expAvgOut, const miopenTensorDescriptor_t expAvgSqInDesc, void *expAvgSqIn, const miopenTensorDescriptor_t expAvgSqOutDesc, void *expAvgSqOut, const miopenTensorDescriptor_t maxExpAvgSqInDesc, void *maxExpAvgSqIn, const miopenTensorDescriptor_t maxExpAvgSqOutDesc, void *maxExpAvgSqOut, const miopenTensorDescriptor_t stateStepInDesc, void *stateStepIn, const miopenTensorDescriptor_t stateStepOutDesc, void *stateStepOut, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const bool amsgrad, const bool maximize, const bool adamw, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)
Execute single tensor Adam optimization and receive the result in a separate output tensor.
miopenTransformersAdamWWithOutput
miopenStatus_t miopenTransformersAdamWWithOutput(miopenHandle_t handle, const miopenTensorDescriptor_t paramInDesc, void *paramIn, const miopenTensorDescriptor_t paramOutDesc, void *paramOut, const miopenTensorDescriptor_t paramOutFloat16Desc, void *paramOutFloat16, const miopenTensorDescriptor_t gradInDesc, const void *gradIn, const miopenTensorDescriptor_t expAvgInDesc, void *expAvgIn, const miopenTensorDescriptor_t expAvgOutDesc, void *expAvgOut, const miopenTensorDescriptor_t expAvgSqInDesc, void *expAvgSqIn, const miopenTensorDescriptor_t expAvgSqOutDesc, void *expAvgSqOut, const miopenTensorDescriptor_t stateStepInDesc, void *stateStepIn, const miopenTensorDescriptor_t stateStepOutDesc, void *stateStepOut, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const float step_size, const bool correct_bias, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)
Execute single tensor Adam optimization and receive the result in a separate output tensor.
miopenReduceTensorIndices_t
miopenReduceTensorIndices_t
Definition: miopen.h:611
miopenSetReduceTensorDescriptor
miopenStatus_t miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc, miopenReduceTensorOp_t reduceTensorOp, miopenDataType_t reduceTensorCompType, miopenNanPropagation_t reduceTensorNanOpt, miopenReduceTensorIndices_t reduceTensorIndices, miopenIndicesType_t reduceTensorIndicesType)
Initialize a ReduceTensor descriptor object.
miopenCreateReduceTensorDescriptor
miopenStatus_t miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t *reduceTensorDesc)
Creates the ReduceTensor descriptor object.
miopenReduceTensorOp_t
miopenReduceTensorOp_t
Definition: miopen.h:576
miopenIndicesType_t
miopenIndicesType_t
Definition: miopen.h:621
miopenReduceTensor
miopenStatus_t miopenReduceTensor(miopenHandle_t handle, const miopenReduceTensorDescriptor_t reduceTensorDesc, void *indices, size_t indicesSizeInBytes, void *workspace, size_t workspaceSizeInBytes, const void *alpha, const miopenTensorDescriptor_t aDesc, const void *A, const void *beta, const miopenTensorDescriptor_t cDesc, void *C)
TensorReduce function doing reduction on tensor A by implementing C = alpha * reduceOp(A)
miopenGetReductionIndicesSize
miopenStatus_t miopenGetReductionIndicesSize(miopenHandle_t handle, const miopenReduceTensorDescriptor_t reduceTensorDesc, const miopenTensorDescriptor_t aDesc, const miopenTensorDescriptor_t cDesc, size_t *sizeInBytes)
Helper function to query the minimum index space size required by the ReduceTensor call.
miopenDestroyReduceTensorDescriptor
miopenStatus_t miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc)
Destroy the ReduceTensor descriptor object.
miopenGetReductionWorkspaceSize
miopenStatus_t miopenGetReductionWorkspaceSize(miopenHandle_t handle, const miopenReduceTensorDescriptor_t reduceTensorDesc, const miopenTensorDescriptor_t aDesc, const miopenTensorDescriptor_t cDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the ReduceTensor call.
miopenGetReduceTensorDescriptor
miopenStatus_t miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc, miopenReduceTensorOp_t *reduceTensorOp, miopenDataType_t *reduceTensorCompType, miopenNanPropagation_t *reduceTensorNanOpt, miopenReduceTensorIndices_t *reduceTensorIndices, miopenIndicesType_t *reduceTensorIndicesType)
Query a ReduceTensor descriptor object.
miopenActivationForward
miopenStatus_t miopenActivationForward(miopenHandle_t handle, const miopenActivationDescriptor_t activDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)
Execute an activation forward layer.
miopenGLUBackward
miopenStatus_t miopenGLUBackward(miopenHandle_t handle, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputGradDesc, const void *outputGrad, const miopenTensorDescriptor_t inputGradDesc, void *inputGrad, const uint32_t dim)
Execute a GLU backward layer.
miopenActivationBackward
miopenStatus_t miopenActivationBackward(miopenHandle_t handle, const miopenActivationDescriptor_t activDesc, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx)
Execute a activation backwards layer.
miopenActivationMode_t
miopenActivationMode_t
Definition: miopen.h:522
miopenSetActivationDescriptor
miopenStatus_t miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc, miopenActivationMode_t mode, double activAlpha, double activBeta, double activGamma)
Sets the activation layer descriptor details.
miopenCreateActivationDescriptor
miopenStatus_t miopenCreateActivationDescriptor(miopenActivationDescriptor_t *activDesc)
Creates the Activation descriptor object.
miopenGetActivationDescriptor
miopenStatus_t miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc, miopenActivationMode_t *mode, double *activAlpha, double *activBeta, double *activGamma)
Gets the activation layer descriptor details.
miopenGLUForward
miopenStatus_t miopenGLUForward(miopenHandle_t handle, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, const uint32_t dim)
Execute a GLU forward layer.
miopenDestroyActivationDescriptor
miopenStatus_t miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc)
Destroys the activation descriptor object.
miopenBatchNormalizationForwardInference
miopenStatus_t miopenBatchNormalizationForwardInference(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon)
Execute forward inference layer for batch normalization.
miopenBatchNormalizationForwardInference_V2
miopenStatus_t miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon)
Execute forward inference layer for batch normalization.
miopenBatchNormForwardTrainingActivation
miopenStatus_t miopenBatchNormForwardTrainingActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, void *resultRunningMean, void *resultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance, const miopenActivationDescriptor_t activDesc)
Execute forward training layer for batch normalization with fused activation.
miopenBatchNormBackwardActivation
miopenStatus_t miopenBatchNormBackwardActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, const void *alphaDataDiff, const void *betaDataDiff, const void *alphaParamDiff, const void *betaParamDiff, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarianceDesc, const void *bnScale, const void *bnBias, void *resultBnScaleDiff, void *resultBnBiasDiff, double epsilon, const void *savedMean, const void *savedInvVariance, const miopenActivationDescriptor_t activDesc)
Execute backwards propagation layer for batch normalization with fused activation.
miopenBatchNormalizationForwardTraining_V3
miopenStatus_t miopenBatchNormalizationForwardTraining_V3(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, const void *prevResultRunningMean, const void *prevResultRunningVariance, void *nextResultRunningMean, void *nextResultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance)
Execute forward training layer for batch normalization.
miopenBatchNormalizationForwardTraining
miopenStatus_t miopenBatchNormalizationForwardTraining(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc, void *bnScale, void *bnBias, double expAvgFactor, void *resultRunningMean, void *resultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance)
Execute forward training layer for batch normalization.
miopenBatchNormalizationForwardTraining_V2
miopenStatus_t miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, void *resultRunningMean, void *resultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance)
Execute forward training layer for batch normalization.
miopenBatchNormalizationBackward_V2
miopenStatus_t miopenBatchNormalizationBackward_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, const void *alphaDataDiff, const void *betaDataDiff, const void *alphaParamDiff, const void *betaParamDiff, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, const void *bnScale, void *resultBnScaleDiff, void *resultBnBiasDiff, double epsilon, const void *savedMean, const void *savedInvVariance)
Execute backwards propagation layer for batch normalization.
miopenBatchNormForwardTrainingActivation_V2
miopenStatus_t miopenBatchNormForwardTrainingActivation_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, const void *prevResultRunningMean, const void *prevResultRunningVariance, void *nextResultRunningMean, void *nextResultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance, const miopenActivationDescriptor_t activDesc)
Execute forward training layer for batch normalization with fused activation.
miopenBatchNormalizationForwardInferenceInvVariance
miopenStatus_t miopenBatchNormalizationForwardInferenceInvVariance(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estInvVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedInvVariance)
Execute forward inference layer for batch normalization using inverse variance.
miopenBatchNormalizationBackward
miopenStatus_t miopenBatchNormalizationBackward(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, const void *alphaDataDiff, const void *betaDataDiff, const void *alphaParamDiff, const void *betaParamDiff, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t bnScaleBiasDiffDesc, const void *bnScale, void *resultBnScaleDiff, void *resultBnBiasDiff, double epsilon, const void *savedMean, const void *savedInvVariance)
Execute backwards propagation layer for batch normalization.
miopenBatchNormMode_t
miopenBatchNormMode_t
Definition: miopen.h:512
miopenBatchNormForwardInferenceActivation
miopenStatus_t miopenBatchNormForwardInferenceActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon, const miopenActivationDescriptor_t activDesc)
Execute forward inference layer for batch normalization with fused activation.
miopenBatchNormForwardInferenceActivationInvVariance
miopenStatus_t miopenBatchNormForwardInferenceActivationInvVariance(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estInvVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedInvVariance, const miopenActivationDescriptor_t activDesc)
Execute forward inference layer for batch normalization with fused activation using inverse variance.
miopenDeriveBNTensorDescriptor
miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc, const miopenTensorDescriptor_t xDesc, miopenBatchNormMode_t bn_mode)
Derive tensor for gamma and beta from input tensor descriptor.
miopenCatForward
miopenStatus_t miopenCatForward(miopenHandle_t handle, const int32_t xCount, const miopenTensorDescriptor_t *xDescs, const void *const *xs, const miopenTensorDescriptor_t yDesc, void *y, const int32_t dim)
Execute a cat forward layer.
miopenInitConvolutionNdDescriptor
miopenStatus_t miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc, int spatialDim, const int *padA, const int *strideA, const int *dilationA, miopenConvolutionMode_t c_mode)
Creates a N-dimensional convolution layer descriptor.
miopenConvolutionForwardImmediate
miopenStatus_t miopenConvolutionForwardImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, void *y, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)
Executes the Forward convolution operation based on the provided solution ID.
miopenConvolutionBackwardDataCompileSolution
miopenStatus_t miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const uint64_t solution_id)
Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionBac...
miopenConvolutionForwardGetSolutionWorkspaceSize
miopenStatus_t miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const uint64_t solution_id, size_t *workSpaceSize)
Returns the workspace size required for a particular solution id.
miopenConvolutionForward
miopenStatus_t miopenConvolutionForward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvFwdAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, void *workSpace, size_t workSpaceSize)
Execute a forward convolution layer.
miopenGetConvolutionGroupCount
miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)
Get the number of groups to be used in Group/Depthwise convolution.
miopenGetConvolutionFindMode
miopenStatus_t miopenGetConvolutionFindMode(const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t *findMode)
Reads the Find Mode attribute from the convolution descriptor.
miopenInitConvolutionDescriptor
miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc, miopenConvolutionMode_t c_mode, int pad_h, int pad_w, int stride_h, int stride_w, int dilation_h, int dilation_w)
Creates a 2-D convolution layer descriptor.
miopenConvAlgorithm_t
miopenConvAlgorithm_t
Definition: miopen.h:1276
miopenConvolutionBackwardData
miopenStatus_t miopenConvolutionBackwardData(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvBwdDataAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace, size_t workSpaceSize)
Execute a backward data convolution layer.
miopenGetConvolutionAttribute
miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc, const miopenConvolutionAttrib_t attr, int *value)
Get the attribute of the convolution descriptor.
miopenGetConvolutionNdForwardOutputDim
miopenStatus_t miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t inputTensorDesc, const miopenTensorDescriptor_t filterDesc, int *nDim, int *outputTensorDimA)
Get the shape of a resulting N-dimensional tensor from a (N-2)-dimensional convolution.
miopenConvolutionBackwardWeightsCompileSolution
miopenStatus_t miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, const uint64_t solution_id)
Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionBac...
miopenFindConvolutionBackwardWeightsAlgorithm
miopenStatus_t miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, void *dw, const int requestAlgoCount, int *returnedAlgoCount, miopenConvAlgoPerf_t *perfResults, void *workSpace, size_t workSpaceSize, bool exhaustiveSearch)
Search and run the backwards weights convolutional algorithms and return a list of kernel times.
miopenGetConvolutionForwardOutputDim
miopenStatus_t miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t inputTensorDesc, const miopenTensorDescriptor_t filterDesc, int *n, int *c, int *h, int *w)
Get the shape of a resulting 4-D tensor from a 2-D convolution.
miopenConvFwdAlgorithm_t
miopenConvFwdAlgorithm_t
Definition: miopen.h:1239
miopenConvolutionForwardGetWorkSpaceSize
miopenStatus_t miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)
Query the workspace size required for a forward convolution algorithm.
miopenCreateConvolutionDescriptor
miopenStatus_t miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t *convDesc)
Creates a convolution layer descriptor.
miopenConvolutionBackwardWeightsGetSolution
miopenStatus_t miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, const size_t maxSolutionCount, size_t *solutionCount, miopenConvSolution_t *solutions)
Query the applicable solutions for a backward convolution w-r-t weights as described by input,...
miopenGetConvolutionNdDescriptor
miopenStatus_t miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc, int requestedSpatialDim, int *spatialDim, int *padA, int *strideA, int *dilationA, miopenConvolutionMode_t *c_mode)
Retrieves a N-dimensional convolution layer descriptor's details.
miopenConvBwdDataAlgorithm_t
miopenConvBwdDataAlgorithm_t
Definition: miopen.h:1262
miopenConvolutionAttrib_t
miopenConvolutionAttrib_t
Definition: miopen.h:633
miopenConvolutionBackwardWeightsGetWorkSpaceSize
miopenStatus_t miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, size_t *workSpaceSize)
Get the GPU memory required for the backward weights convolution algorithm.
miopenConvolutionBackwardWeightsImmediate
miopenStatus_t miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, void *dw, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)
Executes the Backward convolution w-r-t weights operation based on the provided solution ID.
miopenFindConvolutionBackwardDataAlgorithm
miopenStatus_t miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, void *dx, const int requestAlgoCount, int *returnedAlgoCount, miopenConvAlgoPerf_t *perfResults, void *workSpace, size_t workSpaceSize, bool exhaustiveSearch)
Search and run the backwards data convolution algorithms and return a list of kernel times.
miopenConvolutionBackwardDataGetSolution
miopenStatus_t miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const size_t maxSolutionCount, size_t *solutionCount, miopenConvSolution_t *solutions)
Query the applicable solutions for a backward convolution w-r-t data as described by input,...
miopenConvolutionForwardBias
miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t bDesc, const void *b, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)
Calculate element-wise scale and shift of a tensor via a bias tensor.
miopenConvolutionMode_t
miopenConvolutionMode_t
Definition: miopen.h:437
miopenSetConvolutionAttribute
miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc, const miopenConvolutionAttrib_t attr, int value)
Set the attribute of the convolution descriptor.
miopenConvolutionBackwardDataImmediate
miopenStatus_t miopenConvolutionBackwardDataImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)
Executes the Backward convolution w-r-t data operation based on the provided solution ID.
miopenSetTransposeConvNdOutputPadding
miopenStatus_t miopenSetTransposeConvNdOutputPadding(miopenConvolutionDescriptor_t convDesc, int spatialDim, const int *adjA)
Set the output padding to be used in N-dimensional Transpose convolution.
miopenSetConvolutionFindMode
miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t findMode)
Sets the Find Mode attribute in the convolution descriptor.
miopenSetTransposeConvOutputPadding
miopenStatus_t miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w)
Set the output padding to be used in 2-D Transpose convolution.
miopenConvolutionFindMode_t
miopenConvolutionFindMode_t
Definition: miopen.h:662
miopenGetConvolutionSpatialDim
miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc, int *spatialDim)
Retrieves the spatial dimension of a convolution layer descriptor.
miopenConvBwdWeightsAlgorithm_t
miopenConvBwdWeightsAlgorithm_t
Definition: miopen.h:1251
miopenConvolutionForwardCompileSolution
miopenStatus_t miopenConvolutionForwardCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const uint64_t solution_id)
Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionFor...
miopenConvolutionBackwardDataGetSolutionCount
miopenStatus_t miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, size_t *solutionCount)
Query the maximum number of solutions applicable for the given input/output and weights tensor descri...
miopenConvolutionBackwardWeights
miopenStatus_t miopenConvolutionBackwardWeights(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, miopenConvBwdWeightsAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t dwDesc, void *dw, void *workSpace, size_t workSpaceSize)
Execute a backward weights convolution layer.
miopenConvolutionBackwardDataGetWorkSpaceSize
miopenStatus_t miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, size_t *workSpaceSize)
Query the workspace size required for a backward data convolution algorithm.
miopenFindConvolutionForwardAlgorithm
miopenStatus_t miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, void *y, const int requestAlgoCount, int *returnedAlgoCount, miopenConvAlgoPerf_t *perfResults, void *workSpace, size_t workSpaceSize, bool exhaustiveSearch)
Search and run the forward convolutional algorithms and return a list of kernel times.
miopenDestroyConvolutionDescriptor
miopenStatus_t miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc)
Destroys the tensor descriptor object.
miopenConvolutionBackwardWeightsGetSolutionCount
miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, size_t *solutionCount)
Query the maximum number of solutions applicable for the given input/output and weights tensor descri...
miopenSetConvolutionGroupCount
miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int groupCount)
Set the number of groups to be used in Group/Depthwise convolution.
miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize
miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, const uint64_t solution_id, size_t *workSpaceSize)
Returns the workspace size required for a particular solution id.
miopenConvolutionForwardGetSolution
miopenStatus_t miopenConvolutionForwardGetSolution(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const size_t maxSolutionCount, size_t *solutionCount, miopenConvSolution_t *solutions)
Query the applicable solutions for a convolution configuration described by input,...
miopenGetConvolutionDescriptor
miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc, miopenConvolutionMode_t *c_mode, int *pad_h, int *pad_w, int *stride_h, int *stride_w, int *dilation_h, int *dilation_w)
Retrieves a 2-D convolution layer descriptor's details.
miopenConvolutionForwardGetSolutionCount
miopenStatus_t miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, size_t *solutionCount)
Query the maximum number of solutions applicable for the given input/output and weights tensor descri...
miopenConvolutionBackwardDataGetSolutionWorkspaceSize
miopenStatus_t miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const uint64_t solution_id, size_t *workSpaceSize)
Returns the workspace size required for a particular solution id.
miopenConvolutionBackwardBias
miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t dyDesc, const void *dy, const void *beta, const miopenTensorDescriptor_t dbDesc, void *db)
Calculates the gradient with respect to the bias.
miopenConvolutionAlgoDirect
@ miopenConvolutionAlgoDirect
Definition: miopen.h:1278
miopenConvolutionAlgoWinograd
@ miopenConvolutionAlgoWinograd
Definition: miopen.h:1280
miopenConvolutionAlgoFFT
@ miopenConvolutionAlgoFFT
Definition: miopen.h:1279
miopenConvolutionAlgoImplicitGEMM
@ miopenConvolutionAlgoImplicitGEMM
Definition: miopen.h:1281
miopenConvolutionAlgoGEMM
@ miopenConvolutionAlgoGEMM
Definition: miopen.h:1277
miopenConvolutionFwdAlgoFFT
@ miopenConvolutionFwdAlgoFFT
Definition: miopen.h:1242
miopenConvolutionFwdAlgoImplicitGEMM
@ miopenConvolutionFwdAlgoImplicitGEMM
Definition: miopen.h:1244
miopenConvolutionFwdAlgoGEMM
@ miopenConvolutionFwdAlgoGEMM
Definition: miopen.h:1240
miopenConvolutionFwdAlgoWinograd
@ miopenConvolutionFwdAlgoWinograd
Definition: miopen.h:1243
miopenConvolutionFwdAlgoDirect
@ miopenConvolutionFwdAlgoDirect
Definition: miopen.h:1241
miopenTransposeBwdDataAlgoGEMM
@ miopenTransposeBwdDataAlgoGEMM
Definition: miopen.h:1267
miopenConvolutionBwdDataAlgoDirect
@ miopenConvolutionBwdDataAlgoDirect
Definition: miopen.h:1264
miopenConvolutionBwdDataAlgoGEMM
@ miopenConvolutionBwdDataAlgoGEMM
Definition: miopen.h:1263
miopenConvolutionBwdDataAlgoFFT
@ miopenConvolutionBwdDataAlgoFFT
Definition: miopen.h:1265
miopenConvolutionBwdDataAlgoWinograd
@ miopenConvolutionBwdDataAlgoWinograd
Definition: miopen.h:1266
miopenConvolutionBwdDataAlgoImplicitGEMM
@ miopenConvolutionBwdDataAlgoImplicitGEMM
Definition: miopen.h:1269
miopenConvolutionBwdWeightsAlgoGEMM
@ miopenConvolutionBwdWeightsAlgoGEMM
Definition: miopen.h:1252
miopenConvolutionBwdWeightsAlgoWinograd
@ miopenConvolutionBwdWeightsAlgoWinograd
Definition: miopen.h:1254
miopenConvolutionBwdWeightsAlgoDirect
@ miopenConvolutionBwdWeightsAlgoDirect
Definition: miopen.h:1253
miopenConvolutionBwdWeightsAlgoImplicitGEMM
@ miopenConvolutionBwdWeightsAlgoImplicitGEMM
Definition: miopen.h:1255
miopenDestroyDropoutDescriptor
miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)
Destroys the dropout descriptor object.
miopenRNGType_t
miopenRNGType_t
Definition: miopen.h:5821
miopenDropoutGetStatesSize
miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle, size_t *stateSizeInBytes)
Query the amount of memory required to store the states of the random number generators.
miopenDropoutGetReserveSpaceSize
miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc, size_t *reserveSpaceSizeInBytes)
Query the amount of memory required to run dropout.
miopenDropoutForward
miopenStatus_t miopenDropoutForward(miopenHandle_t handle, const miopenDropoutDescriptor_t dropoutDesc, const miopenTensorDescriptor_t noise_shape, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, void *reserveSpace, size_t reserveSpaceSizeInBytes)
Execute forward dropout operation.
miopenGetDropoutDescriptor
miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc, miopenHandle_t handle, float *dropout, void **states, unsigned long long *seed, bool *use_mask, bool *state_evo, miopenRNGType_t *rng_mode)
Get the details of the dropout descriptor.
miopenCreateDropoutDescriptor
miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t *dropoutDesc)
Creates the dropout descriptor object.
miopenDropoutBackward
miopenStatus_t miopenDropoutBackward(miopenHandle_t handle, const miopenDropoutDescriptor_t dropoutDesc, const miopenTensorDescriptor_t noise_shape, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, void *reserveSpace, size_t reserveSpaceSizeInBytes)
Execute backward dropout operation.
miopenRestoreDropoutDescriptor
miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc, miopenHandle_t handle, float dropout, void *states, size_t stateSizeInBytes, unsigned long long seed, bool use_mask, bool state_evo, miopenRNGType_t rng_mode)
Restore the dropout descriptor to a saved state.
miopenSetDropoutDescriptor
miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc, miopenHandle_t handle, float dropout, void *states, size_t stateSizeInBytes, unsigned long long seed, bool use_mask, bool state_evo, miopenRNGType_t rng_mode)
Initialize the dropout descriptor.
MIOPEN_RNG_PSEUDO_XORWOW
@ MIOPEN_RNG_PSEUDO_XORWOW
Definition: miopen.h:5822
miopenFindResultsOrder_t
miopenFindResultsOrder_t
Definition: miopen.h:6252
miopenGetSolutionSolverId
miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution, uint64_t *solverId)
Reads id of the solver referred by the solution.
miopenSetSoftmaxDescriptor
miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc, float alpha, float beta, miopenSoftmaxAlgorithm_t algorithm, miopenSoftmaxMode_t mode)
Sets the softmax descriptor details.
miopenGetSolutionTime
miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float *time)
Reads the time spent to execute the solution the last it was run.
miopenGetMhaDescriptor
miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float *scale)
Gets the Mha descriptor details.
miopenMhaMask_t
miopenMhaMask_t
Initializes a problem object describing a Mha operation.
Definition: miopen.h:6280
miopenSetMhaDescriptor
miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale)
Sets the Mha descriptor details.
miopenSetFindOptionWorkspaceLimit
miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options, size_t value)
Sets the workspace limit find option. Default value is maximum of size_t.
miopenSetFindOptionPreallocatedTensor
miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options, miopenTensorArgumentId_t id, void *buffer)
Attaches a preallocated tensor to find options. If not used, buffers are allocated by MIOpen internal...
miopenCreateSoftmaxProblem
miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t *problem, miopenSoftmaxDescriptor_t operatorDesc, miopenProblemDirection_t direction)
Initializes a problem object describing a softmax operation.
miopenDestroyFindOptions
miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options)
Destroys miopenFindOptions object.
miopenSetFindOptionAttachBinaries
miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options, unsigned attach)
Forces library to attach kernel binaries to solutions for later saving. This allows zero lookup miope...
miopenFuseProblems
miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2)
Fuse two problems into a single one. Problems can be either regular, or fused. No problems are dispos...
miopenGetSolutionSize
miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t *size)
Reads the expected size of a solution.
miopenTensorArgumentId_t
miopenTensorArgumentId_t
Definition: miopen.h:6171
miopenFindSolutions
miopenStatus_t miopenFindSolutions(miopenHandle_t handle, miopenProblem_t problem, miopenFindOptions_t options, miopenSolution_t *solutions, size_t *numSolutions, size_t maxSolutions)
Finds solutions to a problem by running different applicable solutions. Memory is automatically alloc...
miopenSetFindOptionTuning
miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value)
Sets the tuning find option. Default value is zero.
miopenGetSolutionWorkspaceSize
miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution, size_t *workspaceSize)
Reads the amount of workspace required to execute the solution.
miopenSetFindOptionResultsOrder
miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options, miopenFindResultsOrder_t value)
Sets the results order find option. Default value is miopenFindResultsOrderByTime.
miopenRunSolution
miopenStatus_t miopenRunSolution(miopenHandle_t handle, miopenSolution_t solution, size_t nInputs, const miopenTensorArgument_t *tensors, void *workspace, size_t workspaceSize)
Runs the solution using the passed in buffers.
miopenCreateMhaProblem
miopenStatus_t miopenCreateMhaProblem(miopenProblem_t *problem, miopenMhaDescriptor_t operatorDesc, miopenProblemDirection_t direction)
miopenProblemDirection_t
miopenProblemDirection_t
Definition: miopen.h:6158
miopenCreateBatchnormProblem
miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t *problem, miopenBatchNormMode_t mode, bool runningMeanVariance, miopenProblemDirection_t direction)
Initializes a problem object describing an activation operation.
miopenCreateMhaDescriptor
miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t *mhaDesc)
Creates the mha descriptor object.
miopenDestroySolution
miopenStatus_t miopenDestroySolution(miopenSolution_t solution)
Destroys solution object.
miopenLoadSolution
miopenStatus_t miopenLoadSolution(miopenSolution_t *solution, const char *data, size_t size)
Loads solution object from binary data.
miopenSaveSolution
miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char *data)
Saves a solution object as binary data.
miopenGetSolverIdConvAlgorithm
miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId, miopenConvAlgorithm_t *result)
Gets the convolution algorithm implemented by a solver.
miopenSetFindOptionPreallocatedWorkspace
miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options, void *buffer, size_t size)
Attaches the preallocated workspace to find options. Allocated by the library by default.
miopenCreateActivationProblem
miopenStatus_t miopenCreateActivationProblem(miopenProblem_t *problem, miopenActivationDescriptor_t operatorDesc, miopenProblemDirection_t direction)
Initializes a problem object describing an activation operation.
miopenDestroyProblem
miopenStatus_t miopenDestroyProblem(miopenProblem_t problem)
Destroys a problem object.
miopenCreateFindOptions
miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t *options)
Initializes miopenFindOptions object.
miopenGetSoftmaxDescriptor
miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc, float *alpha, float *beta, miopenSoftmaxAlgorithm_t *algorithm, miopenSoftmaxMode_t *mode)
Gets the softmax layer descriptor details.
miopenCreateConvProblem
miopenStatus_t miopenCreateConvProblem(miopenProblem_t *problem, miopenConvolutionDescriptor_t operatorDesc, miopenProblemDirection_t direction)
Initializes a problem object describing a convolution operation.
miopenCreateBiasProblem
miopenStatus_t miopenCreateBiasProblem(miopenProblem_t *problem, miopenProblemDirection_t direction)
Initializes a problem object describing an bias operation.
miopenSetProblemTensorDescriptor
miopenStatus_t miopenSetProblemTensorDescriptor(miopenProblem_t problem, miopenTensorArgumentId_t id, const miopenTensorDescriptor_t descriptor)
Sets a tensor descriptor for the specified argument.
miopenCreateSoftmaxDescriptor
miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t *softmaxDesc)
Creates the Softmax descriptor object.
miopenFindResultsOrderByWorkspaceSize
@ miopenFindResultsOrderByWorkspaceSize
Definition: miopen.h:6254
miopenFindResultsOrderByTime
@ miopenFindResultsOrderByTime
Definition: miopen.h:6253
miopenMhaMaskCausal
@ miopenMhaMaskCausal
Definition: miopen.h:6282
miopenMhaMaskNone
@ miopenMhaMaskNone
Definition: miopen.h:6281
miopenTensorMhaDescaleS
@ miopenTensorMhaDescaleS
Definition: miopen.h:6183
miopenTensorMhaO
@ miopenTensorMhaO
Definition: miopen.h:6189
miopenTensorMhaAmaxDV
@ miopenTensorMhaAmaxDV
Definition: miopen.h:6207
miopenTensorBatchnormScaleDiff
@ miopenTensorBatchnormScaleDiff
Definition: miopen.h:6230
miopenTensorMhaMask
@ miopenTensorMhaMask
Definition: miopen.h:6241
miopenTensorMhaDescaleDS
@ miopenTensorMhaDescaleDS
Definition: miopen.h:6197
miopenTensorMhaDropoutSeed
@ miopenTensorMhaDropoutSeed
Definition: miopen.h:6187
miopenTensorBatchnormSavedMean
@ miopenTensorBatchnormSavedMean
Definition: miopen.h:6227
miopenTensorActivationDY
@ miopenTensorActivationDY
Definition: miopen.h:6215
miopenTensorBatchnormDX
@ miopenTensorBatchnormDX
Definition: miopen.h:6235
miopenTensorMhaDescaleV
@ miopenTensorMhaDescaleV
Definition: miopen.h:6182
miopenTensorMhaK
@ miopenTensorMhaK
Definition: miopen.h:6177
miopenTensorConvolutionX
@ miopenTensorConvolutionX
Definition: miopen.h:6173
miopenTensorMhaAmaxDK
@ miopenTensorMhaAmaxDK
Definition: miopen.h:6206
miopenTensorMhaScaleDS
@ miopenTensorMhaScaleDS
Definition: miopen.h:6198
miopenTensorBatchnormBias
@ miopenTensorBatchnormBias
Definition: miopen.h:6233
miopenTensorMhaM
@ miopenTensorMhaM
Definition: miopen.h:6192
miopenTensorBatchnormRunningMean
@ miopenTensorBatchnormRunningMean
Definition: miopen.h:6225
miopenTensorMhaDropoutProbability
@ miopenTensorMhaDropoutProbability
Definition: miopen.h:6186
miopenTensorSoftmaxY
@ miopenTensorSoftmaxY
Definition: miopen.h:6220
miopenTensorSoftmaxDY
@ miopenTensorSoftmaxDY
Definition: miopen.h:6222
miopenTensorMhaDescaleO
@ miopenTensorMhaDescaleO
Definition: miopen.h:6195
miopenTensorMhaScaleO
@ miopenTensorMhaScaleO
Definition: miopen.h:6185
miopenScalarBatchnormExpAvgFactor
@ miopenScalarBatchnormExpAvgFactor
Definition: miopen.h:6243
miopenTensorBatchnormScale
@ miopenTensorBatchnormScale
Definition: miopen.h:6229
miopenTensorBatchnormRunningVariance
@ miopenTensorBatchnormRunningVariance
Definition: miopen.h:6226
miopenTensorActivationDX
@ miopenTensorActivationDX
Definition: miopen.h:6214
miopenTensorMhaScaleDK
@ miopenTensorMhaScaleDK
Definition: miopen.h:6200
miopenTensorMhaV
@ miopenTensorMhaV
Definition: miopen.h:6179
miopenTensorMhaAmaxS
@ miopenTensorMhaAmaxS
Definition: miopen.h:6191
miopenTensorBatchnormBiasDiff
@ miopenTensorBatchnormBiasDiff
Definition: miopen.h:6234
miopenTensorBatchnormSavedVariance
@ miopenTensorBatchnormSavedVariance
Definition: miopen.h:6228
miopenTensorActivationX
@ miopenTensorActivationX
Definition: miopen.h:6212
miopenTensorMhaScaleDV
@ miopenTensorMhaScaleDV
Definition: miopen.h:6201
miopenTensorMhaAmaxO
@ miopenTensorMhaAmaxO
Definition: miopen.h:6190
miopenScalarBatchnormEpsilon
@ miopenScalarBatchnormEpsilon
Definition: miopen.h:6244
miopenTensorMhaScaleDQ
@ miopenTensorMhaScaleDQ
Definition: miopen.h:6199
miopenTensorSoftmaxDX
@ miopenTensorSoftmaxDX
Definition: miopen.h:6221
miopenTensorMhaAmaxDS
@ miopenTensorMhaAmaxDS
Definition: miopen.h:6208
miopenTensorMhaDV
@ miopenTensorMhaDV
Definition: miopen.h:6204
miopenTensorMhaQ
@ miopenTensorMhaQ
Definition: miopen.h:6178
miopenTensorMhaAmaxDQ
@ miopenTensorMhaAmaxDQ
Definition: miopen.h:6205
miopenTensorConvolutionY
@ miopenTensorConvolutionY
Definition: miopen.h:6175
miopenTensorBatchnormEstimatedMean
@ miopenTensorBatchnormEstimatedMean
Definition: miopen.h:6231
miopenTensorBatchnormDY
@ miopenTensorBatchnormDY
Definition: miopen.h:6236
miopenTensorMhaZInv
@ miopenTensorMhaZInv
Definition: miopen.h:6193
miopenTensorMhaDescaleQ
@ miopenTensorMhaDescaleQ
Definition: miopen.h:6181
miopenTensorMhaBias
@ miopenTensorMhaBias
Definition: miopen.h:6209
miopenTensorBatchnormEstimatedVariance
@ miopenTensorBatchnormEstimatedVariance
Definition: miopen.h:6232
miopenTensorArgumentIsScalar
@ miopenTensorArgumentIsScalar
Definition: miopen.h:6239
miopenTensorArgumentIdInvalid
@ miopenTensorArgumentIdInvalid
Definition: miopen.h:6172
miopenTensorMhaDO
@ miopenTensorMhaDO
Definition: miopen.h:6194
miopenTensorMhaDescaleDO
@ miopenTensorMhaDescaleDO
Definition: miopen.h:6196
miopenTensorConvolutionW
@ miopenTensorConvolutionW
Definition: miopen.h:6174
miopenTensorMhaDescaleK
@ miopenTensorMhaDescaleK
Definition: miopen.h:6180
miopenTensorMhaDropoutOffset
@ miopenTensorMhaDropoutOffset
Definition: miopen.h:6188
miopenTensorBiasY
@ miopenTensorBiasY
Definition: miopen.h:6217
miopenTensorMhaDQ
@ miopenTensorMhaDQ
Definition: miopen.h:6202
miopenTensorSoftmaxX
@ miopenTensorSoftmaxX
Definition: miopen.h:6219
miopenTensorBatchnormY
@ miopenTensorBatchnormY
Definition: miopen.h:6224
miopenTensorMhaScaleS
@ miopenTensorMhaScaleS
Definition: miopen.h:6184
miopenTensorBias
@ miopenTensorBias
Definition: miopen.h:6218
miopenTensorActivationY
@ miopenTensorActivationY
Definition: miopen.h:6213
miopenTensorBatchnormX
@ miopenTensorBatchnormX
Definition: miopen.h:6223
miopenTensorBiasX
@ miopenTensorBiasX
Definition: miopen.h:6216
miopenTensorMhaDK
@ miopenTensorMhaDK
Definition: miopen.h:6203
miopenProblemDirectionBackwardWeights
@ miopenProblemDirectionBackwardWeights
Definition: miopen.h:6161
miopenProblemDirectionInference
@ miopenProblemDirectionInference
Definition: miopen.h:6163
miopenProblemDirectionForward
@ miopenProblemDirectionForward
Definition: miopen.h:6159
miopenProblemDirectionBackward
@ miopenProblemDirectionBackward
Definition: miopen.h:6160
miopenGetGetitemWorkspaceSize
miopenStatus_t miopenGetGetitemWorkspaceSize(miopenHandle_t handle, uint32_t indexCount, const miopenTensorDescriptor_t *indexDescs, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the getitem call.
miopenGetitemBackward
miopenStatus_t miopenGetitemBackward(miopenHandle_t handle, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, uint32_t indexCount, const miopenTensorDescriptor_t *indexDescs, const void *const *indexs, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t errorDesc, void *error, uint32_t dimCount, const int32_t *dims, uint32_t sliceCount, const int32_t *slices, uint32_t offset)
Execute a getitem backward layer.
miopenGroupNormForward
miopenStatus_t miopenGroupNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const uint64_t num_groups, const float epsilon, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)
Execute a groupnorm forward layer.
miopenCreateWithStream
miopenStatus_t miopenCreateWithStream(miopenHandle_t *handle, miopenAcceleratorQueue_t stream)
Create a MIOpen handle with an accelerator stream.
miopenDestroy
miopenStatus_t miopenDestroy(miopenHandle_t handle)
Destroys the MIOpen handle.
miopenTuningPolicy_t
miopenTuningPolicy_t
Definition: miopen.h:8769
miopenGetTuningPolicy
miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t *value)
Get tuning policy from a handle.
miopenDeallocatorFunction
void(* miopenDeallocatorFunction)(void *context, void *memory)
Custom deallocator function.
Definition: miopen.h:166
miopenMathType_t
miopenMathType_t
Definition: miopen.h:124
miopenGetStream
miopenStatus_t miopenGetStream(miopenHandle_t handle, miopenAcceleratorQueue_t *streamID)
Get the previously created accelerator command queue.
miopenEnableProfiling
miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable)
Enable profiling to retrieve kernel time.
miopenGetVersion
miopenStatus_t miopenGetVersion(size_t *major, size_t *minor, size_t *patch)
Method to return version of MIOpen.
miopenSetTuningPolicy
miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t newValue)
Update tuning policy for a specific handle. API alternative for MIOPEN_FIND_ENFORCE environment varia...
miopenStatus_t
miopenStatus_t
Definition: miopen.h:109
miopenSetAllocator
miopenStatus_t miopenSetAllocator(miopenHandle_t handle, miopenAllocatorFunction allocator, miopenDeallocatorFunction deallocator, void *allocatorContext)
Set allocator for previously created miopenHandle.
miopenF8RoundingMode_t
miopenF8RoundingMode_t
Definition: miopen.h:133
miopenAllocatorFunction
void *(* miopenAllocatorFunction)(void *context, size_t sizeBytes)
Custom allocator function.
Definition: miopen.h:156
miopenGetErrorString
const char * miopenGetErrorString(miopenStatus_t error)
Get character string for an error code.
miopenCreate
miopenStatus_t miopenCreate(miopenHandle_t *handle)
Method to create the MIOpen handle object.
miopenGetKernelTime
miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float *time)
Get time for last kernel launched.
miopenSetStream
miopenStatus_t miopenSetStream(miopenHandle_t handle, miopenAcceleratorQueue_t streamID)
Set accelerator command queue previously created.
miopenMathDefault
@ miopenMathDefault
Definition: miopen.h:126
miopenMathPedantic
@ miopenMathPedantic
Definition: miopen.h:127
miopenStatusUnsupportedOp
@ miopenStatusUnsupportedOp
Definition: miopen.h:118
miopenStatusGpuOperationsSkipped
@ miopenStatusGpuOperationsSkipped
Definition: miopen.h:119
miopenStatusUnknownError
@ miopenStatusUnknownError
Definition: miopen.h:117
miopenStatusSuccess
@ miopenStatusSuccess
Definition: miopen.h:110
miopenStatusVersionMismatch
@ miopenStatusVersionMismatch
Definition: miopen.h:120
miopenStatusAllocFailed
@ miopenStatusAllocFailed
Definition: miopen.h:114
miopenStatusNotImplemented
@ miopenStatusNotImplemented
Definition: miopen.h:116
miopenStatusBadParm
@ miopenStatusBadParm
Definition: miopen.h:113
miopenStatusNotInitialized
@ miopenStatusNotInitialized
Definition: miopen.h:111
miopenStatusInternalError
@ miopenStatusInternalError
Definition: miopen.h:115
miopenStatusInvalidValue
@ miopenStatusInvalidValue
Definition: miopen.h:112
miopenF8RoundingModeStandard
@ miopenF8RoundingModeStandard
Definition: miopen.h:134
miopenF8RoundingModeStochastic
@ miopenF8RoundingModeStochastic
Definition: miopen.h:135
miopenKthvalueForward
miopenStatus_t miopenKthvalueForward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t outputDesc, void *output, miopenTensorDescriptor_t indicesDesc, size_t *indices, size_t k, int32_t dim=-1, bool keepDim=false)
Execute a Kthvalue forward layer.
miopenLayerNormForward
miopenStatus_t miopenLayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const float epsilon, const int32_t normalized_dim, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)
Execute a layernorm forward layer.
miopenT5LayerNormBackward
miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle, miopenNormMode_t mode, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t rstdDesc, const void *rstd, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t dwDesc, void *dw)
Execute a T5layernorm backward layer.
miopenLayerNormBackward
miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle, miopenNormMode_t mode, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t meanDesc, const void *mean, const miopenTensorDescriptor_t rstdDesc, const void *rstd, const int32_t normalized_dim, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t dwDesc, void *dw, const miopenTensorDescriptor_t dbDesc, void *db)
Execute a layernorm backward layer.
miopenT5LayerNormForward
miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const float epsilon, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t rstdDesc, void *rstd)
Execute a T5layernorm forward layer.
miopenNormMode_t
miopenNormMode_t
Definition: miopen.h:493
miopenGetLayerNormBackwardWorkspaceSize
miopenStatus_t miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenTensorDescriptor_t weightDesc, const miopenTensorDescriptor_t meanDesc, const miopenTensorDescriptor_t rstdDesc, const int32_t normalized_dim, const miopenTensorDescriptor_t dxDesc, const miopenTensorDescriptor_t dwDesc, const miopenTensorDescriptor_t dbDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the layernorm backward call.
miopenGetT5LayerNormBackwardWorkspaceSize
miopenStatus_t miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenTensorDescriptor_t weightDesc, const miopenTensorDescriptor_t rstdDesc, const miopenTensorDescriptor_t dxDesc, const miopenTensorDescriptor_t dwDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the T5layernorm backward call.
miopenAddLayerNormForward
miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t x2Desc, const void *x2, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const float epsilon, const int32_t normalized_dim, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)
Execute a add and layernorm forward layer.
miopenSet2dPoolingDescriptor
miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc, miopenPoolingMode_t mode, int windowHeight, int windowWidth, int pad_h, int pad_w, int stride_h, int stride_w)
Sets a 2-D pooling layer descriptor details.
miopenSetPoolingWorkSpaceIndexMode
miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index)
Set workspace index mode for pooling layer. The default mode is miopenPoolingWorkSpaceIndexMask.
miopenGetPoolingForwardOutputDim
miopenStatus_t miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t tensorDesc, int *n, int *c, int *h, int *w)
Gets the shape of the output tensor for 2-D pooling.
miopenPoolingGetWorkSpaceSize
miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)
Get the amount of GPU memory required for pooling.
miopenSetNdPoolingDescriptor
miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc, const miopenPoolingMode_t mode, int nbDims, const int *windowDimA, const int *padA, const int *stridesA)
Set details of a N-D pooling layer descriptor.
miopenPoolingForward
miopenStatus_t miopenPoolingForward(miopenHandle_t handle, const miopenPoolingDescriptor_t poolDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, bool do_backward, void *workSpace, size_t workSpaceSize)
Execute a forward pooling layer.
miopenPoolingMode_t
miopenPoolingMode_t
Definition: miopen.h:460
miopenPoolingGetWorkSpaceSizeV2
miopenStatus_t miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)
Get the amount of GPU memory required for pooling.
miopenGetPoolingWorkSpaceIndexMode
miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t *workspace_index)
Get workspace index mode for pooling layer.
miopenIndexType_t
miopenIndexType_t
Definition: miopen.h:413
miopenGetPoolingIndexType
miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t *index_type)
Get the index data type for pooling layer. The index type to any of the miopenIndexType_t sizes; 8,...
miopenPoolingWorkspaceIndexMode_t
miopenPoolingWorkspaceIndexMode_t
Definition: miopen.h:473
miopenGetPoolingNdForwardOutputDim
miopenStatus_t miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t tensorDesc, int dims, int *tensorDimArr)
Gets the shape of the output tensor for N-D pooling.
miopenGetNdPoolingDescriptor
miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc, int nbDimsRequested, miopenPoolingMode_t *mode, int *nbDims, int *windowDimA, int *padA, int *stridesA)
Get details of a N-D pooling layer descriptor.
miopenCreatePoolingDescriptor
miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t *poolDesc)
Creates a pooling layer descriptor.
miopenSetPoolingIndexType
miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t index_type)
Set index data type for pooling layer. The default indexing type is uint8_t. Users can set the index ...
miopenGet2dPoolingDescriptor
miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc, miopenPoolingMode_t *mode, int *windowHeight, int *windowWidth, int *pad_h, int *pad_w, int *stride_h, int *stride_w)
Gets a 2-D pooling layer descriptor details.
miopenDestroyPoolingDescriptor
miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc)
Destroys the pooling descriptor object.
miopenPoolingBackward
miopenStatus_t miopenPoolingBackward(miopenHandle_t handle, const miopenPoolingDescriptor_t poolDesc, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace)
Execute a backward pooling layer.
miopenReduceCalculationForward
miopenStatus_t miopenReduceCalculationForward(miopenHandle_t handle, miopenReduceCalculationNanPropagation_t nanPropagation, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t xDesc, const void *x, const int32_t dim, const miopenReduceCalculationOp_t reduceCalculationOp, const miopenTensorDescriptor_t reduceDesc, void *y)
Execute a reducecalculation forward layer.
miopenReduceCalculationOp_t
miopenReduceCalculationOp_t
Definition: miopen.h:6685
miopenGetReduceCalculationWorkspaceSize
miopenStatus_t miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const int32_t dim, const miopenReduceCalculationOp_t reduceCalculationOp, const miopenTensorDescriptor_t reduceDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the ReduceTensor call.
MIOPEN_REDUCE_CALCULATION_PROD
@ MIOPEN_REDUCE_CALCULATION_PROD
Definition: miopen.h:6686
MIOPEN_REDUCE_CALCULATION_SUM
@ MIOPEN_REDUCE_CALCULATION_SUM
Definition: miopen.h:6688
miopenSoftmaxBackward_V2
miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, miopenSoftmaxAlgorithm_t algorithm, miopenSoftmaxMode_t mode)
Execute a softmax backwards layer with expanded modes and algorithms.
miopenSoftmaxForward
miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)
Execute a softmax forward layer.
miopenSoftmaxForward_V2
miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, miopenSoftmaxAlgorithm_t algorithm, miopenSoftmaxMode_t mode)
Execute a softmax forward layer with expanded modes and algorithms.
miopenSoftmaxBackward
miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx)
Execute a softmax backwards layer.
miopenSoftmaxMode_t
miopenSoftmaxMode_t
Definition: miopen.h:556
miopenSoftmaxAlgorithm_t
miopenSoftmaxAlgorithm_t
Definition: miopen.h:545
miopenDestroySeqTensorDescriptor
miopenStatus_t miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc)
Destroys the sequence data tensor descriptor.
miopenGetTensorDescriptor
miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t *dataType, int *dimsA, int *stridesA)
Get the details of the N-dimensional tensor descriptor.
miopenSetNdTensorDescriptorWithLayout
miopenStatus_t miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, miopenTensorLayout_t tensorLayout, const int *lens, int num_lens)
Set shape of ND tensor with specific layout.
miopenSetTensor
miopenStatus_t miopenSetTensor(miopenHandle_t handle, const miopenTensorDescriptor_t yDesc, void *y, const void *alpha)
Fills a tensor with a single value.
miopenOpTensor
miopenStatus_t miopenOpTensor(miopenHandle_t handle, miopenTensorOp_t tensorOp, const void *alpha1, const miopenTensorDescriptor_t aDesc, const void *A, const void *alpha2, const miopenTensorDescriptor_t bDesc, const void *B, const void *beta, const miopenTensorDescriptor_t cDesc, void *C)
Execute element-wise tensor operations.
miopenGetTensorNumBytes
miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc, size_t *numBytes)
Returns number of bytes associated with tensor descriptor.
miopenGet4dTensorDescriptor
miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t *dataType, int *n, int *c, int *h, int *w, int *nStride, int *cStride, int *hStride, int *wStride)
Get the details of the tensor descriptor.
miopenTensorLayout_t
miopenTensorLayout_t
Definition: miopen.h:396
miopenTransformTensor
miopenStatus_t miopenTransformTensor(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)
Copies one tensor to another tensor with a different layout/scale.
miopenCreateTensorDescriptor
miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t *tensorDesc)
Create a Tensor Descriptor.
miopenSetTensorDescriptorV2
miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int nbDims, const size_t *dimsA, const size_t *stridesA)
Set shape of N-dimensional tensor.
miopenScaleTensor
miopenStatus_t miopenScaleTensor(miopenHandle_t handle, const miopenTensorDescriptor_t yDesc, void *y, const void *alpha)
Scales all elements in a tensor by a single value.
miopenSetTensorCastType
miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc, miopenDataType_t cast_type)
Set the tensor cast type.
miopenSet4dTensorDescriptor
miopenStatus_t miopenSet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w)
Set shape of 4D tensor.
miopenSet4dTensorDescriptorEx
miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w, int nStride, int cStride, int hStride, int wStride)
Set shape and stride of 4D tensor.
miopenDataType_t
miopenDataType_t
Definition: miopen.h:376
miopenCreateSeqTensorDescriptor
miopenStatus_t miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t *tensorDesc)
Create a Tensor Descriptor for sequence data.
miopenTensorOp_t
miopenTensorOp_t
Definition: miopen.h:425
miopenGetTensorDescriptorSize
miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc, int *size)
Set shape of N-dimensional tensor.
miopenDestroyTensorDescriptor
miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc)
Destroys the tensor descriptor.
miopenSetTensorDescriptor
miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int nbDims, const int *dimsA, const int *stridesA)
Set shape of N-dimensional tensor.
miopenPaddingMode_t
miopenPaddingMode_t
Definition: miopen.h:449
miopenPaddingDefault
@ miopenPaddingDefault
Definition: miopen.h:450
miopenPaddingSame
@ miopenPaddingSame
Definition: miopen.h:451
miopenPaddingValid
@ miopenPaddingValid
Definition: miopen.h:452
miopenReduceCalculationNanPropagation_t
miopenReduceCalculationNanPropagation_t
Definition: miopen.h:6669
MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
Definition: miopen.h:6671
MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
Definition: miopen.h:6670
MIOPEN_DECLARE_OBJECT
#define MIOPEN_DECLARE_OBJECT(name)
Definition: miopen.h:79
miopenNanPropagation_t
miopenNanPropagation_t
Definition: miopen.h:601
MIOPEN_PROPAGATE_NAN
@ MIOPEN_PROPAGATE_NAN
Definition: miopen.h:603
MIOPEN_NOT_PROPAGATE_NAN
@ MIOPEN_NOT_PROPAGATE_NAN
Definition: miopen.h:602
MIOPEN_LOSS_REDUCTION_MEAN
@ MIOPEN_LOSS_REDUCTION_MEAN
Definition: miopen.h:8589
MIOPEN_LOSS_REDUCTION_SUM
@ MIOPEN_LOSS_REDUCTION_SUM
Definition: miopen.h:8588
MIOPEN_LOSS_REDUCTION_NONE
@ MIOPEN_LOSS_REDUCTION_NONE
Definition: miopen.h:8587
miopenTuningPolicyDbClean
@ miopenTuningPolicyDbClean
Definition: miopen.h:8775
miopenTuningPolicyDbUpdate
@ miopenTuningPolicyDbUpdate
Definition: miopen.h:8771
miopenTuningPolicyNone
@ miopenTuningPolicyNone
Definition: miopen.h:8770
miopenTuningPolicySearch
@ miopenTuningPolicySearch
Definition: miopen.h:8772
miopenTuningPolicySearchDbUpdate
@ miopenTuningPolicySearchDbUpdate
Definition: miopen.h:8774
miopenPoolingAverage
@ miopenPoolingAverage
Definition: miopen.h:462
miopenPoolingAverageInclusive
@ miopenPoolingAverageInclusive
Definition: miopen.h:463
miopenPoolingMax
@ miopenPoolingMax
Definition: miopen.h:461
miopenTensorCHWN
@ miopenTensorCHWN
Definition: miopen.h:399
miopenTensorNHWC
@ miopenTensorNHWC
Definition: miopen.h:398
miopenTensorNDHWC
@ miopenTensorNDHWC
Definition: miopen.h:405
miopenTensorNCHW
@ miopenTensorNCHW
Definition: miopen.h:397
miopenTensorCHWNc4
@ miopenTensorCHWNc4
Definition: miopen.h:402
miopenTensorNCHWc8
@ miopenTensorNCHWc8
Definition: miopen.h:401
miopenTensorNCDHW
@ miopenTensorNCDHW
Definition: miopen.h:404
miopenTensorCHWNc8
@ miopenTensorCHWNc8
Definition: miopen.h:403
miopenTensorNCHWc4
@ miopenTensorNCHWc4
Definition: miopen.h:400
MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES
@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES
Definition: miopen.h:613
MIOPEN_REDUCE_TENSOR_NO_INDICES
@ MIOPEN_REDUCE_TENSOR_NO_INDICES
Definition: miopen.h:612
miopenActivationLEAKYRELU
@ miopenActivationLEAKYRELU
Definition: miopen.h:532
miopenActivationPASTHRU
@ miopenActivationPASTHRU
Definition: miopen.h:523
miopenActivationABS
@ miopenActivationABS
Definition: miopen.h:528
miopenActivationLOGISTIC
@ miopenActivationLOGISTIC
Definition: miopen.h:524
miopenActivationCLIPPEDRELU
@ miopenActivationCLIPPEDRELU
Definition: miopen.h:530
miopenActivationRELU
@ miopenActivationRELU
Definition: miopen.h:526
miopenActivationPOWER
@ miopenActivationPOWER
Definition: miopen.h:529
miopenActivationELU
@ miopenActivationELU
Definition: miopen.h:534
miopenActivationCLAMP
@ miopenActivationCLAMP
Definition: miopen.h:537
miopenActivationSOFTRELU
@ miopenActivationSOFTRELU
Definition: miopen.h:527
miopenActivationTANH
@ miopenActivationTANH
Definition: miopen.h:525
MIOPEN_REDUCE_TENSOR_MUL
@ MIOPEN_REDUCE_TENSOR_MUL
Definition: miopen.h:578
MIOPEN_REDUCE_TENSOR_MAX
@ MIOPEN_REDUCE_TENSOR_MAX
Definition: miopen.h:582
MIOPEN_REDUCE_TENSOR_AVG
@ MIOPEN_REDUCE_TENSOR_AVG
Definition: miopen.h:586
MIOPEN_REDUCE_TENSOR_NORM1
@ MIOPEN_REDUCE_TENSOR_NORM1
Definition: miopen.h:588
MIOPEN_REDUCE_TENSOR_AMAX
@ MIOPEN_REDUCE_TENSOR_AMAX
Definition: miopen.h:584
MIOPEN_REDUCE_TENSOR_MIN
@ MIOPEN_REDUCE_TENSOR_MIN
Definition: miopen.h:580
MIOPEN_REDUCE_TENSOR_ADD
@ MIOPEN_REDUCE_TENSOR_ADD
Definition: miopen.h:577
MIOPEN_REDUCE_TENSOR_NORM2
@ MIOPEN_REDUCE_TENSOR_NORM2
Definition: miopen.h:590
MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC
@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC
Definition: miopen.h:638
MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE
@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE
Definition: miopen.h:642
MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE
@ MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE
Definition: miopen.h:651
MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL
@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL
Definition: miopen.h:634
miopenIndexUint16
@ miopenIndexUint16
Definition: miopen.h:415
miopenIndexUint64
@ miopenIndexUint64
Definition: miopen.h:417
miopenIndexUint32
@ miopenIndexUint32
Definition: miopen.h:416
miopenIndexUint8
@ miopenIndexUint8
Definition: miopen.h:414
miopenFloat
@ miopenFloat
Definition: miopen.h:378
miopenBFloat8_fnuz
@ miopenBFloat8_fnuz
Definition: miopen.h:386
miopenBFloat16
@ miopenBFloat16
Definition: miopen.h:382
miopenInt8
@ miopenInt8
Definition: miopen.h:380
miopenInt32
@ miopenInt32
Definition: miopen.h:379
miopenHalf
@ miopenHalf
Definition: miopen.h:377
miopenInt64
@ miopenInt64
Definition: miopen.h:387
miopenDouble
@ miopenDouble
Definition: miopen.h:384
miopenFloat8_fnuz
@ miopenFloat8_fnuz
Definition: miopen.h:385
MIOPEN_8BIT_INDICES
@ MIOPEN_8BIT_INDICES
Definition: miopen.h:625
MIOPEN_32BIT_INDICES
@ MIOPEN_32BIT_INDICES
Definition: miopen.h:622
MIOPEN_16BIT_INDICES
@ MIOPEN_16BIT_INDICES
Definition: miopen.h:624
MIOPEN_64BIT_INDICES
@ MIOPEN_64BIT_INDICES
Definition: miopen.h:623
miopenPoolingWorkspaceIndexImage
@ miopenPoolingWorkspaceIndexImage
Definition: miopen.h:475
miopenPoolingWorkspaceIndexMask
@ miopenPoolingWorkspaceIndexMask
Definition: miopen.h:474
miopenDepthwise
@ miopenDepthwise
Definition: miopen.h:441
miopenGroupConv
@ miopenGroupConv
Definition: miopen.h:440
miopenTranspose
@ miopenTranspose
Definition: miopen.h:439
miopenConvolution
@ miopenConvolution
Definition: miopen.h:438
MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD
@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD
Definition: miopen.h:497
MIOPEN_WEIGHT_BIAS
@ MIOPEN_WEIGHT_BIAS
Definition: miopen.h:495
MIOPEN_ELEMENTWISE_AFFINE
@ MIOPEN_ELEMENTWISE_AFFINE
Definition: miopen.h:494
MIOPEN_WEIGHT_BIAS_T5
@ MIOPEN_WEIGHT_BIAS_T5
Definition: miopen.h:503
MIOPEN_ELEMENTWISE_AFFINE_T5
@ MIOPEN_ELEMENTWISE_AFFINE_T5
Definition: miopen.h:501
MIOPEN_WEIGHT_BIAS_FUSED_ADD
@ MIOPEN_WEIGHT_BIAS_FUSED_ADD
Definition: miopen.h:499
MIOPEN_REDUCE_EXTREME_ARGMAX
@ MIOPEN_REDUCE_EXTREME_ARGMAX
Definition: miopen.h:6748
MIOPEN_REDUCE_EXTREME_MIN
@ MIOPEN_REDUCE_EXTREME_MIN
Definition: miopen.h:6750
MIOPEN_REDUCE_EXTREME_MAX
@ MIOPEN_REDUCE_EXTREME_MAX
Definition: miopen.h:6752
MIOPEN_REDUCE_EXTREME_ARGMIN
@ MIOPEN_REDUCE_EXTREME_ARGMIN
Definition: miopen.h:6746
miopenTensorOpMin
@ miopenTensorOpMin
Definition: miopen.h:428
miopenTensorOpAdd
@ miopenTensorOpAdd
Definition: miopen.h:426
miopenTensorOpMul
@ miopenTensorOpMul
Definition: miopen.h:427
miopenTensorOpMax
@ miopenTensorOpMax
Definition: miopen.h:429
miopenBNSpatial
@ miopenBNSpatial
Definition: miopen.h:514
miopenBNPerActivation
@ miopenBNPerActivation
Definition: miopen.h:513
miopenConvolutionFindModeDynamicHybrid
@ miopenConvolutionFindModeDynamicHybrid
Definition: miopen.h:674
miopenConvolutionFindModeDefault
@ miopenConvolutionFindModeDefault
Definition: miopen.h:681
miopenConvolutionFindModeTrustVerifyFull
@ miopenConvolutionFindModeTrustVerifyFull
Definition: miopen.h:680
miopenConvolutionFindModeTrustVerify
@ miopenConvolutionFindModeTrustVerify
Definition: miopen.h:679
miopenConvolutionFindModeHybrid
@ miopenConvolutionFindModeHybrid
Definition: miopen.h:669
miopenConvolutionFindModeFast
@ miopenConvolutionFindModeFast
Definition: miopen.h:665
miopenConvolutionFindModeNormal
@ miopenConvolutionFindModeNormal
Definition: miopen.h:663
miopenLRNWithinChannel
@ miopenLRNWithinChannel
Definition: miopen.h:484
miopenLRNCrossChannel
@ miopenLRNCrossChannel
Definition: miopen.h:485
MIOPEN_SOFTMAX_MODE_INSTANCE
@ MIOPEN_SOFTMAX_MODE_INSTANCE
Definition: miopen.h:557
MIOPEN_SOFTMAX_MODE_CHANNEL
@ MIOPEN_SOFTMAX_MODE_CHANNEL
Definition: miopen.h:558
MIOPEN_SOFTMAX_FAST
@ MIOPEN_SOFTMAX_FAST
Definition: miopen.h:546
MIOPEN_SOFTMAX_ACCURATE
@ MIOPEN_SOFTMAX_ACCURATE
Definition: miopen.h:547
MIOPEN_SOFTMAX_LOG
@ MIOPEN_SOFTMAX_LOG
Definition: miopen.h:548
miopenConvAlgoPerf_t
Perf struct for forward, backward filter, or backward data algorithms.
Definition: miopen.h:1291
miopenConvAlgoPerf_t::fwd_algo
miopenConvFwdAlgorithm_t fwd_algo
Definition: miopen.h:1294
miopenConvAlgoPerf_t::bwd_data_algo
miopenConvBwdDataAlgorithm_t bwd_data_algo
Definition: miopen.h:1298
miopenConvAlgoPerf_t::memory
size_t memory
Definition: miopen.h:1302
miopenConvAlgoPerf_t::bwd_weights_algo
miopenConvBwdWeightsAlgorithm_t bwd_weights_algo
Definition: miopen.h:1295
miopenConvAlgoPerf_t::time
float time
Definition: miopen.h:1301
miopenConvSolution_t
Performance struct for forward, backward filter, or backward data algorithms in immediate mode.
Definition: miopen.h:1315
miopenConvSolution_t::algorithm
miopenConvAlgorithm_t algorithm
Definition: miopen.h:1322
miopenConvSolution_t::solution_id
uint64_t solution_id
Definition: miopen.h:1321
miopenConvSolution_t::workspace_size
size_t workspace_size
Definition: miopen.h:1319
miopenConvSolution_t::time
float time
Definition: miopen.h:1316
miopenTensorArgument_t
Values of a tensor or scalar argument for the miopenRunSolution function.
Definition: miopen.h:6483
miopenTensorArgument_t::id
miopenTensorArgumentId_t id
Definition: miopen.h:6486
miopenTensorArgument_t::buffer
void * buffer
Definition: miopen.h:6496
miopenTensorArgument_t::descriptor
miopenTensorDescriptor_t * descriptor
Definition: miopen.h:6492