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

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

MIOpen: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/latest/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 #ifdef MIOPEN_BETA_API
124 typedef enum
125 {
126  miopenF8RoundingModeStandard = 0,
127  miopenF8RoundingModeStochastic = 1,
128 } miopenF8RoundingMode_t;
129 #endif
130 
138 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);
139 
148 typedef void* (*miopenAllocatorFunction)(void* context, size_t sizeBytes);
149 
158 typedef void (*miopenDeallocatorFunction)(void* context, void* memory);
159 
173 MIOPEN_EXPORT miopenStatus_t miopenGetVersion(size_t* major, size_t* minor, size_t* patch);
174 
183 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);
184 
196 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,
197  miopenAcceleratorQueue_t stream);
198 
205 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);
206 
214 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,
215  miopenAcceleratorQueue_t streamID);
216 
224 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,
225  miopenAcceleratorQueue_t* streamID);
226 
243 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,
244  miopenAllocatorFunction allocator,
245  miopenDeallocatorFunction deallocator,
246  void* allocatorContext);
247 
259 MIOPEN_EXPORT miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float* time);
260 
268 MIOPEN_EXPORT miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable);
270 // CLOSEOUT HANDLE DOXYGEN GROUP
271 
279 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);
280 
288 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);
289 
296 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);
297 
305 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);
306 
314 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);
315 
323 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);
324 
331 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);
332 
336 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);
337 
341 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);
342 
346 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);
347 
351 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);
352 
356 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);
357 
361 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);
362 
367 typedef enum
368 {
369  miopenHalf = 0,
370  miopenFloat = 1,
371  miopenInt32 = 2,
372  miopenInt8 = 3,
373  // miopenInt8x4 = 4, /*!< Pack of 4x Int8 in NCHW_VECT_C format (Support discontinued) */
374  miopenBFloat16 = 5,
376  miopenDouble = 6,
377 #ifdef MIOPEN_BETA_API
378  miopenFloat8 = 7,
379  miopenBFloat8 = 8,
380 #else
381 // miopenReserved1 = 7,
382 // miopenReserved2 = 8,
383 #endif
384  miopenInt64 = 9,
385 } miopenDataType_t;
386 
392 typedef enum
393 {
394  miopenTensorNCHW = 0,
395  miopenTensorNHWC = 1,
396  miopenTensorCHWN = 2,
397  miopenTensorNCHWc4 = 3,
398  miopenTensorNCHWc8 = 4,
399  miopenTensorCHWNc4 = 5,
400  miopenTensorCHWNc8 = 6,
401  miopenTensorNCDHW = 7,
402  miopenTensorNDHWC = 8,
403 } miopenTensorLayout_t;
404 
409 typedef enum
410 {
411  miopenIndexUint8 = 0,
412  miopenIndexUint16 = 1,
413  miopenIndexUint32 = 2,
414  miopenIndexUint64 = 3,
415 } miopenIndexType_t;
416 
421 typedef enum
422 {
423  miopenTensorOpAdd = 0,
424  miopenTensorOpMul = 1,
425  miopenTensorOpMin = 2,
426  miopenTensorOpMax = 3,
427 } miopenTensorOp_t;
428 
433 typedef enum
434 {
435  miopenConvolution = 0,
436  miopenTranspose = 1,
437  miopenGroupConv = 2,
438  miopenDepthwise = 3,
439 } miopenConvolutionMode_t;
440 
445 typedef enum
446 {
447  miopenPaddingDefault = 0,
448  miopenPaddingSame = 1,
449  miopenPaddingValid = 2,
450 } miopenPaddingMode_t;
451 
456 typedef enum
457 {
458  miopenPoolingMax = 0,
459  miopenPoolingAverage = 1,
460  miopenPoolingAverageInclusive = 2,
461 } miopenPoolingMode_t;
462 
469 typedef enum
470 {
471  miopenPoolingWorkspaceIndexMask = 0,
472  miopenPoolingWorkspaceIndexImage = 1,
473 } miopenPoolingWorkspaceIndexMode_t;
474 
479 typedef enum
480 {
481  miopenLRNWithinChannel = 0,
482  miopenLRNCrossChannel = 1,
483 } miopenLRNMode_t;
484 #ifdef MIOPEN_BETA_API
489 typedef enum
490 {
491  MIOPEN_ELEMENTWISE_AFFINE = 0,
492  MIOPEN_WEIGHT_BIAS =
493  1,
494  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =
495  2,
496  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,
498  MIOPEN_ELEMENTWISE_AFFINE_T5 =
499  4,
500  MIOPEN_WEIGHT_BIAS_T5 = 5,
502 } miopenNormMode_t;
503 #endif
508 typedef enum
509 {
510  miopenBNPerActivation = 0,
511  miopenBNSpatial = 1,
512 } miopenBatchNormMode_t;
513 
518 typedef enum
519 {
520  miopenActivationPASTHRU = 0,
521  miopenActivationLOGISTIC = 1,
522  miopenActivationTANH = 2,
523  miopenActivationRELU = 3,
524  miopenActivationSOFTRELU = 4,
525  miopenActivationABS = 5,
526  miopenActivationPOWER = 6,
527  miopenActivationCLIPPEDRELU =
528  7,
529  miopenActivationLEAKYRELU =
530  8,
531  miopenActivationELU =
532  9,
534 } miopenActivationMode_t;
535 
540 typedef enum
541 {
542  MIOPEN_SOFTMAX_FAST = 0,
543  MIOPEN_SOFTMAX_ACCURATE = 1,
544  MIOPEN_SOFTMAX_LOG = 2,
545 } miopenSoftmaxAlgorithm_t;
546 
551 typedef enum
552 {
553  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,
554  MIOPEN_SOFTMAX_MODE_CHANNEL =
555  1,
556 } miopenSoftmaxMode_t;
557 
565 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1
566 
571 typedef enum
572 {
573  MIOPEN_REDUCE_TENSOR_ADD = 0,
574  MIOPEN_REDUCE_TENSOR_MUL =
575  1,
576  MIOPEN_REDUCE_TENSOR_MIN =
577  2,
578  MIOPEN_REDUCE_TENSOR_MAX =
579  3,
580  MIOPEN_REDUCE_TENSOR_AMAX =
581  4,
582  MIOPEN_REDUCE_TENSOR_AVG =
583  5,
584  MIOPEN_REDUCE_TENSOR_NORM1 =
585  6,
586  MIOPEN_REDUCE_TENSOR_NORM2 = 7,
588  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =
589  // 8, /*!< the operation is same as MUL, but does not have the zero values considered */
590 } miopenReduceTensorOp_t;
591 
596 typedef enum
597 {
598  MIOPEN_NOT_PROPAGATE_NAN = 0,
599  MIOPEN_PROPAGATE_NAN = 1,
600 } miopenNanPropagation_t;
601 
606 typedef enum
607 {
608  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,
609  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,
610 } miopenReduceTensorIndices_t;
611 
616 typedef enum
617 {
618  MIOPEN_32BIT_INDICES = 0,
619  MIOPEN_64BIT_INDICES = 1,
620  MIOPEN_16BIT_INDICES = 2,
621  MIOPEN_8BIT_INDICES = 3,
622 } miopenIndicesType_t;
623 
628 typedef enum
629 {
630  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =
631  0,
634  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =
635  1,
637 #ifdef MIOPEN_BETA_API
638  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =
639  2,
643 #else
644 // miopenReserved1 = 2,
645 #endif
646 } miopenConvolutionAttrib_t;
647 
659 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);
660 
673 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(
674  miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w);
675 
686 MIOPEN_EXPORT miopenStatus_t
687 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,
688  miopenDataType_t dataType,
689  miopenTensorLayout_t tensorLayout,
690  const int* lens,
691  int num_lens);
711 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,
712  miopenDataType_t dataType,
713  int n,
714  int c,
715  int h,
716  int w,
717  int nStride,
718  int cStride,
719  int hStride,
720  int wStride);
721 
738 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
739  miopenDataType_t* dataType,
740  int* n,
741  int* c,
742  int* h,
743  int* w,
744  int* nStride,
745  int* cStride,
746  int* hStride,
747  int* wStride);
748 
759 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
760  miopenDataType_t dataType,
761  int nbDims,
762  const int* dimsA,
763  const int* stridesA);
764 
765 #ifdef MIOPEN_BETA_API
768 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,
769  miopenDataType_t dataType,
770  int nbDims,
771  const size_t* dimsA,
772  const size_t* stridesA);
773 #endif
774 
775 #ifdef MIOPEN_BETA_API
785 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,
786  miopenDataType_t cast_type);
787 #endif
788 
797 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,
798  int* size);
799 
808 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
809  miopenDataType_t* dataType,
810  int* dimsA,
811  int* stridesA);
812 
818 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);
819 
826 MIOPEN_EXPORT miopenStatus_t
827 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);
828 
834 MIOPEN_EXPORT miopenStatus_t
835 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);
836 
856 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,
857  miopenTensorOp_t tensorOp,
858  const void* alpha1,
859  const miopenTensorDescriptor_t aDesc,
860  const void* A,
861  const void* alpha2,
862  const miopenTensorDescriptor_t bDesc,
863  const void* B,
864  const void* beta,
865  const miopenTensorDescriptor_t cDesc,
866  void* C);
867 
878 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,
879  const miopenTensorDescriptor_t yDesc,
880  void* y,
881  const void* alpha);
882 
893 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,
894  const miopenTensorDescriptor_t yDesc,
895  void* y,
896  const void* alpha);
897 
904 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,
905  size_t* numBytes);
906 
924 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,
925  const void* alpha,
926  const miopenTensorDescriptor_t xDesc,
927  const void* x,
928  const void* beta,
929  const miopenTensorDescriptor_t yDesc,
930  void* y);
931 
933 // CLOSEOUT TENSOR DOXYGEN GROUP
934 
945 MIOPEN_EXPORT miopenStatus_t
946 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);
947 
963 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
964  miopenConvolutionMode_t c_mode,
965  int pad_h,
966  int pad_w,
967  int stride_h,
968  int stride_w,
969  int dilation_h,
970  int dilation_w);
971 
982 MIOPEN_EXPORT miopenStatus_t
983 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
984  int spatialDim,
985  const int* padA,
986  const int* strideA,
987  const int* dilationA,
988  miopenConvolutionMode_t c_mode);
989 
996 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,
997  int* spatialDim);
998 
1014 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
1015  miopenConvolutionMode_t* c_mode,
1016  int* pad_h,
1017  int* pad_w,
1018  int* stride_h,
1019  int* stride_w,
1020  int* dilation_h,
1021  int* dilation_w);
1022 
1034 MIOPEN_EXPORT miopenStatus_t
1035 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1036  int requestedSpatialDim,
1037  int* spatialDim,
1038  int* padA,
1039  int* strideA,
1040  int* dilationA,
1041  miopenConvolutionMode_t* c_mode);
1042 
1049 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1050  int* groupCount);
1051 
1065 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1066  int groupCount);
1067 
1080 MIOPEN_EXPORT miopenStatus_t
1081 miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w);
1082 
1095 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(
1096  miopenConvolutionDescriptor_t convDesc, int spatialDim, const int* adjA);
1097 
1115 MIOPEN_EXPORT miopenStatus_t
1116 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1117  const miopenTensorDescriptor_t inputTensorDesc,
1118  const miopenTensorDescriptor_t filterDesc,
1119  int* n,
1120  int* c,
1121  int* h,
1122  int* w);
1123 
1137 MIOPEN_EXPORT miopenStatus_t
1138 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1139  const miopenTensorDescriptor_t inputTensorDesc,
1140  const miopenTensorDescriptor_t filterDesc,
1141  int* nDim,
1142  int* outputTensorDimA);
1143 
1149 MIOPEN_EXPORT miopenStatus_t
1150 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);
1151 
1158 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1159  const miopenConvolutionAttrib_t attr,
1160  int value);
1161 
1168 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1169  const miopenConvolutionAttrib_t attr,
1170  int* value);
1171 
1176 typedef enum
1177 {
1178  miopenConvolutionFwdAlgoGEMM = 0,
1179  miopenConvolutionFwdAlgoDirect = 1,
1180  miopenConvolutionFwdAlgoFFT = 2,
1181  miopenConvolutionFwdAlgoWinograd = 3,
1182  miopenConvolutionFwdAlgoImplicitGEMM = 5,
1183 } miopenConvFwdAlgorithm_t;
1184 
1188 typedef enum
1189 {
1190  miopenConvolutionBwdWeightsAlgoGEMM = 0,
1191  miopenConvolutionBwdWeightsAlgoDirect = 1,
1192  miopenConvolutionBwdWeightsAlgoWinograd = 3,
1193  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,
1194 } miopenConvBwdWeightsAlgorithm_t;
1195 
1199 typedef enum
1200 {
1201  miopenConvolutionBwdDataAlgoGEMM = 0,
1202  miopenConvolutionBwdDataAlgoDirect = 1,
1203  miopenConvolutionBwdDataAlgoFFT = 2,
1204  miopenConvolutionBwdDataAlgoWinograd = 3,
1205  miopenTransposeBwdDataAlgoGEMM =
1206  4,
1207  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,
1208 } miopenConvBwdDataAlgorithm_t;
1209 
1213 typedef enum
1214 {
1215  miopenConvolutionAlgoGEMM = 0,
1216  miopenConvolutionAlgoDirect = 1,
1217  miopenConvolutionAlgoFFT = 2,
1218  miopenConvolutionAlgoWinograd = 3,
1219  miopenConvolutionAlgoImplicitGEMM = 5,
1220 } miopenConvAlgorithm_t;
1221 
1228 typedef struct
1229 {
1230  union
1231  {
1232  miopenConvFwdAlgorithm_t fwd_algo;
1233  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;
1235  miopenConvBwdDataAlgorithm_t
1236  bwd_data_algo;
1237  };
1238 
1239  float time;
1240  size_t memory;
1242 } miopenConvAlgoPerf_t;
1243 
1252 typedef struct
1253 {
1254  float time;
1257  size_t workspace_size;
1259  uint64_t solution_id;
1260  miopenConvAlgorithm_t algorithm;
1262 } miopenConvSolution_t;
1263 
1279 MIOPEN_EXPORT miopenStatus_t
1280 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,
1281  const miopenTensorDescriptor_t wDesc,
1282  const miopenTensorDescriptor_t xDesc,
1283  const miopenConvolutionDescriptor_t convDesc,
1284  const miopenTensorDescriptor_t yDesc,
1285  size_t* solutionCount);
1286 
1310 MIOPEN_EXPORT miopenStatus_t
1311 miopenConvolutionForwardGetSolution(miopenHandle_t handle,
1312  const miopenTensorDescriptor_t wDesc,
1313  const miopenTensorDescriptor_t xDesc,
1314  const miopenConvolutionDescriptor_t convDesc,
1315  const miopenTensorDescriptor_t yDesc,
1316  const size_t maxSolutionCount,
1317  size_t* solutionCount,
1318  miopenConvSolution_t* solutions);
1319 
1337 MIOPEN_EXPORT miopenStatus_t
1338 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,
1339  const miopenTensorDescriptor_t wDesc,
1340  const miopenTensorDescriptor_t xDesc,
1341  const miopenConvolutionDescriptor_t convDesc,
1342  const miopenTensorDescriptor_t yDesc,
1343  const uint64_t solution_id,
1344  size_t* workSpaceSize);
1345 
1363 MIOPEN_EXPORT miopenStatus_t
1364 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,
1365  const miopenTensorDescriptor_t wDesc,
1366  const miopenTensorDescriptor_t xDesc,
1367  const miopenConvolutionDescriptor_t convDesc,
1368  const miopenTensorDescriptor_t yDesc,
1369  const uint64_t solution_id);
1370 
1388 MIOPEN_EXPORT miopenStatus_t
1389 miopenConvolutionForwardImmediate(miopenHandle_t handle,
1390  const miopenTensorDescriptor_t wDesc,
1391  const void* w,
1392  const miopenTensorDescriptor_t xDesc,
1393  const void* x,
1394  const miopenConvolutionDescriptor_t convDesc,
1395  const miopenTensorDescriptor_t yDesc,
1396  void* y,
1397  void* workSpace,
1398  size_t workSpaceSize,
1399  const uint64_t solution_id);
1400 
1418 MIOPEN_EXPORT miopenStatus_t
1419 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,
1420  const miopenTensorDescriptor_t dyDesc,
1421  const miopenTensorDescriptor_t wDesc,
1422  const miopenConvolutionDescriptor_t convDesc,
1423  const miopenTensorDescriptor_t dxDesc,
1424  size_t* solutionCount);
1425 
1450 MIOPEN_EXPORT miopenStatus_t
1451 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,
1452  const miopenTensorDescriptor_t dyDesc,
1453  const miopenTensorDescriptor_t wDesc,
1454  const miopenConvolutionDescriptor_t convDesc,
1455  const miopenTensorDescriptor_t dxDesc,
1456  const size_t maxSolutionCount,
1457  size_t* solutionCount,
1458  miopenConvSolution_t* solutions);
1459 
1477 MIOPEN_EXPORT miopenStatus_t
1478 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,
1479  const miopenTensorDescriptor_t dyDesc,
1480  const miopenTensorDescriptor_t wDesc,
1481  const miopenConvolutionDescriptor_t convDesc,
1482  const miopenTensorDescriptor_t dxDesc,
1483  const uint64_t solution_id,
1484  size_t* workSpaceSize);
1485 
1504 MIOPEN_EXPORT miopenStatus_t
1505 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,
1506  const miopenTensorDescriptor_t dyDesc,
1507  const miopenTensorDescriptor_t wDesc,
1508  const miopenConvolutionDescriptor_t convDesc,
1509  const miopenTensorDescriptor_t dxDesc,
1510  const uint64_t solution_id);
1511 
1529 MIOPEN_EXPORT miopenStatus_t
1530 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,
1531  const miopenTensorDescriptor_t dyDesc,
1532  const void* dy,
1533  const miopenTensorDescriptor_t wDesc,
1534  const void* w,
1535  const miopenConvolutionDescriptor_t convDesc,
1536  const miopenTensorDescriptor_t dxDesc,
1537  void* dx,
1538  void* workSpace,
1539  size_t workSpaceSize,
1540  const uint64_t solution_id);
1541 
1559 MIOPEN_EXPORT miopenStatus_t
1560 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,
1561  const miopenTensorDescriptor_t dyDesc,
1562  const miopenTensorDescriptor_t xDesc,
1563  const miopenConvolutionDescriptor_t convDesc,
1564  const miopenTensorDescriptor_t dwDesc,
1565  size_t* solutionCount);
1566 
1590 MIOPEN_EXPORT miopenStatus_t
1591 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,
1592  const miopenTensorDescriptor_t dyDesc,
1593  const miopenTensorDescriptor_t xDesc,
1594  const miopenConvolutionDescriptor_t convDesc,
1595  const miopenTensorDescriptor_t dwDesc,
1596  const size_t maxSolutionCount,
1597  size_t* solutionCount,
1598  miopenConvSolution_t* solutions);
1599 
1617 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(
1618  miopenHandle_t handle,
1619  const miopenTensorDescriptor_t dyDesc,
1620  const miopenTensorDescriptor_t xDesc,
1621  const miopenConvolutionDescriptor_t convDesc,
1622  const miopenTensorDescriptor_t dwDesc,
1623  const uint64_t solution_id,
1624  size_t* workSpaceSize);
1625 
1643 MIOPEN_EXPORT miopenStatus_t
1644 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,
1645  const miopenTensorDescriptor_t dyDesc,
1646  const miopenTensorDescriptor_t xDesc,
1647  const miopenConvolutionDescriptor_t convDesc,
1648  const miopenTensorDescriptor_t dwDesc,
1649  const uint64_t solution_id);
1650 
1669 MIOPEN_EXPORT miopenStatus_t
1670 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,
1671  const miopenTensorDescriptor_t dyDesc,
1672  const void* dy,
1673  const miopenTensorDescriptor_t xDesc,
1674  const void* x,
1675  const miopenConvolutionDescriptor_t convDesc,
1676  const miopenTensorDescriptor_t dwDesc,
1677  void* dw,
1678  void* workSpace,
1679  size_t workSpaceSize,
1680  const uint64_t solution_id);
1681 
1708 MIOPEN_EXPORT miopenStatus_t
1709 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,
1710  const miopenTensorDescriptor_t wDesc,
1711  const miopenTensorDescriptor_t xDesc,
1712  const miopenConvolutionDescriptor_t convDesc,
1713  const miopenTensorDescriptor_t yDesc,
1714  size_t* workSpaceSize);
1715 
1759 MIOPEN_EXPORT miopenStatus_t
1760 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,
1761  const miopenTensorDescriptor_t xDesc,
1762  const void* x,
1763  const miopenTensorDescriptor_t wDesc,
1764  const void* w,
1765  const miopenConvolutionDescriptor_t convDesc,
1766  const miopenTensorDescriptor_t yDesc,
1767  void* y,
1768  const int requestAlgoCount,
1769  int* returnedAlgoCount,
1770  miopenConvAlgoPerf_t* perfResults,
1771  void* workSpace,
1772  size_t workSpaceSize,
1773  bool exhaustiveSearch);
1774 
1809 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,
1810  const void* alpha,
1811  const miopenTensorDescriptor_t xDesc,
1812  const void* x,
1813  const miopenTensorDescriptor_t wDesc,
1814  const void* w,
1815  const miopenConvolutionDescriptor_t convDesc,
1816  miopenConvFwdAlgorithm_t algo,
1817  const void* beta,
1818  const miopenTensorDescriptor_t yDesc,
1819  void* y,
1820  void* workSpace,
1821  size_t workSpaceSize);
1822 
1838 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,
1839  const void* alpha,
1840  const miopenTensorDescriptor_t bDesc,
1841  const void* b,
1842  const void* beta,
1843  const miopenTensorDescriptor_t yDesc,
1844  void* y);
1845 
1873 MIOPEN_EXPORT miopenStatus_t
1874 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,
1875  const miopenTensorDescriptor_t dyDesc,
1876  const miopenTensorDescriptor_t wDesc,
1877  const miopenConvolutionDescriptor_t convDesc,
1878  const miopenTensorDescriptor_t dxDesc,
1879  size_t* workSpaceSize);
1880 
1924 MIOPEN_EXPORT miopenStatus_t
1925 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,
1926  const miopenTensorDescriptor_t dyDesc,
1927  const void* dy,
1928  const miopenTensorDescriptor_t wDesc,
1929  const void* w,
1930  const miopenConvolutionDescriptor_t convDesc,
1931  const miopenTensorDescriptor_t dxDesc,
1932  void* dx,
1933  const int requestAlgoCount,
1934  int* returnedAlgoCount,
1935  miopenConvAlgoPerf_t* perfResults,
1936  void* workSpace,
1937  size_t workSpaceSize,
1938  bool exhaustiveSearch);
1939 
1973 MIOPEN_EXPORT miopenStatus_t
1974 miopenConvolutionBackwardData(miopenHandle_t handle,
1975  const void* alpha,
1976  const miopenTensorDescriptor_t dyDesc,
1977  const void* dy,
1978  const miopenTensorDescriptor_t wDesc,
1979  const void* w,
1980  const miopenConvolutionDescriptor_t convDesc,
1981  miopenConvBwdDataAlgorithm_t algo,
1982  const void* beta,
1983  const miopenTensorDescriptor_t dxDesc,
1984  void* dx,
1985  void* workSpace,
1986  size_t workSpaceSize);
1987 
2015 MIOPEN_EXPORT miopenStatus_t
2016 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,
2017  const miopenTensorDescriptor_t dyDesc,
2018  const miopenTensorDescriptor_t xDesc,
2019  const miopenConvolutionDescriptor_t convDesc,
2020  const miopenTensorDescriptor_t dwDesc,
2021  size_t* workSpaceSize);
2022 
2066 MIOPEN_EXPORT miopenStatus_t
2067 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,
2068  const miopenTensorDescriptor_t dyDesc,
2069  const void* dy,
2070  const miopenTensorDescriptor_t xDesc,
2071  const void* x,
2072  const miopenConvolutionDescriptor_t convDesc,
2073  const miopenTensorDescriptor_t dwDesc,
2074  void* dw,
2075  const int requestAlgoCount,
2076  int* returnedAlgoCount,
2077  miopenConvAlgoPerf_t* perfResults,
2078  void* workSpace,
2079  size_t workSpaceSize,
2080  bool exhaustiveSearch);
2081 
2115 MIOPEN_EXPORT miopenStatus_t
2116 miopenConvolutionBackwardWeights(miopenHandle_t handle,
2117  const void* alpha,
2118  const miopenTensorDescriptor_t dyDesc,
2119  const void* dy,
2120  const miopenTensorDescriptor_t xDesc,
2121  const void* x,
2122  const miopenConvolutionDescriptor_t convDesc,
2123  miopenConvBwdWeightsAlgorithm_t algo,
2124  const void* beta,
2125  const miopenTensorDescriptor_t dwDesc,
2126  void* dw,
2127  void* workSpace,
2128  size_t workSpaceSize);
2129 
2145 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,
2146  const void* alpha,
2147  const miopenTensorDescriptor_t dyDesc,
2148  const void* dy,
2149  const void* beta,
2150  const miopenTensorDescriptor_t dbDesc,
2151  void* db);
2152 
2154 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP
2155 
2156 // Pooling APIs
2167 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);
2168 
2177 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2178  miopenIndexType_t index_type);
2179 
2187 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2188  miopenIndexType_t* index_type);
2189 
2197 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(
2198  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);
2199 
2206 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(
2207  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);
2208 
2223 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2224  miopenPoolingMode_t mode,
2225  int windowHeight,
2226  int windowWidth,
2227  int pad_h,
2228  int pad_w,
2229  int stride_h,
2230  int stride_w);
2231 
2246 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2247  miopenPoolingMode_t* mode,
2248  int* windowHeight,
2249  int* windowWidth,
2250  int* pad_h,
2251  int* pad_w,
2252  int* stride_h,
2253  int* stride_w);
2254 
2269 MIOPEN_EXPORT miopenStatus_t
2270 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2271  const miopenTensorDescriptor_t tensorDesc,
2272  int* n,
2273  int* c,
2274  int* h,
2275  int* w);
2276 
2292 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2293  const miopenPoolingMode_t mode,
2294  int nbDims,
2295  const int* windowDimA,
2296  const int* padA,
2297  const int* stridesA);
2298 
2315 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2316  int nbDimsRequested,
2317  miopenPoolingMode_t* mode,
2318  int* nbDims,
2319  int* windowDimA,
2320  int* padA,
2321  int* stridesA);
2322 
2335 MIOPEN_EXPORT miopenStatus_t
2336 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2337  const miopenTensorDescriptor_t tensorDesc,
2338  int dims,
2339  int* tensorDimArr);
2340 
2353 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2354  size_t* workSpaceSize);
2355 
2368 MIOPEN_EXPORT miopenStatus_t
2369 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,
2370  const miopenTensorDescriptor_t yDesc,
2371  size_t* workSpaceSize);
2372 
2393 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,
2394  const miopenPoolingDescriptor_t poolDesc,
2395  const void* alpha,
2396  const miopenTensorDescriptor_t xDesc,
2397  const void* x,
2398  const void* beta,
2399  const miopenTensorDescriptor_t yDesc,
2400  void* y,
2401  bool do_backward,
2402  void* workSpace,
2403  size_t workSpaceSize);
2404 
2425 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,
2426  const miopenPoolingDescriptor_t poolDesc,
2427  const void* alpha,
2428  const miopenTensorDescriptor_t yDesc,
2429  const void* y,
2430  const miopenTensorDescriptor_t dyDesc,
2431  const void* dy,
2432  const miopenTensorDescriptor_t xDesc,
2433  const void* x,
2434  const void* beta,
2435  const miopenTensorDescriptor_t dxDesc,
2436  void* dx,
2437  void* workSpace);
2438 
2444 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);
2445 
2447 // CLOSEOUT POOLING DOXYGEN GROUP
2448 
2449 // LRN APIs
2459 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);
2460 
2474 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2475  miopenLRNMode_t mode,
2476  unsigned int lrnN,
2477  double lrnAlpha,
2478  double lrnBeta,
2479  double lrnK);
2480 
2493 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2494  miopenLRNMode_t* mode,
2495  unsigned int* lrnN,
2496  double* lrnAlpha,
2497  double* lrnBeta,
2498  double* lrnK);
2499 
2509 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2510  size_t* workSpaceSize);
2511 
2530 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,
2531  const miopenLRNDescriptor_t lrnDesc,
2532  const void* alpha,
2533  const miopenTensorDescriptor_t xDesc,
2534  const void* x,
2535  const void* beta,
2536  const miopenTensorDescriptor_t yDesc,
2537  void* y,
2538  bool do_backward,
2539  void* workSpace);
2540 
2558 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,
2559  const miopenLRNDescriptor_t lrnDesc,
2560  const void* alpha,
2561  const miopenTensorDescriptor_t yDesc,
2562  const void* y,
2563  const miopenTensorDescriptor_t dyDesc,
2564  const void* dy,
2565  const miopenTensorDescriptor_t xDesc,
2566  const void* x,
2567  const void* beta,
2568  const miopenTensorDescriptor_t dxDesc,
2569  void* dx,
2570  const void* workSpace);
2571 
2577 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);
2578 
2580 // CLOSEOUT LRN DOXYGEN GROUP
2581 
2582 #ifdef MIOPEN_BETA_API
2583 // LayerNorm APIs
2608 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,
2609  miopenNormMode_t mode,
2610  const miopenTensorDescriptor_t xDesc,
2611  const void* x,
2612  const miopenTensorDescriptor_t weightDesc,
2613  const void* weight,
2614  const miopenTensorDescriptor_t biasDesc,
2615  const void* bias,
2616  const float epsilon,
2617  const int32_t normalized_dim,
2618  const miopenTensorDescriptor_t yDesc,
2619  void* y,
2620  const miopenTensorDescriptor_t meanDesc,
2621  void* mean,
2622  const miopenTensorDescriptor_t rstdDesc,
2623  void* rstd);
2624 
2626 // CLOSEOUT LAYERNORM DOXYGEN GROUP
2627 #endif
2628 
2629 #ifdef MIOPEN_BETA_API
2630 // Cat APIs
2646 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,
2647  const int32_t xCount,
2648  const miopenTensorDescriptor_t* xDescs,
2649  const void* const* xs,
2650  const miopenTensorDescriptor_t yDesc,
2651  void* y,
2652  const int32_t dim);
2653 
2655 // CLOSEOUT CAT DOXYGEN GROUP
2656 #endif
2657 
2658 // Batch-Normalization APIs
2680 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,
2681  const miopenTensorDescriptor_t xDesc,
2682  miopenBatchNormMode_t bn_mode);
2683 
2722 MIOPEN_EXPORT miopenStatus_t
2723 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,
2724  miopenBatchNormMode_t bn_mode,
2725  void* alpha,
2726  void* beta,
2727  const miopenTensorDescriptor_t xDesc,
2728  const void* x,
2729  const miopenTensorDescriptor_t yDesc,
2730  void* y,
2731  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
2732  void* bnScale,
2733  void* bnBias,
2734  double expAvgFactor,
2735  void* resultRunningMean,
2736  void* resultRunningVariance,
2737  double epsilon,
2738  void* resultSaveMean,
2739  void* resultSaveInvVariance);
2780 MIOPEN_EXPORT miopenStatus_t
2781 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,
2782  miopenBatchNormMode_t bn_mode,
2783  void* alpha,
2784  void* beta,
2785  const miopenTensorDescriptor_t xDesc,
2786  const void* x,
2787  const miopenTensorDescriptor_t yDesc,
2788  void* y,
2789  const miopenTensorDescriptor_t scaleDesc,
2790  const miopenTensorDescriptor_t biasVarDesc,
2791  const miopenTensorDescriptor_t savedMeanDesc,
2792  const miopenTensorDescriptor_t savedVarDesc,
2793  void* bnScale,
2794  void* bnBias,
2795  double expAvgFactor,
2796  void* resultRunningMean,
2797  void* resultRunningVariance,
2798  double epsilon,
2799  void* resultSaveMean,
2800  void* resultSaveInvVariance);
2801 
2831 MIOPEN_EXPORT miopenStatus_t
2832 miopenBatchNormalizationForwardInference(miopenHandle_t handle,
2833  miopenBatchNormMode_t bn_mode,
2834  void* alpha,
2835  void* beta,
2836  const miopenTensorDescriptor_t xDesc,
2837  const void* x,
2838  const miopenTensorDescriptor_t yDesc,
2839  void* y,
2840  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
2841  void* bnScale,
2842  void* bnBias,
2843  void* estimatedMean,
2844  void* estimatedVariance,
2845  double epsilon);
2846 
2878 MIOPEN_EXPORT miopenStatus_t
2879 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,
2880  miopenBatchNormMode_t bn_mode,
2881  void* alpha,
2882  void* beta,
2883  const miopenTensorDescriptor_t xDesc,
2884  const void* x,
2885  const miopenTensorDescriptor_t yDesc,
2886  void* y,
2887  const miopenTensorDescriptor_t scaleDesc,
2888  const miopenTensorDescriptor_t biasDesc,
2889  const miopenTensorDescriptor_t estMeanDesc,
2890  const miopenTensorDescriptor_t estVarianceDesc,
2891  void* bnScale,
2892  void* bnBias,
2893  void* estimatedMean,
2894  void* estimatedVariance,
2895  double epsilon);
2896 
2931 MIOPEN_EXPORT miopenStatus_t
2932 miopenBatchNormalizationBackward(miopenHandle_t handle,
2933  miopenBatchNormMode_t bn_mode,
2934  const void* alphaDataDiff,
2935  const void* betaDataDiff,
2936  const void* alphaParamDiff,
2937  const void* betaParamDiff,
2938  const miopenTensorDescriptor_t xDesc,
2939  const void* x,
2940  const miopenTensorDescriptor_t dyDesc,
2941  const void* dy,
2942  const miopenTensorDescriptor_t dxDesc,
2943  void* dx,
2944  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,
2945  const void* bnScale,
2946  void* resultBnScaleDiff,
2947  void* resultBnBiasDiff,
2948  double epsilon,
2949  const void* savedMean,
2950  const void* savedInvVariance);
2951 
2990 MIOPEN_EXPORT miopenStatus_t
2991 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,
2992  miopenBatchNormMode_t bn_mode,
2993  const void* alphaDataDiff,
2994  const void* betaDataDiff,
2995  const void* alphaParamDiff,
2996  const void* betaParamDiff,
2997  const miopenTensorDescriptor_t xDesc,
2998  const void* x,
2999  const miopenTensorDescriptor_t dyDesc,
3000  const void* dy,
3001  const miopenTensorDescriptor_t dxDesc,
3002  void* dx,
3003  const miopenTensorDescriptor_t scaleDesc,
3004  const miopenTensorDescriptor_t biasDesc,
3005  const miopenTensorDescriptor_t savedMeanDesc,
3006  const miopenTensorDescriptor_t savedVarDesc,
3007  const void* bnScale,
3008  void* resultBnScaleDiff,
3009  void* resultBnBiasDiff,
3010  double epsilon,
3011  const void* savedMean,
3012  const void* savedInvVariance);
3013 
3015 // CLOSEOUT BATCHNORM DOXYGEN GROUP
3016 
3017 // Activation APIs
3027 MIOPEN_EXPORT miopenStatus_t
3028 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);
3029 
3041 MIOPEN_EXPORT miopenStatus_t
3042 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3043  miopenActivationMode_t mode,
3044  double activAlpha,
3045  double activBeta,
3046  double activGamma);
3047 
3059 MIOPEN_EXPORT miopenStatus_t
3060 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3061  miopenActivationMode_t* mode,
3062  double* activAlpha,
3063  double* activBeta,
3064  double* activGamma);
3065 
3078 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,
3079  const miopenActivationDescriptor_t activDesc,
3080  const void* alpha,
3081  const miopenTensorDescriptor_t xDesc,
3082  const void* x,
3083  const void* beta,
3084  const miopenTensorDescriptor_t yDesc,
3085  void* y);
3086 
3103 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,
3104  const miopenActivationDescriptor_t activDesc,
3105  const void* alpha,
3106  const miopenTensorDescriptor_t yDesc,
3107  const void* y,
3108  const miopenTensorDescriptor_t dyDesc,
3109  const void* dy,
3110  const miopenTensorDescriptor_t xDesc,
3111  const void* x,
3112  const void* beta,
3113  const miopenTensorDescriptor_t dxDesc,
3114  void* dx);
3115 
3121 MIOPEN_EXPORT miopenStatus_t
3122 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);
3123 
3125 // CLOSEOUT ACTIVATION DOXYGEN GROUP
3126 
3127 #ifdef MIOPEN_BETA_API
3143 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,
3144  const miopenTensorDescriptor_t inputDesc,
3145  const void* input,
3146  const miopenTensorDescriptor_t outputDesc,
3147  void* output,
3148  const uint32_t dim);
3149 
3162 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,
3163  const miopenTensorDescriptor_t inputDesc,
3164  const void* input,
3165  const miopenTensorDescriptor_t outputGradDesc,
3166  const void* outputGrad,
3167  const miopenTensorDescriptor_t inputGradDesc,
3168  void* inputGrad,
3169  const uint32_t dim);
3170 
3172 // CLOSEOUT ACTIVATION DOXYGEN GROUP
3173 #endif // MIOPEN_BETA_API
3174 
3175 // Softmax APIs
3193 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,
3194  const void* alpha,
3195  const miopenTensorDescriptor_t xDesc,
3196  const void* x,
3197  const void* beta,
3198  const miopenTensorDescriptor_t yDesc,
3199  void* y);
3200 
3216 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,
3217  const void* alpha,
3218  const miopenTensorDescriptor_t yDesc,
3219  const void* y,
3220  const miopenTensorDescriptor_t dyDesc,
3221  const void* dy,
3222  const void* beta,
3223  const miopenTensorDescriptor_t dxDesc,
3224  void* dx);
3225 
3239 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,
3240  const void* alpha,
3241  const miopenTensorDescriptor_t xDesc,
3242  const void* x,
3243  const void* beta,
3244  const miopenTensorDescriptor_t yDesc,
3245  void* y,
3246  miopenSoftmaxAlgorithm_t algorithm,
3247  miopenSoftmaxMode_t mode);
3248 
3264 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,
3265  const void* alpha,
3266  const miopenTensorDescriptor_t yDesc,
3267  const void* y,
3268  const miopenTensorDescriptor_t dyDesc,
3269  const void* dy,
3270  const void* beta,
3271  const miopenTensorDescriptor_t dxDesc,
3272  void* dx,
3273  miopenSoftmaxAlgorithm_t algorithm,
3274  miopenSoftmaxMode_t mode);
3275 
3277 // CLOSEOUT SOFTMAX DOXYGEN GROUP
3278 
3282 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);
3283 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);
3284 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);
3285 
3294 typedef enum
3295 {
3296  miopenVerticalFusion = 0,
3297  miopenHorizontalFusion = 1,
3298 } miopenFusionDirection_t;
3299 
3307 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,
3308  const miopenFusionDirection_t fuseDirection,
3309  const miopenTensorDescriptor_t inputDesc);
3310 
3316 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);
3317 
3324 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,
3325  miopenFusionPlanDescriptor_t fusePlanDesc);
3326 
3337 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,
3338  const int op_idx,
3339  miopenFusionOpDescriptor_t* op);
3340 
3348 MIOPEN_EXPORT miopenStatus_t
3349 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,
3350  miopenFusionPlanDescriptor_t fusePlanDesc,
3351  size_t* workSpaceSize,
3352  miopenConvFwdAlgorithm_t algo);
3353 
3371 MIOPEN_EXPORT miopenStatus_t
3372 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,
3373  const int requestAlgoCount,
3374  int* returnedAlgoCount,
3375  miopenConvFwdAlgorithm_t* returnedAlgos);
3376 
3386 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(
3387  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);
3388 
3397 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3398  miopenFusionOpDescriptor_t* convOp,
3399  miopenConvolutionDescriptor_t convDesc,
3400  const miopenTensorDescriptor_t wDesc);
3401 
3402 //---
3403 
3404 // Activation forward create ops ---
3412 MIOPEN_EXPORT miopenStatus_t
3413 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3414  miopenFusionOpDescriptor_t* activFwdOp,
3415  miopenActivationMode_t mode);
3416 
3417 // Activation backward create ops ---
3425 MIOPEN_EXPORT miopenStatus_t
3426 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3427  miopenFusionOpDescriptor_t* activBwdOp,
3428  miopenActivationMode_t mode);
3429 
3430 // Bias create ops ---
3438 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3439  miopenFusionOpDescriptor_t* biasOp,
3440  const miopenTensorDescriptor_t bDesc);
3441 
3442 // Batch normalization create ops ---
3451 MIOPEN_EXPORT miopenStatus_t
3452 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,
3453  miopenFusionOpDescriptor_t* bnOp,
3454  const miopenBatchNormMode_t bn_mode,
3455  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);
3456 
3466 MIOPEN_EXPORT miopenStatus_t
3467 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3468  miopenFusionOpDescriptor_t* bnFwdOp,
3469  const miopenBatchNormMode_t bn_mode,
3470  bool runningMeanVariance);
3471 
3479 MIOPEN_EXPORT miopenStatus_t
3480 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3481  miopenFusionOpDescriptor_t* bnBwdOp,
3482  const miopenBatchNormMode_t bn_mode);
3483 
3484 //---
3490 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);
3491 
3497 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);
3498 
3499 // Convolution set arguments ---
3509 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,
3510  const miopenFusionOpDescriptor_t convOp,
3511  const void* alpha,
3512  const void* beta,
3513  const void* w);
3514 // Activation set arguments ---
3526 MIOPEN_EXPORT miopenStatus_t
3527 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,
3528  const miopenFusionOpDescriptor_t activFwdOp,
3529  const void* alpha,
3530  const void* beta,
3531  double activAlpha,
3532  double activBeta,
3533  double activGamma);
3534 
3548 MIOPEN_EXPORT miopenStatus_t
3549 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,
3550  const miopenFusionOpDescriptor_t activBwdOp,
3551  const void* alpha,
3552  const void* beta,
3553  const void* y,
3554  const void* reserved,
3555  double activAlpha,
3556  double activBeta,
3557  double activGamma);
3558 
3559 // Batch Normalization set arguments ---
3573 MIOPEN_EXPORT miopenStatus_t
3574 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,
3575  const miopenFusionOpDescriptor_t bnOp,
3576  const void* alpha,
3577  const void* beta,
3578  const void* bnScale,
3579  const void* bnBias,
3580  const void* estimatedMean,
3581  const void* estimatedVariance,
3582  double epsilon);
3583 
3600 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,
3601  const miopenFusionOpDescriptor_t bnOp,
3602  const void* alpha,
3603  const void* beta,
3604  const void* bnScale,
3605  const void* bnBias,
3606  void* savedMean,
3607  void* savedInvVariance,
3608  void* runningMean,
3609  void* runningVariance,
3610  double expAvgFactor,
3611  double epsilon);
3612 
3628 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,
3629  const miopenFusionOpDescriptor_t bnOp,
3630  const void* alpha,
3631  const void* beta,
3632  const void* x,
3633  const void* bnScale,
3634  const void* bnBias,
3635  void* resultBnScaleDiff,
3636  void* resultBnBiasDiff,
3637  const void* savedMean,
3638  const void* savedInvVariance);
3639 
3640 // Bias forward set arguments ---
3650 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,
3651  const miopenFusionOpDescriptor_t biasOp,
3652  const void* alpha,
3653  const void* beta,
3654  const void* bias);
3667 MIOPEN_EXPORT miopenStatus_t
3668 miopenExecuteFusionPlan(const miopenHandle_t handle,
3669  const miopenFusionPlanDescriptor_t fusePlanDesc,
3670  const miopenTensorDescriptor_t inputDesc,
3671  const void* input,
3672  const miopenTensorDescriptor_t outputDesc,
3673  void* output,
3674  miopenOperatorArgs_t args);
3675 
3699 MIOPEN_EXPORT miopenStatus_t
3700 miopenConvolutionBiasActivationForward(miopenHandle_t handle,
3701  const void* alpha1,
3702  const miopenTensorDescriptor_t xDesc,
3703  const void* x,
3704  const miopenTensorDescriptor_t wDesc,
3705  const void* w,
3706  const miopenConvolutionDescriptor_t convDesc,
3707  miopenConvFwdAlgorithm_t algo,
3708  void* workspace,
3709  size_t workspaceSizeInBytes,
3710  const void* alpha2,
3711  const miopenTensorDescriptor_t zDesc,
3712  const void* z,
3713  const miopenTensorDescriptor_t biasDesc,
3714  const void* bias,
3715  const miopenActivationDescriptor_t activationDesc,
3716  const miopenTensorDescriptor_t yDesc,
3717  void* y);
3719 // CLOSEOUT FUSION DOXYGEN GROUP
3720 
3729 typedef enum
3730 {
3731  miopenRNNRELU = 0,
3732  miopenRNNTANH = 1,
3733  miopenLSTM = 2,
3734  miopenGRU = 3,
3735 } miopenRNNMode_t;
3736 
3740 typedef enum
3741 {
3742  miopenRNNlinear = 0,
3743  miopenRNNskip = 1,
3744 } miopenRNNInputMode_t;
3745 
3749 typedef enum
3750 {
3751  miopenRNNdefault = 0,
3753  miopenRNNfundamental =
3754  1,
3755 } miopenRNNAlgo_t;
3756 
3760 typedef enum
3761 {
3762  miopenRNNunidirection = 0,
3763  miopenRNNbidirection = 1,
3764 } miopenRNNDirectionMode_t;
3765 
3769 typedef enum
3770 {
3771  miopenRNNNoBias = 0,
3772  miopenRNNwithBias = 1,
3773 } miopenRNNBiasMode_t;
3774 
3778 typedef enum
3779 {
3780  miopenRNNAlgoGEMM = 0,
3781 } miopenRNNGEMMalgoMode_t;
3782 
3786 typedef enum
3787 {
3788  miopenRNNIONotPadded = 0,
3789  miopenRNNIOWithPadding = 1,
3790 } miopenRNNPaddingMode_t;
3791 
3795 typedef enum
3796 {
3797  miopenRNNTraining = 0,
3798  miopenRNNInference = 1,
3799 } miopenRNNFWDMode_t;
3800 
3804 typedef enum
3805 {
3806  miopenRNNDataUnknownLayout = 0,
3807  miopenRNNDataSeqMajorNotPadded = 1,
3808  miopenRNNDataSeqMajorPadded = 2,
3809  miopenRNNDataBatchMajorPadded = 3,
3810 } miopenRNNBaseLayout_t;
3811 
3818 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);
3819 
3832 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
3833  miopenRNNMode_t* rnnMode,
3834  miopenRNNAlgo_t* algoMode,
3835  miopenRNNInputMode_t* inputMode,
3836  miopenRNNDirectionMode_t* dirMode,
3837  miopenRNNBiasMode_t* biasMode,
3838  int* hiddenSize,
3839  int* layer);
3840 
3857 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
3858  int* hiddenSize,
3859  int* layer,
3860  miopenDropoutDescriptor_t* dropoutDesc,
3861  miopenRNNInputMode_t* inputMode,
3862  miopenRNNDirectionMode_t* dirMode,
3863  miopenRNNMode_t* rnnMode,
3864  miopenRNNBiasMode_t* biasMode,
3865  miopenRNNAlgo_t* algoMode,
3866  miopenDataType_t* dataType);
3867 
3873 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);
3874 
3890 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
3891  const int hsize,
3892  const int nlayers,
3893  miopenRNNInputMode_t inMode,
3894  miopenRNNDirectionMode_t direction,
3895  miopenRNNMode_t rnnMode,
3896  miopenRNNBiasMode_t biasMode,
3897  miopenRNNAlgo_t algo,
3898  miopenDataType_t dataType);
3899 
3918 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
3919  const int hsize,
3920  const int nlayers,
3921  miopenDropoutDescriptor_t dropoutDesc,
3922  miopenRNNInputMode_t inMode,
3923  miopenRNNDirectionMode_t direction,
3924  miopenRNNMode_t rnnMode,
3925  miopenRNNBiasMode_t biasMode,
3926  miopenRNNAlgo_t algo,
3927  miopenDataType_t dataType);
3928 
3943 MIOPEN_EXPORT miopenStatus_t
3944 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
3945  miopenDataType_t dataType,
3946  miopenRNNBaseLayout_t layout,
3947  int maxSequenceLen,
3948  int batchSize,
3949  int vectorSize,
3950  const int* sequenceLenArray,
3951  void* paddingMarker);
3952 
3971 MIOPEN_EXPORT miopenStatus_t
3972 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
3973  miopenDataType_t* dataType,
3974  miopenRNNBaseLayout_t* layout,
3975  int* maxSequenceLen,
3976  int* batchSize,
3977  int* vectorSize,
3978  int sequenceLenArrayLimit,
3979  int* sequenceLenArray,
3980  void* paddingMarker);
3981 
3998 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,
3999  const miopenRNNDescriptor_t rnnDesc,
4000  const int sequenceLen,
4001  const miopenTensorDescriptor_t* xDesc,
4002  size_t* numBytes);
4003 
4020 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,
4021  miopenRNNDescriptor_t rnnDesc,
4022  const int sequenceLen,
4023  const miopenTensorDescriptor_t* xDesc,
4024  size_t* numBytes);
4025 
4042 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,
4043  miopenRNNDescriptor_t rnnDesc,
4044  miopenSeqTensorDescriptor_t xDesc,
4045  miopenRNNFWDMode_t fwdMode,
4046  size_t* workSpaceSize,
4047  size_t* reserveSpaceSize);
4048 
4061 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,
4062  miopenRNNDescriptor_t rnnDesc,
4063  miopenTensorDescriptor_t xDesc,
4064  size_t* numBytes,
4065  miopenDataType_t dtype);
4066 
4079 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,
4080  miopenRNNDescriptor_t rnnDesc,
4081  miopenTensorDescriptor_t xDesc,
4082  miopenTensorDescriptor_t wDesc,
4083  miopenDataType_t dtype);
4084 
4102 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,
4103  miopenRNNDescriptor_t rnnDesc,
4104  const int seqLen,
4105  miopenTensorDescriptor_t* xDesc,
4106  size_t* numBytes);
4107 
4120 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,
4121  miopenRNNDescriptor_t rnnDesc,
4122  const int seqLen,
4123  miopenTensorDescriptor_t* xDesc,
4124  size_t* numBytes);
4125 
4166 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,
4167  miopenRNNDescriptor_t rnnDesc,
4168  const int layer,
4169  miopenTensorDescriptor_t xDesc,
4170  const int paramID,
4171  size_t* numBytes);
4172 
4210 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,
4211  miopenRNNDescriptor_t rnnDesc,
4212  const int layer,
4213  const int biasID,
4214  size_t* numBytes);
4215 
4274 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,
4275  miopenRNNDescriptor_t rnnDesc,
4276  const int layer,
4277  miopenTensorDescriptor_t xDesc,
4278  miopenTensorDescriptor_t wDesc,
4279  const void* w,
4280  const int paramID,
4281  miopenTensorDescriptor_t paramDesc,
4282  void* layerParam);
4283 
4341 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,
4342  miopenRNNDescriptor_t rnnDesc,
4343  const int layer,
4344  miopenTensorDescriptor_t xDesc,
4345  miopenTensorDescriptor_t wDesc,
4346  const void* w,
4347  const int biasID,
4348  miopenTensorDescriptor_t biasDesc,
4349  void* layerBias);
4350 
4405 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,
4406  const int layer,
4407  miopenTensorDescriptor_t xDesc,
4408  const int paramID,
4409  miopenTensorDescriptor_t paramDesc,
4410  size_t* layerParamOffset);
4411 
4462 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,
4463  const int layer,
4464  miopenTensorDescriptor_t xDesc,
4465  const int biasID,
4466  miopenTensorDescriptor_t biasDesc,
4467  size_t* layerBiasOffset);
4468 
4521 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,
4522  miopenRNNDescriptor_t rnnDesc,
4523  const int layer,
4524  miopenTensorDescriptor_t xDesc,
4525  miopenTensorDescriptor_t wDesc,
4526  void* w,
4527  const int paramID,
4528  miopenTensorDescriptor_t paramDesc,
4529  const void* layerParam);
4530 
4581 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,
4582  miopenRNNDescriptor_t rnnDesc,
4583  const int layer,
4584  miopenTensorDescriptor_t xDesc,
4585  miopenTensorDescriptor_t wDesc,
4586  void* w,
4587  const int biasID,
4588  miopenTensorDescriptor_t biasDesc,
4589  const void* layerBias);
4590 
4602 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
4603  miopenRNNPaddingMode_t paddingMode);
4604 
4612 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
4613  miopenRNNPaddingMode_t* paddingMode);
4614 
4665 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,
4666  const miopenRNNDescriptor_t rnnDesc,
4667  miopenRNNFWDMode_t fwdMode,
4668  const miopenSeqTensorDescriptor_t xDesc,
4669  const void* x,
4670  const miopenTensorDescriptor_t hDesc,
4671  const void* hx,
4672  void* hy,
4673  const miopenTensorDescriptor_t cDesc,
4674  const void* cx,
4675  void* cy,
4676  const miopenSeqTensorDescriptor_t yDesc,
4677  void* y,
4678  const void* w,
4679  size_t weightSpaceSize,
4680  void* workSpace,
4681  size_t workSpaceNumBytes,
4682  void* reserveSpace,
4683  size_t reserveSpaceNumBytes);
4684 
4734 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,
4735  const miopenRNNDescriptor_t rnnDesc,
4736  const miopenSeqTensorDescriptor_t yDesc,
4737  const void* y,
4738  const void* dy,
4739  const miopenTensorDescriptor_t hDesc,
4740  const void* hx,
4741  const void* dhy,
4742  void* dhx,
4743  const miopenTensorDescriptor_t cDesc,
4744  const void* cx,
4745  const void* dcy,
4746  void* dcx,
4747  const miopenSeqTensorDescriptor_t xDesc,
4748  void* dx,
4749  const void* w,
4750  size_t weightSpaceSize,
4751  void* workSpace,
4752  size_t workSpaceNumBytes,
4753  void* reserveSpace,
4754  size_t reserveSpaceNumBytes);
4755 
4789 MIOPEN_EXPORT miopenStatus_t
4790 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,
4791  const miopenRNNDescriptor_t rnnDesc,
4792  const miopenSeqTensorDescriptor_t xDesc,
4793  const void* x,
4794  const miopenTensorDescriptor_t hDesc,
4795  const void* hx,
4796  const miopenSeqTensorDescriptor_t yDesc,
4797  const void* y,
4798  void* dw,
4799  size_t weightSpaceSize,
4800  void* workSpace,
4801  size_t workSpaceNumBytes,
4802  const void* reserveSpace,
4803  size_t reserveSpaceNumBytes);
4804 
4862 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,
4863  const miopenRNNDescriptor_t rnnDesc,
4864  const int sequenceLen,
4865  const miopenTensorDescriptor_t* xDesc,
4866  const void* x,
4867  const miopenTensorDescriptor_t hxDesc,
4868  const void* hx,
4869  const miopenTensorDescriptor_t cxDesc,
4870  const void* cx,
4871  const miopenTensorDescriptor_t wDesc,
4872  const void* w,
4873  const miopenTensorDescriptor_t* yDesc,
4874  void* y,
4875  const miopenTensorDescriptor_t hyDesc,
4876  void* hy,
4877  const miopenTensorDescriptor_t cyDesc,
4878  void* cy,
4879  void* workSpace,
4880  size_t workSpaceNumBytes,
4881  void* reserveSpace,
4882  size_t reserveSpaceNumBytes);
4883 
4956 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,
4957  const miopenRNNDescriptor_t rnnDesc,
4958  const int sequenceLen,
4959  const miopenTensorDescriptor_t* yDesc,
4960  const void* y,
4961  const miopenTensorDescriptor_t* dyDesc,
4962  const void* dy,
4963  const miopenTensorDescriptor_t dhyDesc,
4964  const void* dhy,
4965  const miopenTensorDescriptor_t dcyDesc,
4966  const void* dcy,
4967  const miopenTensorDescriptor_t wDesc,
4968  const void* w,
4969  const miopenTensorDescriptor_t hxDesc,
4970  const void* hx,
4971  const miopenTensorDescriptor_t cxDesc,
4972  const void* cx,
4973  const miopenTensorDescriptor_t* dxDesc,
4974  void* dx,
4975  const miopenTensorDescriptor_t dhxDesc,
4976  void* dhx,
4977  const miopenTensorDescriptor_t dcxDesc,
4978  void* dcx,
4979  void* workSpace,
4980  size_t workSpaceNumBytes,
4981  void* reserveSpace,
4982  size_t reserveSpaceNumBytes);
4983 
5020 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,
5021  const miopenRNNDescriptor_t rnnDesc,
5022  const int sequenceLen,
5023  const miopenTensorDescriptor_t* xDesc,
5024  const void* x,
5025  const miopenTensorDescriptor_t hxDesc,
5026  const void* hx,
5027  const miopenTensorDescriptor_t* yDesc,
5028  const void* y,
5029  const miopenTensorDescriptor_t dwDesc,
5030  void* dw,
5031  void* workSpace,
5032  size_t workSpaceNumBytes,
5033  const void* reserveSpace,
5034  size_t reserveSpaceNumBytes);
5035 
5091 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,
5092  miopenRNNDescriptor_t rnnDesc,
5093  const int sequenceLen,
5094  const miopenTensorDescriptor_t* xDesc,
5095  const void* x,
5096  const miopenTensorDescriptor_t hxDesc,
5097  const void* hx,
5098  const miopenTensorDescriptor_t cxDesc,
5099  const void* cx,
5100  const miopenTensorDescriptor_t wDesc,
5101  const void* w,
5102  const miopenTensorDescriptor_t* yDesc,
5103  void* y,
5104  const miopenTensorDescriptor_t hyDesc,
5105  void* hy,
5106  const miopenTensorDescriptor_t cyDesc,
5107  void* cy,
5108  void* workSpace,
5109  size_t workSpaceNumBytes);
5110 
5112 // CLOSEOUT RNN DOXYGEN GROUP
5113 
5122 typedef enum
5123 {
5124  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,
5125 } miopenCTCLossAlgo_t;
5126 
5133 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);
5134 
5144 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5145  miopenDataType_t* dataType,
5146  int* blank_label_id,
5147  bool* apply_softmax_layer);
5148 
5154 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);
5155 
5165 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5166  miopenDataType_t dataType,
5167  const int blank_label_id,
5168  bool apply_softmax_layer);
5169 
5186 MIOPEN_EXPORT miopenStatus_t
5187 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,
5188  const miopenTensorDescriptor_t probsDesc,
5189  const miopenTensorDescriptor_t gradientsDesc,
5190  const int* labels,
5191  const int* labelLengths,
5192  const int* inputLengths,
5193  miopenCTCLossAlgo_t algo,
5194  const miopenCTCLossDescriptor_t ctcLossDesc,
5195  size_t* workSpaceSize);
5196 
5216 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,
5217  const miopenTensorDescriptor_t probsDesc,
5218  const void* probs,
5219  const int* labels,
5220  const int* labelLengths,
5221  const int* inputLengths,
5222  void* losses,
5223  const miopenTensorDescriptor_t gradientsDesc,
5224  void* gradients,
5225  miopenCTCLossAlgo_t algo,
5226  const miopenCTCLossDescriptor_t ctcLossDesc,
5227  void* workSpace,
5228  size_t workSpaceSize);
5229 
5231 // CLOSEOUT LossFunction DOXYGEN GROUP
5232 
5233 // Dropout APIs
5242 typedef enum
5243 {
5244  MIOPEN_RNG_PSEUDO_XORWOW = 0,
5245 } miopenRNGType_t;
5246 
5252 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);
5253 
5259 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);
5260 
5269 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,
5270  size_t* reserveSpaceSizeInBytes);
5271 
5280 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,
5281  size_t* stateSizeInBytes);
5282 
5299 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5300  miopenHandle_t handle,
5301  float* dropout,
5302  void** states,
5303  unsigned long long* seed,
5304  bool* use_mask,
5305  bool* state_evo,
5306  miopenRNGType_t* rng_mode);
5307 
5330 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5331  miopenHandle_t handle,
5332  float dropout,
5333  void* states,
5334  size_t stateSizeInBytes,
5335  unsigned long long seed,
5336  bool use_mask,
5337  bool state_evo,
5338  miopenRNGType_t rng_mode);
5339 
5359 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5360  miopenHandle_t handle,
5361  float dropout,
5362  void* states,
5363  size_t stateSizeInBytes,
5364  unsigned long long seed,
5365  bool use_mask,
5366  bool state_evo,
5367  miopenRNGType_t rng_mode);
5368 
5386 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,
5387  const miopenDropoutDescriptor_t dropoutDesc,
5388  const miopenTensorDescriptor_t noise_shape,
5389  const miopenTensorDescriptor_t xDesc,
5390  const void* x,
5391  const miopenTensorDescriptor_t yDesc,
5392  void* y,
5393  void* reserveSpace,
5394  size_t reserveSpaceSizeInBytes);
5395 
5413 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,
5414  const miopenDropoutDescriptor_t dropoutDesc,
5415  const miopenTensorDescriptor_t noise_shape,
5416  const miopenTensorDescriptor_t dyDesc,
5417  const void* dy,
5418  const miopenTensorDescriptor_t dxDesc,
5419  void* dx,
5420  void* reserveSpace,
5421  size_t reserveSpaceSizeInBytes);
5422 
5424 // CLOSEOUT DROPOUT DOXYGEN GROUP
5425 
5426 // TensorReduce APIs
5437 MIOPEN_EXPORT miopenStatus_t
5438 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);
5439 
5445 MIOPEN_EXPORT miopenStatus_t
5446 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);
5447 
5460 MIOPEN_EXPORT miopenStatus_t
5461 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,
5462  miopenReduceTensorOp_t reduceTensorOp,
5463  miopenDataType_t reduceTensorCompType,
5464  miopenNanPropagation_t reduceTensorNanOpt,
5465  miopenReduceTensorIndices_t reduceTensorIndices,
5466  miopenIndicesType_t reduceTensorIndicesType);
5467 
5483 MIOPEN_EXPORT miopenStatus_t
5484 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,
5485  miopenReduceTensorOp_t* reduceTensorOp,
5486  miopenDataType_t* reduceTensorCompType,
5487  miopenNanPropagation_t* reduceTensorNanOpt,
5488  miopenReduceTensorIndices_t* reduceTensorIndices,
5489  miopenIndicesType_t* reduceTensorIndicesType);
5490 
5500 MIOPEN_EXPORT miopenStatus_t
5501 miopenGetReductionIndicesSize(miopenHandle_t handle,
5502  const miopenReduceTensorDescriptor_t reduceTensorDesc,
5503  const miopenTensorDescriptor_t aDesc,
5504  const miopenTensorDescriptor_t cDesc,
5505  size_t* sizeInBytes);
5506 
5516 MIOPEN_EXPORT miopenStatus_t
5517 miopenGetReductionWorkspaceSize(miopenHandle_t handle,
5518  const miopenReduceTensorDescriptor_t reduceTensorDesc,
5519  const miopenTensorDescriptor_t aDesc,
5520  const miopenTensorDescriptor_t cDesc,
5521  size_t* sizeInBytes);
5522 
5546 MIOPEN_EXPORT miopenStatus_t
5547 miopenReduceTensor(miopenHandle_t handle,
5548  const miopenReduceTensorDescriptor_t reduceTensorDesc,
5549  void* indices,
5550  size_t indicesSizeInBytes,
5551  void* workspace,
5552  size_t workspaceSizeInBytes,
5553  const void* alpha,
5554  const miopenTensorDescriptor_t aDesc,
5555  const void* A,
5556  const void* beta,
5557  const miopenTensorDescriptor_t cDesc,
5558  void* C);
5559 
5561 // CLOSEOUT TensorReduce DOXYGEN GROUP
5562 
5563 // Find 2.0 API
5574 MIOPEN_DECLARE_OBJECT(miopenProblem);
5575 
5579 typedef enum
5580 {
5581  miopenProblemDirectionForward = 0,
5582  miopenProblemDirectionBackward = 1,
5583  miopenProblemDirectionBackwardWeights = 2,
5584 #ifdef MIOPEN_BETA_API
5585  miopenProblemDirectionInference = 4,
5586 #endif
5587 } miopenProblemDirection_t;
5588 
5592 typedef enum
5593 {
5594  miopenTensorArgumentIdInvalid = 0,
5595  miopenTensorConvolutionX = 1,
5596  miopenTensorConvolutionW = 2,
5597  miopenTensorConvolutionY = 3,
5598 
5599  miopenTensorMhaK = 4,
5600  miopenTensorMhaQ = 5,
5601  miopenTensorMhaV = 6,
5602  miopenTensorMhaDescaleK = 7,
5603  miopenTensorMhaDescaleQ = 8,
5604  miopenTensorMhaDescaleV = 9,
5605  miopenTensorMhaDescaleS = 10,
5606  miopenTensorMhaScaleS = 11,
5607  miopenTensorMhaScaleO = 12,
5608  miopenTensorMhaDropoutProbability = 13,
5609  miopenTensorMhaDropoutSeed = 14,
5610  miopenTensorMhaDropoutOffset = 15,
5611  miopenTensorMhaO = 16,
5612  miopenTensorMhaAmaxO = 17,
5613  miopenTensorMhaAmaxS = 18,
5614  miopenTensorMhaM = 19,
5615  miopenTensorMhaZInv = 20,
5616  miopenTensorMhaDO = 21,
5617  miopenTensorMhaDescaleO = 22,
5618  miopenTensorMhaDescaleDO = 23,
5619  miopenTensorMhaDescaleDS = 24,
5620  miopenTensorMhaScaleDS = 25,
5621  miopenTensorMhaScaleDQ = 26,
5622  miopenTensorMhaScaleDK = 27,
5623  miopenTensorMhaScaleDV = 28,
5624  miopenTensorMhaDQ = 29,
5625  miopenTensorMhaDK = 30,
5626  miopenTensorMhaDV = 31,
5627  miopenTensorMhaAmaxDQ = 32,
5628  miopenTensorMhaAmaxDK = 33,
5629  miopenTensorMhaAmaxDV = 34,
5630  miopenTensorMhaAmaxDS = 35,
5631  miopenTensorMhaBias = 36,
5632 
5633 #ifdef MIOPEN_BETA_API
5634  miopenTensorActivationX = 37,
5635  miopenTensorActivationY = 38,
5636  miopenTensorActivationDX = 39,
5637  miopenTensorActivationDY = 40,
5638  miopenTensorBiasX = 41,
5639  miopenTensorBiasY = 42,
5640  miopenTensorBias = 43,
5641  miopenTensorSoftmaxX = 44,
5642  miopenTensorSoftmaxY = 45,
5643  miopenTensorSoftmaxDX = 46,
5644  miopenTensorSoftmaxDY = 47,
5645  miopenTensorBatchnormX = 48,
5646  miopenTensorBatchnormY = 49,
5647  miopenTensorBatchnormRunningMean = 50,
5648  miopenTensorBatchnormRunningVariance = 51,
5649  miopenTensorBatchnormSavedMean = 52,
5650  miopenTensorBatchnormSavedVariance = 53,
5651  miopenTensorBatchnormScale = 54,
5652  miopenTensorBatchnormScaleDiff = 55,
5653  miopenTensorBatchnormEstimatedMean = 56,
5654  miopenTensorBatchnormEstimatedVariance = 57,
5655  miopenTensorBatchnormBias = 58,
5656  miopenTensorBatchnormBiasDiff = 59,
5657  miopenTensorBatchnormDX = 60,
5658  miopenTensorBatchnormDY = 61,
5659 #endif
5660 
5661  miopenTensorArgumentIsScalar = 1U << 31,
5662 
5663  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,
5664 #ifdef MIOPEN_BETA_API
5665  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,
5666  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,
5667 #endif
5668 } miopenTensorArgumentId_t;
5669 
5673 typedef enum
5674 {
5675  miopenFindResultsOrderByTime = 0,
5676  miopenFindResultsOrderByWorkspaceSize = 1,
5677 } miopenFindResultsOrder_t;
5678 
5686 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,
5687  miopenConvolutionDescriptor_t operatorDesc,
5688  miopenProblemDirection_t direction);
5689 
5701 typedef enum
5702 {
5703  miopenMhaMaskNone = 0,
5704  miopenMhaMaskCausal = 1,
5705 } miopenMhaMask_t;
5706 
5707 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,
5708  miopenMhaDescriptor_t operatorDesc,
5709  miopenProblemDirection_t direction);
5710 
5717 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);
5718 
5728 MIOPEN_EXPORT miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale);
5729 
5739 MIOPEN_EXPORT miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float* scale);
5740 
5747 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);
5748 
5760 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,
5761  float alpha,
5762  float beta,
5763  miopenSoftmaxAlgorithm_t algorithm,
5764  miopenSoftmaxMode_t mode);
5765 
5777 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,
5778  float* alpha,
5779  float* beta,
5780  miopenSoftmaxAlgorithm_t* algorithm,
5781  miopenSoftmaxMode_t* mode);
5782 
5788 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);
5789 
5797 MIOPEN_EXPORT miopenStatus_t
5798 miopenSetProblemTensorDescriptor(miopenProblem_t problem,
5799  miopenTensorArgumentId_t id,
5800  const miopenTensorDescriptor_t descriptor);
5801 
5804 MIOPEN_DECLARE_OBJECT(miopenFindOptions);
5805 
5811 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);
5812 
5818 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);
5819 
5826 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value);
5827 
5834 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,
5835  miopenFindResultsOrder_t value);
5836 
5844 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,
5845  size_t value);
5846 
5854 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,
5855  void* buffer,
5856  size_t size);
5857 
5866 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,
5867  miopenTensorArgumentId_t id,
5868  void* buffer);
5869 
5877 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,
5878  unsigned attach);
5879 
5882 MIOPEN_DECLARE_OBJECT(miopenSolution);
5883 
5895 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,
5896  miopenProblem_t problem,
5897  miopenFindOptions_t options,
5898  miopenSolution_t* solutions,
5899  size_t* numSolutions,
5900  size_t maxSolutions);
5901 
5904 struct miopenTensorArgument_t
5905 {
5906  /* @brief Identifier of the tensor argument.
5907  */
5908  miopenTensorArgumentId_t id;
5909  /* @brief Tensor descriptor to override the value stored in the solution.
5910  *
5911  * Some solvers may support overriding input and output tensor descriptors, but right now there
5912  * is no way to tell from the API. Intended for the future use.
5913  */
5914  miopenTensorDescriptor_t* descriptor;
5915  /* @brief Pointer to the device memory buffer to use for the operation or to the host memory if
5916  * the value is scalar.
5917  */
5918  void* buffer;
5919 };
5920 
5932 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,
5933  miopenSolution_t solution,
5934  size_t nInputs,
5935  const miopenTensorArgument_t* tensors,
5936  void* workspace,
5937  size_t workspaceSize);
5938 
5944 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);
5945 
5953 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,
5954  const char* data,
5955  size_t size);
5956 
5963 MIOPEN_EXPORT miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data);
5964 
5971 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size);
5972 
5979 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,
5980  size_t* workspaceSize);
5981 
5988 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time);
5989 
5996 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,
5997  uint64_t* solverId);
5998 
6005 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,
6006  miopenConvAlgorithm_t* result);
6007 
6008 #ifdef MIOPEN_BETA_API
6009 
6018 MIOPEN_EXPORT miopenStatus_t
6019 miopenCreateActivationProblem(miopenProblem_t* problem,
6020  miopenActivationDescriptor_t operatorDesc,
6021  miopenProblemDirection_t direction);
6022 
6031 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,
6032  miopenBatchNormMode_t mode,
6033  bool runningMeanVariance,
6034  miopenProblemDirection_t direction);
6035 
6055 MIOPEN_EXPORT miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2);
6056 
6064 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,
6065  miopenProblemDirection_t direction);
6066 
6075 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,
6076  miopenSoftmaxDescriptor_t operatorDesc,
6077  miopenProblemDirection_t direction);
6078 
6079 #endif
6080 
6082 // CLOSEOUT find2 DOXYGEN GROUP
6083 
6084 #ifdef MIOPEN_BETA_API
6085 
6090 typedef enum
6091 {
6092  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,
6093  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =
6094  1,
6095 } miopenReduceCalculationNanPropagation_t;
6096 
6097 // ReduceCalculation APIs
6106 typedef enum
6107 {
6108  MIOPEN_REDUCE_CALCULATION_PROD =
6109  1,
6110  MIOPEN_REDUCE_CALCULATION_SUM =
6111  2,
6112 } miopenReduceCalculationOp_t;
6113 
6123 MIOPEN_EXPORT miopenStatus_t
6124 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,
6125  const miopenTensorDescriptor_t xDesc,
6126  const int32_t dim,
6127  const miopenReduceCalculationOp_t reduceCalculationOp,
6128  const miopenTensorDescriptor_t reduceDesc,
6129  size_t* sizeInBytes);
6130 
6144 MIOPEN_EXPORT miopenStatus_t
6145 miopenReduceCalculationForward(miopenHandle_t handle,
6146  miopenReduceCalculationNanPropagation_t nanPropagation,
6147  void* workspace,
6148  size_t workspaceSizeInBytes,
6149  const miopenTensorDescriptor_t xDesc,
6150  const void* x,
6151  const int32_t dim,
6152  const miopenReduceCalculationOp_t reduceCalculationOp,
6153  const miopenTensorDescriptor_t reduceDesc,
6154  void* y);
6155 
6157 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP
6158 #endif // MIOPEN_BETA_API
6159 
6160 #ifdef MIOPEN_BETA_API
6161 
6166 typedef enum
6167 {
6168  MIOPEN_REDUCE_EXTREME_ARGMIN =
6169  1,
6170  MIOPEN_REDUCE_EXTREME_ARGMAX =
6171  2,
6172  MIOPEN_REDUCE_EXTREME_MIN =
6173  3,
6174  MIOPEN_REDUCE_EXTREME_MAX =
6175  4,
6176 } miopenReduceExtremeOp_t;
6177 
6178 // ReduceExtreme APIs
6198 MIOPEN_EXPORT miopenStatus_t
6199 miopenReduceExtremeForward(miopenHandle_t handle,
6200  const miopenTensorDescriptor_t xDesc,
6201  const void* x,
6202  const int32_t dim,
6203  const miopenReduceExtremeOp_t reduceExtremeOp,
6204  const miopenTensorDescriptor_t yDesc,
6205  void* y,
6206  const miopenTensorDescriptor_t indiceDesc,
6207  void* indice);
6208 
6210 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP
6211 #endif // MIOPEN_BETA_API
6212 
6213 #ifdef MIOPEN_BETA_API
6214 // GroupNorm APIs
6239 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,
6240  miopenNormMode_t mode,
6241  const miopenTensorDescriptor_t xDesc,
6242  const void* x,
6243  const miopenTensorDescriptor_t weightDesc,
6244  const void* weight,
6245  const miopenTensorDescriptor_t biasDesc,
6246  const void* bias,
6247  const uint64_t num_groups,
6248  const float epsilon,
6249  const miopenTensorDescriptor_t yDesc,
6250  void* y,
6251  const miopenTensorDescriptor_t meanDesc,
6252  void* mean,
6253  const miopenTensorDescriptor_t rstdDesc,
6254  void* rstd);
6255 
6257 // CLOSEOUT groupnorm DOXYGEN GROUP
6258 #endif // MIOPEN_BETA_API
6259 
6260 #ifdef MIOPEN_BETA_API
6261 // LayerNorm APIs
6288 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,
6289  miopenNormMode_t mode,
6290  const miopenTensorDescriptor_t xDesc,
6291  const void* x,
6292  const miopenTensorDescriptor_t x2Desc,
6293  const void* x2,
6294  const miopenTensorDescriptor_t weightDesc,
6295  const void* weight,
6296  const miopenTensorDescriptor_t biasDesc,
6297  const void* bias,
6298  const float epsilon,
6299  const int32_t normalized_dim,
6300  const miopenTensorDescriptor_t yDesc,
6301  void* y,
6302  const miopenTensorDescriptor_t meanDesc,
6303  void* mean,
6304  const miopenTensorDescriptor_t rstdDesc,
6305  void* rstd);
6306 
6308 // CLOSEOUT LAYERNORM DOXYGEN GROUP
6309 #endif // MIOPEN_BETA_API
6310 
6311 #ifdef MIOPEN_BETA_API
6312 // LayerNorm APIs
6332 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,
6333  miopenNormMode_t mode,
6334  const miopenTensorDescriptor_t xDesc,
6335  const void* x,
6336  const miopenTensorDescriptor_t weightDesc,
6337  const void* weight,
6338  const float epsilon,
6339  const miopenTensorDescriptor_t yDesc,
6340  void* y,
6341  const miopenTensorDescriptor_t rstdDesc,
6342  void* rstd);
6343 
6358 MIOPEN_EXPORT miopenStatus_t
6359 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,
6360  miopenNormMode_t mode,
6361  const miopenTensorDescriptor_t dyDesc,
6362  const miopenTensorDescriptor_t xDesc,
6363  const miopenTensorDescriptor_t weightDesc,
6364  const miopenTensorDescriptor_t rstdDesc,
6365  const miopenTensorDescriptor_t dxDesc,
6366  const miopenTensorDescriptor_t dwDesc,
6367  size_t* sizeInBytes);
6368 
6389 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,
6390  miopenNormMode_t mode,
6391  void* workspace,
6392  size_t workspaceSizeInBytes,
6393  const miopenTensorDescriptor_t dyDesc,
6394  const void* dy,
6395  const miopenTensorDescriptor_t xDesc,
6396  const void* x,
6397  const miopenTensorDescriptor_t weightDesc,
6398  const void* weight,
6399  const miopenTensorDescriptor_t rstdDesc,
6400  const void* rstd,
6401  const miopenTensorDescriptor_t dxDesc,
6402  void* dx,
6403  const miopenTensorDescriptor_t dwDesc,
6404  void* dw);
6406 // CLOSEOUT LAYERNORM DOXYGEN GROUP
6407 #endif // MIOPEN_BETA_API
6408 
6409 #ifdef MIOPEN_BETA_API
6410 // Graph API
6422 typedef enum
6423 {
6424  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,
6425  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,
6426  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,
6427  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,
6428  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,
6429  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,
6430  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,
6431  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,
6432  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,
6433  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,
6434  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,
6435  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,
6436  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,
6437  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
6438  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,
6439  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,
6440  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,
6441  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,
6442  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,
6443  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,
6444  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,
6445  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,
6446  MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,
6447  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,
6448  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,
6449  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,
6450  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,
6451  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,
6452  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,
6453  MIOPEN_BACKEND_RNG_DESCRIPTOR,
6454  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,
6455  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,
6456 } miopenBackendDescriptorType_t;
6457 
6465 typedef enum
6466 {
6467  MIOPEN_ATTR_POINTWISE_MODE = 0,
6468  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,
6469  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,
6470  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,
6471  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,
6472  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,
6473  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,
6474  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,
6475  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,
6476  MIOPEN_ATTR_POINTWISE_AXIS = 9,
6477 
6478  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,
6479  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,
6480  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,
6481  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,
6482  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,
6483  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,
6484  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,
6485 
6486  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,
6487  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,
6488  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,
6489  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,
6490 
6491  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,
6492  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,
6493  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,
6494 
6495  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,
6496  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,
6497  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,
6498  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,
6499  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,
6500  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,
6501 
6502  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,
6503  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,
6504  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,
6505  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,
6506 
6507  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,
6508  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,
6509 
6510  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,
6511  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,
6512  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,
6513  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,
6514  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,
6515  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,
6516  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,
6517  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,
6518  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,
6519  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,
6520  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,
6521  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,
6522  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,
6523  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,
6524  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,
6525  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,
6526  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,
6527  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,
6528  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,
6529  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,
6530  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,
6531  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,
6532  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,
6533  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,
6534  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,
6535  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,
6536  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,
6537 
6538  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,
6539  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,
6540  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,
6541  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,
6542  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,
6543 
6544  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,
6545  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,
6546  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,
6547  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,
6548  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,
6549  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,
6550  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,
6551  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,
6552  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,
6553  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,
6554  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,
6555  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,
6556  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,
6557  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,
6558  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,
6559  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,
6560  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,
6561 
6562  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,
6563  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,
6564  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,
6565 
6566  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,
6567  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,
6568  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,
6569  MIOPEN_ATTR_TENSOR_STRIDES = 903,
6570  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,
6571  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,
6572  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,
6573  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,
6574  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,
6575  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,
6576  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,
6577 
6578  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,
6579  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,
6580  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,
6581  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,
6582 
6583  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,
6584  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,
6585 
6586  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,
6587  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,
6588  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,
6589  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,
6590 
6591  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,
6592  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,
6593  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,
6594  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,
6595  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,
6596  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,
6597  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,
6598 
6599  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,
6600  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,
6601 
6602  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,
6603  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,
6604  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,
6605  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,
6606  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,
6607  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,
6608  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,
6609  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,
6610 
6611  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,
6612  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,
6613 
6614  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,
6615  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,
6616  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,
6617 
6618  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,
6619  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,
6620  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,
6621  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,
6622  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,
6623  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,
6624  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,
6625  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,
6626  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,
6627  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,
6628  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,
6629 
6630  MIOPEN_ATTR_RESAMPLE_MODE = 1700,
6631  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,
6632  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,
6633  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,
6634  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,
6635  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,
6636  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,
6637  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,
6638  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,
6639 
6640  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,
6641  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,
6642  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,
6643  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,
6644  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,
6645  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,
6646 
6647  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,
6648  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,
6649  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,
6650  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,
6651  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,
6652  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,
6653  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,
6654  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,
6655 
6656  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,
6657  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,
6658  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,
6659  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,
6660 
6661  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,
6662  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,
6663  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,
6664  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,
6665  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,
6666 
6667  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,
6668  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,
6669  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,
6670  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,
6671  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,
6672  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,
6673  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,
6674  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,
6675  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,
6676  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,
6677  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,
6678  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,
6679  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,
6680  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,
6681  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,
6682 
6683  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,
6684  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,
6685  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,
6686  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,
6687  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,
6688  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,
6689  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,
6690  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,
6691  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,
6692  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,
6693  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,
6694 
6695  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,
6696  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,
6697 
6698  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,
6699  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,
6700  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,
6701  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,
6702  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,
6703  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,
6704 
6705  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,
6706  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,
6707  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,
6708  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,
6709 
6710 } miopenBackendAttributeName_t;
6711 
6719 typedef enum
6720 {
6721  MIOPEN_TYPE_HANDLE = 0,
6722  MIOPEN_TYPE_DATA_TYPE,
6723  MIOPEN_TYPE_BOOLEAN,
6724  MIOPEN_TYPE_INT64,
6725  MIOPEN_TYPE_FLOAT,
6726  MIOPEN_TYPE_DOUBLE,
6727  MIOPEN_TYPE_VOID_PTR,
6728  MIOPEN_TYPE_CONVOLUTION_MODE,
6729  MIOPEN_TYPE_HEUR_MODE,
6730  MIOPEN_TYPE_KNOB_TYPE,
6731  MIOPEN_TYPE_NAN_PROPOGATION,
6732  MIOPEN_TYPE_NUMERICAL_NOTE,
6733  MIOPEN_TYPE_LAYOUT_TYPE,
6734  MIOPEN_TYPE_ATTRIB_NAME,
6735  MIOPEN_TYPE_POINTWISE_MODE,
6736  MIOPEN_TYPE_BACKEND_DESCRIPTOR,
6737  MIOPEN_TYPE_GENSTATS_MODE,
6738  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,
6739  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,
6740  MIOPEN_TYPE_BEHAVIOR_NOTE,
6741  MIOPEN_TYPE_TENSOR_REORDERING_MODE,
6742  MIOPEN_TYPE_RESAMPLE_MODE,
6743  MIOPEN_TYPE_PADDING_MODE,
6744  MIOPEN_TYPE_INT32,
6745  MIOPEN_TYPE_CHAR,
6746  MIOPEN_TYPE_SIGNAL_MODE,
6747  MIOPEN_TYPE_FRACTION,
6748  MIOPEN_TYPE_NORM_MODE,
6749  MIOPEN_TYPE_NORM_FWD_PHASE,
6750  MIOPEN_TYPE_RNG_DISTRIBUTION
6751 } miopenBackendAttributeType_t;
6752 
6758 typedef enum
6759 {
6761  MIOPEN_POINTWISE_ADD,
6762 
6765  MIOPEN_POINTWISE_ADD_SQUARE,
6766 
6768  MIOPEN_POINTWISE_DIV,
6769 
6771  MIOPEN_POINTWISE_MAX,
6772 
6774  MIOPEN_POINTWISE_MIN,
6775 
6778  MIOPEN_POINTWISE_MOD,
6779 
6781  MIOPEN_POINTWISE_MUL,
6782 
6784  MIOPEN_POINTWISE_POW,
6785 
6787  MIOPEN_POINTWISE_SUB,
6788 
6790  MIOPEN_POINTWISE_ABS,
6791 
6793  MIOPEN_POINTWISE_CEIL,
6794 
6796  MIOPEN_POINTWISE_COS,
6797 
6799  MIOPEN_POINTWISE_EXP,
6800 
6802  MIOPEN_POINTWISE_FLOOR,
6803 
6805  MIOPEN_POINTWISE_LOG,
6806 
6808  MIOPEN_POINTWISE_NEG,
6809 
6811  MIOPEN_POINTWISE_RSQRT,
6812 
6814  MIOPEN_POINTWISE_SIN,
6815 
6817  MIOPEN_POINTWISE_SQRT,
6818 
6820  MIOPEN_POINTWISE_TAN,
6821 
6823  MIOPEN_POINTWISE_ERF,
6824 
6828  MIOPEN_POINTWISE_IDENTITY,
6829 
6831  MIOPEN_POINTWISE_RELU_FWD,
6832 
6834  MIOPEN_POINTWISE_TANH_FWD,
6835 
6837  MIOPEN_POINTWISE_SIGMOID_FWD,
6838 
6840  MIOPEN_POINTWISE_ELU_FWD,
6841 
6844  MIOPEN_POINTWISE_GELU_FWD,
6845 
6847  MIOPEN_POINTWISE_SOFTPLUS_FWD,
6848 
6850  MIOPEN_POINTWISE_SWISH_FWD,
6851 
6855  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,
6856 
6859  MIOPEN_POINTWISE_RELU_BWD,
6860 
6862  MIOPEN_POINTWISE_TANH_BWD,
6863 
6865  MIOPEN_POINTWISE_SIGMOID_BWD,
6866 
6869  MIOPEN_POINTWISE_ELU_BWD,
6870 
6873  MIOPEN_POINTWISE_GELU_BWD,
6874 
6876  MIOPEN_POINTWISE_SOFTPLUS_BWD,
6877 
6879  MIOPEN_POINTWISE_SWISH_BWD,
6880 
6886  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,
6887 
6889  MIOPEN_POINTWISE_CMP_EQ,
6890 
6892  MIOPEN_POINTWISE_CMP_NEQ,
6893 
6895  MIOPEN_POINTWISE_CMP_GT,
6896 
6899  MIOPEN_POINTWISE_CMP_GE,
6900 
6902  MIOPEN_POINTWISE_CMP_LT,
6903 
6906  MIOPEN_POINTWISE_CMP_LE,
6907 
6909  MIOPEN_POINTWISE_LOGICAL_AND,
6910 
6912  MIOPEN_POINTWISE_LOGICAL_OR,
6913 
6915  MIOPEN_POINTWISE_LOGICAL_NOT,
6916 
6918  MIOPEN_POINTWISE_GEN_INDEX,
6919 
6922  MIOPEN_POINTWISE_BINARY_SELECT,
6923 
6926  MIOPEN_POINTWISE_RECIPROCAL
6927 } miopenPointwiseMode_t;
6928 
6934 typedef enum
6935 {
6936  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,
6937  MIOPEN_RNG_DISTRIBUTION_UNIFORM,
6938  MIOPEN_RNG_DISTRIBUTION_NORMAL,
6939 } miopenRngDistribution_t;
6940 
6941 typedef enum
6942 {
6943  /* IDENTITY alpha = 1.0 and beta = 0.0 */
6944  /* SCALE alpha = 4.2 and beta = 0.0 */
6945  /* BILINEAR alpha = 3.2 and beta = 1.1 */
6946  /* ERROR_STATE alpha = 0.0 and beta = 3.1 */
6947 
6948  DEFAULT = 0, /* alpha = 1.0 and beta = 0.0.*/
6949  SCALE = 1, /* alpha with some value and beta 0.0*/
6950  BILINEAR = 2, /* both alpha and beta with some value*/
6951  ERROR_STATE = 3, /* alpha 0.0 and beta with some value, this should not occur.
6952  But used to check for errors.*/
6953 } miopenAlphaBetaCase_t;
6958 typedef enum
6959 {
6960  MIOPEN_HEUR_MODE_INSTANT = 0,
6961  MIOPEN_HEUR_MODE_B = 1,
6962  MIOPEN_HEUR_MODE_FALLBACK = 2,
6963  MIOPEN_HEUR_MODE_A = 3,
6964  MIOPEN_HEUR_MODES_COUNT = 4,
6965 } miopenBackendHeurMode_t;
6966 
6979 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)
6980 
6981 
6994 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(
6995  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);
6996 
7026 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,
7027  miopenBackendAttributeName_t attributeName,
7028  miopenBackendAttributeType_t attributeType,
7029  int64_t elementCount,
7030  void* arrayOfElements);
7031 
7048 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);
7049 
7084 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,
7085  miopenBackendAttributeName_t attributeName,
7086  miopenBackendAttributeType_t attributeType,
7087  int64_t requestedElementCount,
7088  int64_t* elementCount,
7089  void* arrayOfElements);
7090 
7110 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,
7111  miopenBackendDescriptor_t executionPlan,
7112  miopenBackendDescriptor_t variantPack);
7113 
7130 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);
7131 
7149 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,
7150  miopenBackendDescriptorType_t descriptorType,
7151  size_t sizeInBytes);
7152 
7154 // CLOSEOUT BackendAPI DOXYGEN GROUP
7155 #endif // MIOPEN_BETA_API
7156 
7157 #ifdef MIOPEN_BETA_API
7158 // FusedAdam APIs
7301 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,
7302  const miopenTensorDescriptor_t paramDesc,
7303  void* param,
7304  const miopenTensorDescriptor_t gradDesc,
7305  const void* grad,
7306  const miopenTensorDescriptor_t expAvgDesc,
7307  void* expAvg,
7308  const miopenTensorDescriptor_t expAvgSqDesc,
7309  void* expAvgSq,
7310  const miopenTensorDescriptor_t maxExpAvgSqDesc,
7311  void* maxExpAvgSq,
7312  const miopenTensorDescriptor_t stateStepDesc,
7313  void* stateStep,
7314  const unsigned int state_step,
7315  const float lr,
7316  const float beta1,
7317  const float beta2,
7318  const float weight_decay,
7319  const float eps,
7320  const bool amsgrad,
7321  const bool maximize,
7322  const bool adamw,
7323  const miopenTensorDescriptor_t gradScaleDesc,
7324  const void* gradScale,
7325  const miopenTensorDescriptor_t foundInfDesc,
7326  const void* foundInf);
7327 
7468 MIOPEN_EXPORT miopenStatus_t
7469 miopenFusedAdamWithOutput(miopenHandle_t handle,
7470  const miopenTensorDescriptor_t paramInDesc,
7471  void* paramIn,
7472  const miopenTensorDescriptor_t paramOutDesc,
7473  void* paramOut,
7474  const miopenTensorDescriptor_t paramOutFloat16Desc,
7475  void* paramOutFloat16,
7476  const miopenTensorDescriptor_t gradInDesc,
7477  const void* gradIn,
7478  const miopenTensorDescriptor_t expAvgInDesc,
7479  void* expAvgIn,
7480  const miopenTensorDescriptor_t expAvgOutDesc,
7481  void* expAvgOut,
7482  const miopenTensorDescriptor_t expAvgSqInDesc,
7483  void* expAvgSqIn,
7484  const miopenTensorDescriptor_t expAvgSqOutDesc,
7485  void* expAvgSqOut,
7486  const miopenTensorDescriptor_t maxExpAvgSqInDesc,
7487  void* maxExpAvgSqIn,
7488  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,
7489  void* maxExpAvgSqOut,
7490  const miopenTensorDescriptor_t stateStepInDesc,
7491  void* stateStepIn,
7492  const miopenTensorDescriptor_t stateStepOutDesc,
7493  void* stateStepOut,
7494  const unsigned int state_step,
7495  const float lr,
7496  const float beta1,
7497  const float beta2,
7498  const float weight_decay,
7499  const float eps,
7500  const bool amsgrad,
7501  const bool maximize,
7502  const bool adamw,
7503  const miopenTensorDescriptor_t gradScaleDesc,
7504  const void* gradScale,
7505  const miopenTensorDescriptor_t foundInfDesc,
7506  const void* foundInf);
7507 
7509 // CLOSEOUT SGD DOXYGEN GROUP
7510 #endif // MIOPEN_BETA_API
7511 
7512 #ifdef MIOPEN_BETA_API
7513 // TransformersAdamW APIs
7604 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,
7605  const miopenTensorDescriptor_t paramDesc,
7606  void* param,
7607  const miopenTensorDescriptor_t gradDesc,
7608  const void* grad,
7609  const miopenTensorDescriptor_t expAvgDesc,
7610  void* expAvg,
7611  const miopenTensorDescriptor_t expAvgSqDesc,
7612  void* expAvgSq,
7613  const miopenTensorDescriptor_t stateStepDesc,
7614  void* stateStep,
7615  const unsigned int state_step,
7616  const float lr,
7617  const float beta1,
7618  const float beta2,
7619  const float weight_decay,
7620  const float eps,
7621  const bool correct_bias,
7622  const miopenTensorDescriptor_t gradScaleDesc,
7623  const void* gradScale,
7624  const miopenTensorDescriptor_t foundInfDesc,
7625  const void* foundInf);
7626 
7753 MIOPEN_EXPORT miopenStatus_t
7754 miopenTransformersAdamWWithOutput(miopenHandle_t handle,
7755  const miopenTensorDescriptor_t paramInDesc,
7756  void* paramIn,
7757  const miopenTensorDescriptor_t paramOutDesc,
7758  void* paramOut,
7759  const miopenTensorDescriptor_t paramOutFloat16Desc,
7760  void* paramOutFloat16,
7761  const miopenTensorDescriptor_t gradInDesc,
7762  const void* gradIn,
7763  const miopenTensorDescriptor_t expAvgInDesc,
7764  void* expAvgIn,
7765  const miopenTensorDescriptor_t expAvgOutDesc,
7766  void* expAvgOut,
7767  const miopenTensorDescriptor_t expAvgSqInDesc,
7768  void* expAvgSqIn,
7769  const miopenTensorDescriptor_t expAvgSqOutDesc,
7770  void* expAvgSqOut,
7771  const miopenTensorDescriptor_t stateStepInDesc,
7772  void* stateStepIn,
7773  const miopenTensorDescriptor_t stateStepOutDesc,
7774  void* stateStepOut,
7775  const unsigned int state_step,
7776  const float lr,
7777  const float beta1,
7778  const float beta2,
7779  const float weight_decay,
7780  const float eps,
7781  const float step_size,
7782  const bool correct_bias,
7783  const miopenTensorDescriptor_t gradScaleDesc,
7784  const void* gradScale,
7785  const miopenTensorDescriptor_t foundInfDesc,
7786  const void* foundInf);
7787 
7789 // CLOSEOUT SGD DOXYGEN GROUP
7790 #endif // MIOPEN_BETA_API
7791 
7792 #ifdef MIOPEN_BETA_API
7793 // GetItem APIs
7806 MIOPEN_EXPORT miopenStatus_t
7807 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,
7808  uint32_t indexCount,
7809  const miopenTensorDescriptor_t* indexDescs,
7810  size_t* sizeInBytes);
7811 
7836 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,
7837  void* workspace,
7838  size_t workspaceSizeInBytes,
7839  const miopenTensorDescriptor_t dyDesc,
7840  const void* dy,
7841  uint32_t indexCount,
7842  const miopenTensorDescriptor_t* indexDescs,
7843  const void* const* indexs,
7844  const miopenTensorDescriptor_t dxDesc,
7845  void* dx,
7846  const miopenTensorDescriptor_t errorDesc,
7847  void* error,
7848  uint32_t dimCount,
7849  const int32_t* dims,
7850  uint32_t sliceCount,
7851  const int32_t* slices,
7852  uint32_t offset);
7853 
7855 // CLOSEOUT GETITEM DOXYGEN GROUP
7856 #endif // MIOPEN_BETA_API
7857 
7858 #ifdef MIOPEN_BETA_API
7859 // RotaryPositionalEmbeddings APIs
7877 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,
7878  const miopenTensorDescriptor_t xDesc,
7879  const void* x,
7880  const miopenTensorDescriptor_t cosDesc,
7881  const void* cos,
7882  const miopenTensorDescriptor_t sinDesc,
7883  const void* sin,
7884  const miopenTensorDescriptor_t yDesc,
7885  void* y);
7886 
7900 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,
7901  const miopenTensorDescriptor_t dyDesc,
7902  const void* dy,
7903  const miopenTensorDescriptor_t cosDesc,
7904  const void* cos,
7905  const miopenTensorDescriptor_t sinDesc,
7906  const void* sin,
7907  const miopenTensorDescriptor_t dxDesc,
7908  void* dx);
7910 // CLOSEOUT ROPE DOXYGEN GROUP
7911 // kthvalue APIs
7932 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,
7933  miopenTensorDescriptor_t inputDesc,
7934  const void* input,
7935  miopenTensorDescriptor_t outputDesc,
7936  void* output,
7937  miopenTensorDescriptor_t indicesDesc,
7938  size_t* indices,
7939  size_t k,
7940  int32_t dim = -1,
7941  bool keepDim = false);
7942 
7944 // CLOSEOUT kthvalue DOXYGEN GROUP
7945 #endif // MIOPEN_BETA_API
7946 
7947 #ifdef MIOPEN_BETA_API
7961 MIOPEN_EXPORT miopenStatus_t
7962 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,
7963  miopenTensorDescriptor_t inputDesc,
7964  miopenTensorDescriptor_t weightDesc,
7965  size_t* sizeInBytes);
7966 
7983 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,
7984  void* workspace,
7985  size_t workspaceSizeInBytes,
7986  miopenTensorDescriptor_t inputDesc,
7987  const void* input,
7988  miopenTensorDescriptor_t weightDesc,
7989  const void* weight,
7990  miopenTensorDescriptor_t doutputDesc,
7991  const void* doutput,
7992  miopenTensorDescriptor_t dinputDesc,
7993  void* dinput,
7994  miopenTensorDescriptor_t dweightDesc,
7995  void* dweight);
7996 
7998 // CLOSEOUT RELU DOXYGEN GROUP
7999 #endif // MIOPEN_BETA_API
8000 
8001 #ifdef MIOPEN_BETA_API
8002 
8007 typedef enum
8008 {
8009  MIOPEN_LOSS_REDUCTION_NONE = 0,
8010  MIOPEN_LOSS_REDUCTION_SUM = 1,
8011  MIOPEN_LOSS_REDUCTION_MEAN = 2,
8013 } miopenLossReductionMode_t;
8014 
8015 // SoftMarginLoss APIs
8033 MIOPEN_EXPORT miopenStatus_t
8034 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8035  miopenTensorDescriptor_t inputDesc,
8036  miopenTensorDescriptor_t targetDesc,
8037  miopenTensorDescriptor_t outputDesc,
8038  miopenLossReductionMode_t reduction,
8039  size_t* sizeInBytes);
8040 
8057 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,
8058  miopenTensorDescriptor_t inputDesc,
8059  const void* input,
8060  miopenTensorDescriptor_t targetDesc,
8061  const void* target,
8062  miopenTensorDescriptor_t outputDesc,
8063  void* output,
8064  miopenLossReductionMode_t reduction,
8065  void* workspace = nullptr,
8066  size_t workspaceSizeInBytes = 0);
8067 
8082 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,
8083  miopenTensorDescriptor_t inputDesc,
8084  const void* input,
8085  miopenTensorDescriptor_t targetDesc,
8086  const void* target,
8087  miopenTensorDescriptor_t doutputDesc,
8088  const void* doutput,
8089  miopenTensorDescriptor_t dinputDesc,
8090  void* dinput,
8091  miopenLossReductionMode_t reduction);
8092 
8094 // CLOSEOUT LossFunction DOXYGEN GROUP
8095 #endif
8096 
8097 #ifdef MIOPEN_BETA_API
8098 // MultiMarginLoss APIs
8122 MIOPEN_EXPORT miopenStatus_t
8123 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8124  miopenTensorDescriptor_t inputDesc,
8125  miopenTensorDescriptor_t targetDesc,
8126  miopenTensorDescriptor_t weightDesc,
8127  miopenTensorDescriptor_t outputDesc,
8128  long p,
8129  float margin,
8130  miopenLossReductionMode_t reduction,
8131  size_t* sizeInBytes);
8132 
8160 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,
8161  miopenTensorDescriptor_t inputDesc,
8162  const void* input,
8163  miopenTensorDescriptor_t targetDesc,
8164  const void* target,
8165  miopenTensorDescriptor_t weightDesc,
8166  const void* weight,
8167  miopenTensorDescriptor_t outputDesc,
8168  void* output,
8169  long p,
8170  float margin,
8171  miopenLossReductionMode_t reduction,
8172  void* workspace,
8173  size_t workspaceSizeInBytes);
8174 
8176 // CLOSEOUT LossFunction DOXYGEN GROUP
8177 #endif // MIOPEN_BETA_API
8178 
8179 #ifdef __cplusplus
8180 }
8181 #endif
8182 
8183 #ifdef __clang__
8184 #pragma clang diagnostic pop
8185 #endif
8186 
8187 #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.
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.
miopenFusionDirection_t
miopenFusionDirection_t
Kernel fusion direction in the network.
Definition: miopen.h:3295
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:3297
miopenVerticalFusion
@ miopenVerticalFusion
Definition: miopen.h:3296
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:6959
miopenPointwiseMode_t
miopenPointwiseMode_t
Intended poinwise math operation for a pointwise operation descriptor.
Definition: miopen.h:6759
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:6466
miopenRngDistribution_t
miopenRngDistribution_t
Distribution for random number generation.
Definition: miopen.h:6935
miopenBackendDescriptorType_t
miopenBackendDescriptorType_t
Descriptor type.
Definition: miopen.h:6423
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:6942
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:6720
MIOPEN_HEUR_MODE_INSTANT
@ MIOPEN_HEUR_MODE_INSTANT
Definition: miopen.h:6960
MIOPEN_HEUR_MODE_A
@ MIOPEN_HEUR_MODE_A
Definition: miopen.h:6963
MIOPEN_HEUR_MODE_B
@ MIOPEN_HEUR_MODE_B
Definition: miopen.h:6961
MIOPEN_HEUR_MODES_COUNT
@ MIOPEN_HEUR_MODES_COUNT
Definition: miopen.h:6964
MIOPEN_HEUR_MODE_FALLBACK
@ MIOPEN_HEUR_MODE_FALLBACK
Definition: miopen.h:6962
MIOPEN_POINTWISE_SOFTPLUS_FWD
@ MIOPEN_POINTWISE_SOFTPLUS_FWD
Definition: miopen.h:6847
MIOPEN_POINTWISE_ELU_FWD
@ MIOPEN_POINTWISE_ELU_FWD
Definition: miopen.h:6840
MIOPEN_POINTWISE_RELU_FWD
@ MIOPEN_POINTWISE_RELU_FWD
Definition: miopen.h:6831
MIOPEN_POINTWISE_DIV
@ MIOPEN_POINTWISE_DIV
Definition: miopen.h:6768
MIOPEN_POINTWISE_SIGMOID_BWD
@ MIOPEN_POINTWISE_SIGMOID_BWD
Definition: miopen.h:6865
MIOPEN_POINTWISE_POW
@ MIOPEN_POINTWISE_POW
Definition: miopen.h:6784
MIOPEN_POINTWISE_MOD
@ MIOPEN_POINTWISE_MOD
Definition: miopen.h:6778
MIOPEN_POINTWISE_SQRT
@ MIOPEN_POINTWISE_SQRT
Definition: miopen.h:6817
MIOPEN_POINTWISE_BINARY_SELECT
@ MIOPEN_POINTWISE_BINARY_SELECT
Definition: miopen.h:6922
MIOPEN_POINTWISE_GELU_BWD
@ MIOPEN_POINTWISE_GELU_BWD
Definition: miopen.h:6873
MIOPEN_POINTWISE_MIN
@ MIOPEN_POINTWISE_MIN
Definition: miopen.h:6774
MIOPEN_POINTWISE_CMP_NEQ
@ MIOPEN_POINTWISE_CMP_NEQ
Definition: miopen.h:6892
MIOPEN_POINTWISE_FLOOR
@ MIOPEN_POINTWISE_FLOOR
Definition: miopen.h:6802
MIOPEN_POINTWISE_RSQRT
@ MIOPEN_POINTWISE_RSQRT
Definition: miopen.h:6811
MIOPEN_POINTWISE_CMP_EQ
@ MIOPEN_POINTWISE_CMP_EQ
Definition: miopen.h:6889
MIOPEN_POINTWISE_CMP_GE
@ MIOPEN_POINTWISE_CMP_GE
Definition: miopen.h:6899
MIOPEN_POINTWISE_ADD_SQUARE
@ MIOPEN_POINTWISE_ADD_SQUARE
Definition: miopen.h:6765
MIOPEN_POINTWISE_ERF
@ MIOPEN_POINTWISE_ERF
Definition: miopen.h:6823
MIOPEN_POINTWISE_SWISH_FWD
@ MIOPEN_POINTWISE_SWISH_FWD
Definition: miopen.h:6850
MIOPEN_POINTWISE_LOG
@ MIOPEN_POINTWISE_LOG
Definition: miopen.h:6805
MIOPEN_POINTWISE_SUB
@ MIOPEN_POINTWISE_SUB
Definition: miopen.h:6787
MIOPEN_POINTWISE_NEG
@ MIOPEN_POINTWISE_NEG
Definition: miopen.h:6808
MIOPEN_POINTWISE_LOGICAL_AND
@ MIOPEN_POINTWISE_LOGICAL_AND
Definition: miopen.h:6909
MIOPEN_POINTWISE_SWISH_BWD
@ MIOPEN_POINTWISE_SWISH_BWD
Definition: miopen.h:6879
MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
Definition: miopen.h:6855
MIOPEN_POINTWISE_SIN
@ MIOPEN_POINTWISE_SIN
Definition: miopen.h:6814
MIOPEN_POINTWISE_RECIPROCAL
@ MIOPEN_POINTWISE_RECIPROCAL
Definition: miopen.h:6926
MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
Definition: miopen.h:6886
MIOPEN_POINTWISE_GELU_FWD
@ MIOPEN_POINTWISE_GELU_FWD
Definition: miopen.h:6844
MIOPEN_POINTWISE_ABS
@ MIOPEN_POINTWISE_ABS
Definition: miopen.h:6790
MIOPEN_POINTWISE_CMP_LT
@ MIOPEN_POINTWISE_CMP_LT
Definition: miopen.h:6902
MIOPEN_POINTWISE_EXP
@ MIOPEN_POINTWISE_EXP
Definition: miopen.h:6799
MIOPEN_POINTWISE_GEN_INDEX
@ MIOPEN_POINTWISE_GEN_INDEX
Definition: miopen.h:6918
MIOPEN_POINTWISE_CEIL
@ MIOPEN_POINTWISE_CEIL
Definition: miopen.h:6793
MIOPEN_POINTWISE_LOGICAL_NOT
@ MIOPEN_POINTWISE_LOGICAL_NOT
Definition: miopen.h:6915
MIOPEN_POINTWISE_SIGMOID_FWD
@ MIOPEN_POINTWISE_SIGMOID_FWD
Definition: miopen.h:6837
MIOPEN_POINTWISE_SOFTPLUS_BWD
@ MIOPEN_POINTWISE_SOFTPLUS_BWD
Definition: miopen.h:6876
MIOPEN_POINTWISE_LOGICAL_OR
@ MIOPEN_POINTWISE_LOGICAL_OR
Definition: miopen.h:6912
MIOPEN_POINTWISE_TAN
@ MIOPEN_POINTWISE_TAN
Definition: miopen.h:6820
MIOPEN_POINTWISE_ELU_BWD
@ MIOPEN_POINTWISE_ELU_BWD
Definition: miopen.h:6869
MIOPEN_POINTWISE_IDENTITY
@ MIOPEN_POINTWISE_IDENTITY
Definition: miopen.h:6828
MIOPEN_POINTWISE_CMP_LE
@ MIOPEN_POINTWISE_CMP_LE
Definition: miopen.h:6906
MIOPEN_POINTWISE_COS
@ MIOPEN_POINTWISE_COS
Definition: miopen.h:6796
MIOPEN_POINTWISE_TANH_BWD
@ MIOPEN_POINTWISE_TANH_BWD
Definition: miopen.h:6862
MIOPEN_POINTWISE_MUL
@ MIOPEN_POINTWISE_MUL
Definition: miopen.h:6781
MIOPEN_POINTWISE_TANH_FWD
@ MIOPEN_POINTWISE_TANH_FWD
Definition: miopen.h:6834
MIOPEN_POINTWISE_RELU_BWD
@ MIOPEN_POINTWISE_RELU_BWD
Definition: miopen.h:6859
MIOPEN_POINTWISE_ADD
@ MIOPEN_POINTWISE_ADD
Definition: miopen.h:6761
MIOPEN_POINTWISE_MAX
@ MIOPEN_POINTWISE_MAX
Definition: miopen.h:6771
MIOPEN_POINTWISE_CMP_GT
@ MIOPEN_POINTWISE_CMP_GT
Definition: miopen.h:6895
MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
Definition: miopen.h:6683
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
Definition: miopen.h:6513
MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
Definition: miopen.h:6637
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
Definition: miopen.h:6640
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
Definition: miopen.h:6519
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
Definition: miopen.h:6510
MIOPEN_ATTR_OPERATION_SIGNAL_MODE
@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE
Definition: miopen.h:6661
MIOPEN_ATTR_OPERATION_RNG_DESC
@ MIOPEN_ATTR_OPERATION_RNG_DESC
Definition: miopen.h:6707
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
Definition: miopen.h:6511
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
Definition: miopen.h:6624
MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
Definition: miopen.h:6686
MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
Definition: miopen.h:6674
MIOPEN_ATTR_OPERATIONGRAPH_OPS
@ MIOPEN_ATTR_OPERATIONGRAPH_OPS
Definition: miopen.h:6563
MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
Definition: miopen.h:6587
MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
Definition: miopen.h:6482
MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
Definition: miopen.h:6665
MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
Definition: miopen.h:6690
MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
Definition: miopen.h:6693
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
Definition: miopen.h:6654
MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
Definition: miopen.h:6483
MIOPEN_ATTR_REDUCTION_OPERATOR
@ MIOPEN_ATTR_REDUCTION_OPERATOR
Definition: miopen.h:6611
MIOPEN_ATTR_OPERATION_MATMUL_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_DESC
Definition: miopen.h:6605
MIOPEN_ATTR_CONVOLUTION_DILATIONS
@ MIOPEN_ATTR_CONVOLUTION_DILATIONS
Definition: miopen.h:6480
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
Definition: miopen.h:6648
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
Definition: miopen.h:6532
MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
Definition: miopen.h:6632
MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
Definition: miopen.h:6498
MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
Definition: miopen.h:6670
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
Definition: miopen.h:6552
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
Definition: miopen.h:6620
MIOPEN_ATTR_KNOB_INFO_TYPE
@ MIOPEN_ATTR_KNOB_INFO_TYPE
Definition: miopen.h:6586
MIOPEN_ATTR_LAYOUT_INFO_TYPES
@ MIOPEN_ATTR_LAYOUT_INFO_TYPES
Definition: miopen.h:6584
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
Definition: miopen.h:6546
MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
Definition: miopen.h:6562
MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
Definition: miopen.h:6687
MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
Definition: miopen.h:6702
MIOPEN_ATTR_POINTWISE_MATH_PREC
@ MIOPEN_ATTR_POINTWISE_MATH_PREC
Definition: miopen.h:6468
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
Definition: miopen.h:6608
MIOPEN_ATTR_OPERATION_GENSTATS_MODE
@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE
Definition: miopen.h:6538
MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
Definition: miopen.h:6508
MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
Definition: miopen.h:6580
MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
Definition: miopen.h:6615
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
Definition: miopen.h:6523
MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
Definition: miopen.h:6581
MIOPEN_ATTR_TENSOR_IS_BY_VALUE
@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE
Definition: miopen.h:6574
MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
Definition: miopen.h:6667
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
Definition: miopen.h:6512
MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
Definition: miopen.h:6544
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
Definition: miopen.h:6677
MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
Definition: miopen.h:6695
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
Definition: miopen.h:6653
MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
Definition: miopen.h:6529
MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
Definition: miopen.h:6578
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
Definition: miopen.h:6623
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
Definition: miopen.h:6643
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
Definition: miopen.h:6548
MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
Definition: miopen.h:6663
MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
Definition: miopen.h:6662
MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
Definition: miopen.h:6536
MIOPEN_ATTR_ENGINEHEUR_RESULTS
@ MIOPEN_ATTR_ENGINEHEUR_RESULTS
Definition: miopen.h:6488
MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
Definition: miopen.h:6566
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
Definition: miopen.h:6526
MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
Definition: miopen.h:6558
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
Definition: miopen.h:6628
MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
Definition: miopen.h:6539
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
Definition: miopen.h:6676
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
Definition: miopen.h:6556
MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
Definition: miopen.h:6495
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
Definition: miopen.h:6622
MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
Definition: miopen.h:6659
MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
Definition: miopen.h:6689
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
Definition: miopen.h:6517
MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
Definition: miopen.h:6497
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
Definition: miopen.h:6520
MIOPEN_ATTR_TENSOR_VECTOR_COUNT
@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT
Definition: miopen.h:6570
MIOPEN_ATTR_OPERATION_MATMUL_CDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC
Definition: miopen.h:6604
MIOPEN_ATTR_REDUCTION_COMP_TYPE
@ MIOPEN_ATTR_REDUCTION_COMP_TYPE
Definition: miopen.h:6612
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
Definition: miopen.h:6651
MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
Definition: miopen.h:6571
MIOPEN_ATTR_TENSOR_DIMENSIONS
@ MIOPEN_ATTR_TENSOR_DIMENSIONS
Definition: miopen.h:6568
MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
Definition: miopen.h:6541
MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
Definition: miopen.h:6658
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
Definition: miopen.h:6533
MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
Definition: miopen.h:6594
MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
Definition: miopen.h:6596
MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
Definition: miopen.h:6500
MIOPEN_ATTR_RESAMPLE_STRIDES
@ MIOPEN_ATTR_RESAMPLE_STRIDES
Definition: miopen.h:6635
MIOPEN_ATTR_POINTWISE_ELU_ALPHA
@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA
Definition: miopen.h:6473
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
Definition: miopen.h:6679
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
Definition: miopen.h:6649
MIOPEN_ATTR_OPERATION_RNG_SEED
@ MIOPEN_ATTR_OPERATION_RNG_SEED
Definition: miopen.h:6706
MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
Definition: miopen.h:6684
MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
Definition: miopen.h:6534
MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
Definition: miopen.h:6657
MIOPEN_ATTR_RESAMPLE_MODE
@ MIOPEN_ATTR_RESAMPLE_MODE
Definition: miopen.h:6630
MIOPEN_ATTR_RNG_DISTRIBUTION
@ MIOPEN_ATTR_RNG_DISTRIBUTION
Definition: miopen.h:6698
MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
Definition: miopen.h:6685
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
Definition: miopen.h:6607
MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
Definition: miopen.h:6668
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
Definition: miopen.h:6472
MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
Definition: miopen.h:6696
MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
Definition: miopen.h:6579
MIOPEN_ATTR_POINTWISE_AXIS
@ MIOPEN_ATTR_POINTWISE_AXIS
Definition: miopen.h:6476
MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
Definition: miopen.h:6680
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
Definition: miopen.h:6470
MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
Definition: miopen.h:6591
MIOPEN_ATTR_OPERATION_MATMUL_BDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC
Definition: miopen.h:6603
MIOPEN_ATTR_TENSOR_DATA_TYPE
@ MIOPEN_ATTR_TENSOR_DATA_TYPE
Definition: miopen.h:6567
MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
Definition: miopen.h:6664
MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
Definition: miopen.h:6588
MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
Definition: miopen.h:6673
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
Definition: miopen.h:6645
MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
Definition: miopen.h:6634
MIOPEN_ATTR_MATMUL_COMP_TYPE
@ MIOPEN_ATTR_MATMUL_COMP_TYPE
Definition: miopen.h:6599
MIOPEN_ATTR_TENSOR_UNIQUE_ID
@ MIOPEN_ATTR_TENSOR_UNIQUE_ID
Definition: miopen.h:6572
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
Definition: miopen.h:6626
MIOPEN_ATTR_OPERATION_CONCAT_AXIS
@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS
Definition: miopen.h:6656
MIOPEN_ATTR_OPERATION_RNG_YDESC
@ MIOPEN_ATTR_OPERATION_RNG_YDESC
Definition: miopen.h:6705
MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
Definition: miopen.h:6592
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
Definition: miopen.h:6518
MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
Definition: miopen.h:6487
MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
Definition: miopen.h:6576
MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
Definition: miopen.h:6474
MIOPEN_ATTR_TENSOR_IS_VIRTUAL
@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL
Definition: miopen.h:6573
MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
Definition: miopen.h:6493
MIOPEN_ATTR_MATMUL_PADDING_VALUE
@ MIOPEN_ATTR_MATMUL_PADDING_VALUE
Definition: miopen.h:6600
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
Definition: miopen.h:6560
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
Definition: miopen.h:6555
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
Definition: miopen.h:6514
MIOPEN_ATTR_KNOB_INFO_STRIDE
@ MIOPEN_ATTR_KNOB_INFO_STRIDE
Definition: miopen.h:6589
MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
Definition: miopen.h:6636
MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
Definition: miopen.h:6531
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
Definition: miopen.h:6641
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
Definition: miopen.h:6621
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
Definition: miopen.h:6521
MIOPEN_ATTR_CONVOLUTION_CONV_MODE
@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE
Definition: miopen.h:6479
MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
Definition: miopen.h:6614
MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
Definition: miopen.h:6499
MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
Definition: miopen.h:6545
MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
Definition: miopen.h:6597
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
Definition: miopen.h:6557
MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
Definition: miopen.h:6507
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
Definition: miopen.h:6647
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
Definition: miopen.h:6550
MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
Definition: miopen.h:6535
MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
Definition: miopen.h:6675
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
Definition: miopen.h:6627
MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
Definition: miopen.h:6708
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
Definition: miopen.h:6515
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
Definition: miopen.h:6551
MIOPEN_ATTR_ENGINE_LAYOUT_INFO
@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO
Definition: miopen.h:6595
MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
Definition: miopen.h:6502
MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
Definition: miopen.h:6478
MIOPEN_ATTR_RESAMPLE_COMP_TYPE
@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE
Definition: miopen.h:6631
MIOPEN_ATTR_ENGINECFG_ENGINE
@ MIOPEN_ATTR_ENGINECFG_ENGINE
Definition: miopen.h:6491
MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
Definition: miopen.h:6633
MIOPEN_ATTR_RESAMPLE_PADDING_MODE
@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE
Definition: miopen.h:6638
MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
Definition: miopen.h:6484
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
Definition: miopen.h:6678
MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
Definition: miopen.h:6540
MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
Definition: miopen.h:6671
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
Definition: miopen.h:6547
MIOPEN_ATTR_ENGINE_KNOB_INFO
@ MIOPEN_ATTR_ENGINE_KNOB_INFO
Definition: miopen.h:6593
MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
Definition: miopen.h:6606
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
Definition: miopen.h:6525
MIOPEN_ATTR_TENSOR_REORDERING_MODE
@ MIOPEN_ATTR_TENSOR_REORDERING_MODE
Definition: miopen.h:6575
MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
Definition: miopen.h:6503
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
Definition: miopen.h:6609
MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
Definition: miopen.h:6528
MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
Definition: miopen.h:6700
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
Definition: miopen.h:6504
MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
Definition: miopen.h:6583
MIOPEN_ATTR_ENGINEHEUR_MODE
@ MIOPEN_ATTR_ENGINEHEUR_MODE
Definition: miopen.h:6486
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
Definition: miopen.h:6650
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
Definition: miopen.h:6652
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
Definition: miopen.h:6559
MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
Definition: miopen.h:6530
MIOPEN_ATTR_POINTWISE_MODE
@ MIOPEN_ATTR_POINTWISE_MODE
Definition: miopen.h:6467
MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
Definition: miopen.h:6492
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
Definition: miopen.h:6527
MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
Definition: miopen.h:6692
MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
Definition: miopen.h:6469
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
Definition: miopen.h:6505
MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
Definition: miopen.h:6471
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
Definition: miopen.h:6625
MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
Definition: miopen.h:6703
MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
Definition: miopen.h:6489
MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
Definition: miopen.h:6549
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
Definition: miopen.h:6553
MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
Definition: miopen.h:6699
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
Definition: miopen.h:6618
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
Definition: miopen.h:6619
MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
Definition: miopen.h:6681
MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
Definition: miopen.h:6672
MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
Definition: miopen.h:6542
MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
Definition: miopen.h:6496
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
Definition: miopen.h:6644
MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
Definition: miopen.h:6691
MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
Definition: miopen.h:6688
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
Definition: miopen.h:6516
MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
Definition: miopen.h:6701
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
Definition: miopen.h:6524
MIOPEN_ATTR_TENSOR_STRIDES
@ MIOPEN_ATTR_TENSOR_STRIDES
Definition: miopen.h:6569
MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
Definition: miopen.h:6481
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
Definition: miopen.h:6522
MIOPEN_ATTR_POINTWISE_SWISH_BETA
@ MIOPEN_ATTR_POINTWISE_SWISH_BETA
Definition: miopen.h:6475
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
Definition: miopen.h:6642
MIOPEN_ATTR_OPERATION_REDUCTION_DESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC
Definition: miopen.h:6616
MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
Definition: miopen.h:6669
MIOPEN_ATTR_OPERATION_MATMUL_ADESC
@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC
Definition: miopen.h:6602
MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
Definition: miopen.h:6564
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
Definition: miopen.h:6554
MIOPEN_RNG_DISTRIBUTION_BERNOULLI
@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI
Definition: miopen.h:6936
MIOPEN_RNG_DISTRIBUTION_UNIFORM
@ MIOPEN_RNG_DISTRIBUTION_UNIFORM
Definition: miopen.h:6937
MIOPEN_RNG_DISTRIBUTION_NORMAL
@ MIOPEN_RNG_DISTRIBUTION_NORMAL
Definition: miopen.h:6938
MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
Definition: miopen.h:6434
MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
Definition: miopen.h:6452
MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
Definition: miopen.h:6426
MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
Definition: miopen.h:6450
MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
Definition: miopen.h:6445
MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
Definition: miopen.h:6424
MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
Definition: miopen.h:6447
MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
Definition: miopen.h:6431
MIOPEN_BACKEND_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_RNG_DESCRIPTOR
Definition: miopen.h:6453
MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
Definition: miopen.h:6442
MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
Definition: miopen.h:6441
MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
Definition: miopen.h:6427
MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
Definition: miopen.h:6446
MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
Definition: miopen.h:6432
MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
Definition: miopen.h:6443
MIOPEN_BACKEND_TENSOR_DESCRIPTOR
@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR
Definition: miopen.h:6454
MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
Definition: miopen.h:6444
MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
Definition: miopen.h:6449
MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
Definition: miopen.h:6437
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
Definition: miopen.h:6436
MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
Definition: miopen.h:6429
MIOPEN_BACKEND_ENGINE_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR
Definition: miopen.h:6425
MIOPEN_BACKEND_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR
Definition: miopen.h:6433
MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
Definition: miopen.h:6438
MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
Definition: miopen.h:6455
MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
Definition: miopen.h:6451
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
Definition: miopen.h:6435
MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
Definition: miopen.h:6439
MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
Definition: miopen.h:6440
MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
Definition: miopen.h:6448
MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
Definition: miopen.h:6428
MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
Definition: miopen.h:6430
SCALE
@ SCALE
Definition: miopen.h:6949
BILINEAR
@ BILINEAR
Definition: miopen.h:6950
DEFAULT
@ DEFAULT
Definition: miopen.h:6948
ERROR_STATE
@ ERROR_STATE
Definition: miopen.h:6951
MIOPEN_TYPE_RNG_DISTRIBUTION
@ MIOPEN_TYPE_RNG_DISTRIBUTION
Definition: miopen.h:6750
MIOPEN_TYPE_FLOAT
@ MIOPEN_TYPE_FLOAT
Definition: miopen.h:6725
MIOPEN_TYPE_NUMERICAL_NOTE
@ MIOPEN_TYPE_NUMERICAL_NOTE
Definition: miopen.h:6732
MIOPEN_TYPE_RESAMPLE_MODE
@ MIOPEN_TYPE_RESAMPLE_MODE
Definition: miopen.h:6742
MIOPEN_TYPE_INT32
@ MIOPEN_TYPE_INT32
Definition: miopen.h:6744
MIOPEN_TYPE_POINTWISE_MODE
@ MIOPEN_TYPE_POINTWISE_MODE
Definition: miopen.h:6735
MIOPEN_TYPE_HANDLE
@ MIOPEN_TYPE_HANDLE
Definition: miopen.h:6721
MIOPEN_TYPE_HEUR_MODE
@ MIOPEN_TYPE_HEUR_MODE
Definition: miopen.h:6729
MIOPEN_TYPE_CONVOLUTION_MODE
@ MIOPEN_TYPE_CONVOLUTION_MODE
Definition: miopen.h:6728
MIOPEN_TYPE_TENSOR_REORDERING_MODE
@ MIOPEN_TYPE_TENSOR_REORDERING_MODE
Definition: miopen.h:6741
MIOPEN_TYPE_BOOLEAN
@ MIOPEN_TYPE_BOOLEAN
Definition: miopen.h:6723
MIOPEN_TYPE_NORM_MODE
@ MIOPEN_TYPE_NORM_MODE
Definition: miopen.h:6748
MIOPEN_TYPE_FRACTION
@ MIOPEN_TYPE_FRACTION
Definition: miopen.h:6747
MIOPEN_TYPE_BACKEND_DESCRIPTOR
@ MIOPEN_TYPE_BACKEND_DESCRIPTOR
Definition: miopen.h:6736
MIOPEN_TYPE_ATTRIB_NAME
@ MIOPEN_TYPE_ATTRIB_NAME
Definition: miopen.h:6734
MIOPEN_TYPE_BEHAVIOR_NOTE
@ MIOPEN_TYPE_BEHAVIOR_NOTE
Definition: miopen.h:6740
MIOPEN_TYPE_DATA_TYPE
@ MIOPEN_TYPE_DATA_TYPE
Definition: miopen.h:6722
MIOPEN_TYPE_NAN_PROPOGATION
@ MIOPEN_TYPE_NAN_PROPOGATION
Definition: miopen.h:6731
MIOPEN_TYPE_DOUBLE
@ MIOPEN_TYPE_DOUBLE
Definition: miopen.h:6726
MIOPEN_TYPE_SIGNAL_MODE
@ MIOPEN_TYPE_SIGNAL_MODE
Definition: miopen.h:6746
MIOPEN_TYPE_CHAR
@ MIOPEN_TYPE_CHAR
Definition: miopen.h:6745
MIOPEN_TYPE_PADDING_MODE
@ MIOPEN_TYPE_PADDING_MODE
Definition: miopen.h:6743
MIOPEN_TYPE_INT64
@ MIOPEN_TYPE_INT64
Definition: miopen.h:6724
MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
Definition: miopen.h:6739
MIOPEN_TYPE_LAYOUT_TYPE
@ MIOPEN_TYPE_LAYOUT_TYPE
Definition: miopen.h:6733
MIOPEN_TYPE_GENSTATS_MODE
@ MIOPEN_TYPE_GENSTATS_MODE
Definition: miopen.h:6737
MIOPEN_TYPE_VOID_PTR
@ MIOPEN_TYPE_VOID_PTR
Definition: miopen.h:6727
MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
Definition: miopen.h:6738
MIOPEN_TYPE_KNOB_TYPE
@ MIOPEN_TYPE_KNOB_TYPE
Definition: miopen.h:6730
MIOPEN_TYPE_NORM_FWD_PHASE
@ MIOPEN_TYPE_NORM_FWD_PHASE
Definition: miopen.h:6749
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:480
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:8008
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:5123
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:5124
miopenRNNMode_t
miopenRNNMode_t
Definition: miopen.h:3730
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:3741
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:3761
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:3770
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:3805
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:3750
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 a the size in bytes of the RNN input tensor.
miopenRNNFWDMode_t
miopenRNNFWDMode_t
Definition: miopen.h:3796
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:3779
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:3787
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 a 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:3732
miopenLSTM
@ miopenLSTM
Definition: miopen.h:3733
miopenGRU
@ miopenGRU
Definition: miopen.h:3734
miopenRNNRELU
@ miopenRNNRELU
Definition: miopen.h:3731
miopenRNNlinear
@ miopenRNNlinear
Definition: miopen.h:3742
miopenRNNskip
@ miopenRNNskip
Definition: miopen.h:3743
miopenRNNbidirection
@ miopenRNNbidirection
Definition: miopen.h:3763
miopenRNNunidirection
@ miopenRNNunidirection
Definition: miopen.h:3762
miopenRNNwithBias
@ miopenRNNwithBias
Definition: miopen.h:3772
miopenRNNNoBias
@ miopenRNNNoBias
Definition: miopen.h:3771
miopenRNNDataSeqMajorPadded
@ miopenRNNDataSeqMajorPadded
Definition: miopen.h:3808
miopenRNNDataSeqMajorNotPadded
@ miopenRNNDataSeqMajorNotPadded
Definition: miopen.h:3807
miopenRNNDataBatchMajorPadded
@ miopenRNNDataBatchMajorPadded
Definition: miopen.h:3809
miopenRNNDataUnknownLayout
@ miopenRNNDataUnknownLayout
Definition: miopen.h:3806
miopenRNNfundamental
@ miopenRNNfundamental
Definition: miopen.h:3753
miopenRNNdefault
@ miopenRNNdefault
Definition: miopen.h:3751
miopenRNNTraining
@ miopenRNNTraining
Definition: miopen.h:3797
miopenRNNInference
@ miopenRNNInference
Definition: miopen.h:3798
miopenRNNAlgoGEMM
@ miopenRNNAlgoGEMM
Definition: miopen.h:3780
miopenRNNIOWithPadding
@ miopenRNNIOWithPadding
Definition: miopen.h:3789
miopenRNNIONotPadded
@ miopenRNNIONotPadded
Definition: miopen.h:3788
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:6167
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:607
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:572
miopenIndicesType_t
miopenIndicesType_t
Definition: miopen.h:617
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:519
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.
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.
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:509
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.
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:1214
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:1177
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:1200
miopenConvolutionAttrib_t
miopenConvolutionAttrib_t
Definition: miopen.h:629
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:434
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.
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.
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:1189
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:1216
miopenConvolutionAlgoWinograd
@ miopenConvolutionAlgoWinograd
Definition: miopen.h:1218
miopenConvolutionAlgoFFT
@ miopenConvolutionAlgoFFT
Definition: miopen.h:1217
miopenConvolutionAlgoImplicitGEMM
@ miopenConvolutionAlgoImplicitGEMM
Definition: miopen.h:1219
miopenConvolutionAlgoGEMM
@ miopenConvolutionAlgoGEMM
Definition: miopen.h:1215
miopenConvolutionFwdAlgoFFT
@ miopenConvolutionFwdAlgoFFT
Definition: miopen.h:1180
miopenConvolutionFwdAlgoImplicitGEMM
@ miopenConvolutionFwdAlgoImplicitGEMM
Definition: miopen.h:1182
miopenConvolutionFwdAlgoGEMM
@ miopenConvolutionFwdAlgoGEMM
Definition: miopen.h:1178
miopenConvolutionFwdAlgoWinograd
@ miopenConvolutionFwdAlgoWinograd
Definition: miopen.h:1181
miopenConvolutionFwdAlgoDirect
@ miopenConvolutionFwdAlgoDirect
Definition: miopen.h:1179
miopenTransposeBwdDataAlgoGEMM
@ miopenTransposeBwdDataAlgoGEMM
Definition: miopen.h:1205
miopenConvolutionBwdDataAlgoDirect
@ miopenConvolutionBwdDataAlgoDirect
Definition: miopen.h:1202
miopenConvolutionBwdDataAlgoGEMM
@ miopenConvolutionBwdDataAlgoGEMM
Definition: miopen.h:1201
miopenConvolutionBwdDataAlgoFFT
@ miopenConvolutionBwdDataAlgoFFT
Definition: miopen.h:1203
miopenConvolutionBwdDataAlgoWinograd
@ miopenConvolutionBwdDataAlgoWinograd
Definition: miopen.h:1204
miopenConvolutionBwdDataAlgoImplicitGEMM
@ miopenConvolutionBwdDataAlgoImplicitGEMM
Definition: miopen.h:1207
miopenConvolutionBwdWeightsAlgoGEMM
@ miopenConvolutionBwdWeightsAlgoGEMM
Definition: miopen.h:1190
miopenConvolutionBwdWeightsAlgoWinograd
@ miopenConvolutionBwdWeightsAlgoWinograd
Definition: miopen.h:1192
miopenConvolutionBwdWeightsAlgoDirect
@ miopenConvolutionBwdWeightsAlgoDirect
Definition: miopen.h:1191
miopenConvolutionBwdWeightsAlgoImplicitGEMM
@ miopenConvolutionBwdWeightsAlgoImplicitGEMM
Definition: miopen.h:1193
miopenDestroyDropoutDescriptor
miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)
Destroys the dropout descriptor object.
miopenRNGType_t
miopenRNGType_t
Definition: miopen.h:5243
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:5244
miopenFindResultsOrder_t
miopenFindResultsOrder_t
Definition: miopen.h:5674
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:5702
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)
miopenGetSolutionSize
miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t *size)
Reads the expected size of a solution.
miopenTensorArgumentId_t
miopenTensorArgumentId_t
Definition: miopen.h:5593
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 exectute 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:5580
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:5676
miopenFindResultsOrderByTime
@ miopenFindResultsOrderByTime
Definition: miopen.h:5675
miopenMhaMaskCausal
@ miopenMhaMaskCausal
Definition: miopen.h:5704
miopenMhaMaskNone
@ miopenMhaMaskNone
Definition: miopen.h:5703
miopenTensorMhaDescaleS
@ miopenTensorMhaDescaleS
Definition: miopen.h:5605
miopenTensorMhaO
@ miopenTensorMhaO
Definition: miopen.h:5611
miopenTensorMhaAmaxDV
@ miopenTensorMhaAmaxDV
Definition: miopen.h:5629
miopenTensorBatchnormScaleDiff
@ miopenTensorBatchnormScaleDiff
Definition: miopen.h:5652
miopenTensorMhaMask
@ miopenTensorMhaMask
Definition: miopen.h:5663
miopenTensorMhaDescaleDS
@ miopenTensorMhaDescaleDS
Definition: miopen.h:5619
miopenTensorMhaDropoutSeed
@ miopenTensorMhaDropoutSeed
Definition: miopen.h:5609
miopenTensorBatchnormSavedMean
@ miopenTensorBatchnormSavedMean
Definition: miopen.h:5649
miopenTensorActivationDY
@ miopenTensorActivationDY
Definition: miopen.h:5637
miopenTensorBatchnormDX
@ miopenTensorBatchnormDX
Definition: miopen.h:5657
miopenTensorMhaDescaleV
@ miopenTensorMhaDescaleV
Definition: miopen.h:5604
miopenTensorMhaK
@ miopenTensorMhaK
Definition: miopen.h:5599
miopenTensorConvolutionX
@ miopenTensorConvolutionX
Definition: miopen.h:5595
miopenTensorMhaAmaxDK
@ miopenTensorMhaAmaxDK
Definition: miopen.h:5628
miopenTensorMhaScaleDS
@ miopenTensorMhaScaleDS
Definition: miopen.h:5620
miopenTensorBatchnormBias
@ miopenTensorBatchnormBias
Definition: miopen.h:5655
miopenTensorMhaM
@ miopenTensorMhaM
Definition: miopen.h:5614
miopenTensorBatchnormRunningMean
@ miopenTensorBatchnormRunningMean
Definition: miopen.h:5647
miopenTensorMhaDropoutProbability
@ miopenTensorMhaDropoutProbability
Definition: miopen.h:5608
miopenTensorSoftmaxY
@ miopenTensorSoftmaxY
Definition: miopen.h:5642
miopenTensorSoftmaxDY
@ miopenTensorSoftmaxDY
Definition: miopen.h:5644
miopenTensorMhaDescaleO
@ miopenTensorMhaDescaleO
Definition: miopen.h:5617
miopenTensorMhaScaleO
@ miopenTensorMhaScaleO
Definition: miopen.h:5607
miopenScalarBatchnormExpAvgFactor
@ miopenScalarBatchnormExpAvgFactor
Definition: miopen.h:5665
miopenTensorBatchnormScale
@ miopenTensorBatchnormScale
Definition: miopen.h:5651
miopenTensorBatchnormRunningVariance
@ miopenTensorBatchnormRunningVariance
Definition: miopen.h:5648
miopenTensorActivationDX
@ miopenTensorActivationDX
Definition: miopen.h:5636
miopenTensorMhaScaleDK
@ miopenTensorMhaScaleDK
Definition: miopen.h:5622
miopenTensorMhaV
@ miopenTensorMhaV
Definition: miopen.h:5601
miopenTensorMhaAmaxS
@ miopenTensorMhaAmaxS
Definition: miopen.h:5613
miopenTensorBatchnormBiasDiff
@ miopenTensorBatchnormBiasDiff
Definition: miopen.h:5656
miopenTensorBatchnormSavedVariance
@ miopenTensorBatchnormSavedVariance
Definition: miopen.h:5650
miopenTensorActivationX
@ miopenTensorActivationX
Definition: miopen.h:5634
miopenTensorMhaScaleDV
@ miopenTensorMhaScaleDV
Definition: miopen.h:5623
miopenTensorMhaAmaxO
@ miopenTensorMhaAmaxO
Definition: miopen.h:5612
miopenScalarBatchnormEpsilon
@ miopenScalarBatchnormEpsilon
Definition: miopen.h:5666
miopenTensorMhaScaleDQ
@ miopenTensorMhaScaleDQ
Definition: miopen.h:5621
miopenTensorSoftmaxDX
@ miopenTensorSoftmaxDX
Definition: miopen.h:5643
miopenTensorMhaAmaxDS
@ miopenTensorMhaAmaxDS
Definition: miopen.h:5630
miopenTensorMhaDV
@ miopenTensorMhaDV
Definition: miopen.h:5626
miopenTensorMhaQ
@ miopenTensorMhaQ
Definition: miopen.h:5600
miopenTensorMhaAmaxDQ
@ miopenTensorMhaAmaxDQ
Definition: miopen.h:5627
miopenTensorConvolutionY
@ miopenTensorConvolutionY
Definition: miopen.h:5597
miopenTensorBatchnormEstimatedMean
@ miopenTensorBatchnormEstimatedMean
Definition: miopen.h:5653
miopenTensorBatchnormDY
@ miopenTensorBatchnormDY
Definition: miopen.h:5658
miopenTensorMhaZInv
@ miopenTensorMhaZInv
Definition: miopen.h:5615
miopenTensorMhaDescaleQ
@ miopenTensorMhaDescaleQ
Definition: miopen.h:5603
miopenTensorMhaBias
@ miopenTensorMhaBias
Definition: miopen.h:5631
miopenTensorBatchnormEstimatedVariance
@ miopenTensorBatchnormEstimatedVariance
Definition: miopen.h:5654
miopenTensorArgumentIsScalar
@ miopenTensorArgumentIsScalar
Definition: miopen.h:5661
miopenTensorArgumentIdInvalid
@ miopenTensorArgumentIdInvalid
Definition: miopen.h:5594
miopenTensorMhaDO
@ miopenTensorMhaDO
Definition: miopen.h:5616
miopenTensorMhaDescaleDO
@ miopenTensorMhaDescaleDO
Definition: miopen.h:5618
miopenTensorConvolutionW
@ miopenTensorConvolutionW
Definition: miopen.h:5596
miopenTensorMhaDescaleK
@ miopenTensorMhaDescaleK
Definition: miopen.h:5602
miopenTensorMhaDropoutOffset
@ miopenTensorMhaDropoutOffset
Definition: miopen.h:5610
miopenTensorBiasY
@ miopenTensorBiasY
Definition: miopen.h:5639
miopenTensorMhaDQ
@ miopenTensorMhaDQ
Definition: miopen.h:5624
miopenTensorSoftmaxX
@ miopenTensorSoftmaxX
Definition: miopen.h:5641
miopenTensorBatchnormY
@ miopenTensorBatchnormY
Definition: miopen.h:5646
miopenTensorMhaScaleS
@ miopenTensorMhaScaleS
Definition: miopen.h:5606
miopenTensorBias
@ miopenTensorBias
Definition: miopen.h:5640
miopenTensorActivationY
@ miopenTensorActivationY
Definition: miopen.h:5635
miopenTensorBatchnormX
@ miopenTensorBatchnormX
Definition: miopen.h:5645
miopenTensorBiasX
@ miopenTensorBiasX
Definition: miopen.h:5638
miopenTensorMhaDK
@ miopenTensorMhaDK
Definition: miopen.h:5625
miopenProblemDirectionBackwardWeights
@ miopenProblemDirectionBackwardWeights
Definition: miopen.h:5583
miopenProblemDirectionInference
@ miopenProblemDirectionInference
Definition: miopen.h:5585
miopenProblemDirectionForward
@ miopenProblemDirectionForward
Definition: miopen.h:5581
miopenProblemDirectionBackward
@ miopenProblemDirectionBackward
Definition: miopen.h:5582
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.
miopenDeallocatorFunction
void(* miopenDeallocatorFunction)(void *context, void *memory)
Custom deallocator function.
Definition: miopen.h:158
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.
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:125
miopenAllocatorFunction
void *(* miopenAllocatorFunction)(void *context, size_t sizeBytes)
Custom allocator function.
Definition: miopen.h:148
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.
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:126
miopenF8RoundingModeStochastic
@ miopenF8RoundingModeStochastic
Definition: miopen.h:127
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.
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:490
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:457
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:410
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:470
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:6107
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:6108
MIOPEN_REDUCE_CALCULATION_SUM
@ MIOPEN_REDUCE_CALCULATION_SUM
Definition: miopen.h:6110
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:552
miopenSoftmaxAlgorithm_t
miopenSoftmaxAlgorithm_t
Definition: miopen.h:541
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:393
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:368
miopenCreateSeqTensorDescriptor
miopenStatus_t miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t *tensorDesc)
Create a Tensor Descriptor for sequence data.
miopenTensorOp_t
miopenTensorOp_t
Definition: miopen.h:422
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:446
miopenPaddingDefault
@ miopenPaddingDefault
Definition: miopen.h:447
miopenPaddingSame
@ miopenPaddingSame
Definition: miopen.h:448
miopenPaddingValid
@ miopenPaddingValid
Definition: miopen.h:449
miopenReduceCalculationNanPropagation_t
miopenReduceCalculationNanPropagation_t
Definition: miopen.h:6091
MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
Definition: miopen.h:6093
MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
Definition: miopen.h:6092
MIOPEN_DECLARE_OBJECT
#define MIOPEN_DECLARE_OBJECT(name)
Definition: miopen.h:79
miopenNanPropagation_t
miopenNanPropagation_t
Definition: miopen.h:597
MIOPEN_PROPAGATE_NAN
@ MIOPEN_PROPAGATE_NAN
Definition: miopen.h:599
MIOPEN_NOT_PROPAGATE_NAN
@ MIOPEN_NOT_PROPAGATE_NAN
Definition: miopen.h:598
MIOPEN_LOSS_REDUCTION_MEAN
@ MIOPEN_LOSS_REDUCTION_MEAN
Definition: miopen.h:8011
MIOPEN_LOSS_REDUCTION_SUM
@ MIOPEN_LOSS_REDUCTION_SUM
Definition: miopen.h:8010
MIOPEN_LOSS_REDUCTION_NONE
@ MIOPEN_LOSS_REDUCTION_NONE
Definition: miopen.h:8009
miopenPoolingAverage
@ miopenPoolingAverage
Definition: miopen.h:459
miopenPoolingAverageInclusive
@ miopenPoolingAverageInclusive
Definition: miopen.h:460
miopenPoolingMax
@ miopenPoolingMax
Definition: miopen.h:458
miopenTensorCHWN
@ miopenTensorCHWN
Definition: miopen.h:396
miopenTensorNHWC
@ miopenTensorNHWC
Definition: miopen.h:395
miopenTensorNDHWC
@ miopenTensorNDHWC
Definition: miopen.h:402
miopenTensorNCHW
@ miopenTensorNCHW
Definition: miopen.h:394
miopenTensorCHWNc4
@ miopenTensorCHWNc4
Definition: miopen.h:399
miopenTensorNCHWc8
@ miopenTensorNCHWc8
Definition: miopen.h:398
miopenTensorNCDHW
@ miopenTensorNCDHW
Definition: miopen.h:401
miopenTensorCHWNc8
@ miopenTensorCHWNc8
Definition: miopen.h:400
miopenTensorNCHWc4
@ miopenTensorNCHWc4
Definition: miopen.h:397
MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES
@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES
Definition: miopen.h:609
MIOPEN_REDUCE_TENSOR_NO_INDICES
@ MIOPEN_REDUCE_TENSOR_NO_INDICES
Definition: miopen.h:608
miopenActivationLEAKYRELU
@ miopenActivationLEAKYRELU
Definition: miopen.h:529
miopenActivationPASTHRU
@ miopenActivationPASTHRU
Definition: miopen.h:520
miopenActivationABS
@ miopenActivationABS
Definition: miopen.h:525
miopenActivationLOGISTIC
@ miopenActivationLOGISTIC
Definition: miopen.h:521
miopenActivationCLIPPEDRELU
@ miopenActivationCLIPPEDRELU
Definition: miopen.h:527
miopenActivationRELU
@ miopenActivationRELU
Definition: miopen.h:523
miopenActivationPOWER
@ miopenActivationPOWER
Definition: miopen.h:526
miopenActivationELU
@ miopenActivationELU
Definition: miopen.h:531
miopenActivationSOFTRELU
@ miopenActivationSOFTRELU
Definition: miopen.h:524
miopenActivationTANH
@ miopenActivationTANH
Definition: miopen.h:522
MIOPEN_REDUCE_TENSOR_MUL
@ MIOPEN_REDUCE_TENSOR_MUL
Definition: miopen.h:574
MIOPEN_REDUCE_TENSOR_MAX
@ MIOPEN_REDUCE_TENSOR_MAX
Definition: miopen.h:578
MIOPEN_REDUCE_TENSOR_AVG
@ MIOPEN_REDUCE_TENSOR_AVG
Definition: miopen.h:582
MIOPEN_REDUCE_TENSOR_NORM1
@ MIOPEN_REDUCE_TENSOR_NORM1
Definition: miopen.h:584
MIOPEN_REDUCE_TENSOR_AMAX
@ MIOPEN_REDUCE_TENSOR_AMAX
Definition: miopen.h:580
MIOPEN_REDUCE_TENSOR_MIN
@ MIOPEN_REDUCE_TENSOR_MIN
Definition: miopen.h:576
MIOPEN_REDUCE_TENSOR_ADD
@ MIOPEN_REDUCE_TENSOR_ADD
Definition: miopen.h:573
MIOPEN_REDUCE_TENSOR_NORM2
@ MIOPEN_REDUCE_TENSOR_NORM2
Definition: miopen.h:586
MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC
@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC
Definition: miopen.h:634
MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE
@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE
Definition: miopen.h:638
MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL
@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL
Definition: miopen.h:630
miopenIndexUint16
@ miopenIndexUint16
Definition: miopen.h:412
miopenIndexUint64
@ miopenIndexUint64
Definition: miopen.h:414
miopenIndexUint32
@ miopenIndexUint32
Definition: miopen.h:413
miopenIndexUint8
@ miopenIndexUint8
Definition: miopen.h:411
miopenFloat
@ miopenFloat
Definition: miopen.h:370
miopenBFloat16
@ miopenBFloat16
Definition: miopen.h:374
miopenInt8
@ miopenInt8
Definition: miopen.h:372
miopenInt32
@ miopenInt32
Definition: miopen.h:371
miopenHalf
@ miopenHalf
Definition: miopen.h:369
miopenBFloat8
@ miopenBFloat8
Definition: miopen.h:379
miopenInt64
@ miopenInt64
Definition: miopen.h:384
miopenDouble
@ miopenDouble
Definition: miopen.h:376
miopenFloat8
@ miopenFloat8
Definition: miopen.h:378
MIOPEN_8BIT_INDICES
@ MIOPEN_8BIT_INDICES
Definition: miopen.h:621
MIOPEN_32BIT_INDICES
@ MIOPEN_32BIT_INDICES
Definition: miopen.h:618
MIOPEN_16BIT_INDICES
@ MIOPEN_16BIT_INDICES
Definition: miopen.h:620
MIOPEN_64BIT_INDICES
@ MIOPEN_64BIT_INDICES
Definition: miopen.h:619
miopenPoolingWorkspaceIndexImage
@ miopenPoolingWorkspaceIndexImage
Definition: miopen.h:472
miopenPoolingWorkspaceIndexMask
@ miopenPoolingWorkspaceIndexMask
Definition: miopen.h:471
miopenDepthwise
@ miopenDepthwise
Definition: miopen.h:438
miopenGroupConv
@ miopenGroupConv
Definition: miopen.h:437
miopenTranspose
@ miopenTranspose
Definition: miopen.h:436
miopenConvolution
@ miopenConvolution
Definition: miopen.h:435
MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD
@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD
Definition: miopen.h:494
MIOPEN_WEIGHT_BIAS
@ MIOPEN_WEIGHT_BIAS
Definition: miopen.h:492
MIOPEN_ELEMENTWISE_AFFINE
@ MIOPEN_ELEMENTWISE_AFFINE
Definition: miopen.h:491
MIOPEN_WEIGHT_BIAS_T5
@ MIOPEN_WEIGHT_BIAS_T5
Definition: miopen.h:500
MIOPEN_ELEMENTWISE_AFFINE_T5
@ MIOPEN_ELEMENTWISE_AFFINE_T5
Definition: miopen.h:498
MIOPEN_WEIGHT_BIAS_FUSED_ADD
@ MIOPEN_WEIGHT_BIAS_FUSED_ADD
Definition: miopen.h:496
MIOPEN_REDUCE_EXTREME_ARGMAX
@ MIOPEN_REDUCE_EXTREME_ARGMAX
Definition: miopen.h:6170
MIOPEN_REDUCE_EXTREME_MIN
@ MIOPEN_REDUCE_EXTREME_MIN
Definition: miopen.h:6172
MIOPEN_REDUCE_EXTREME_MAX
@ MIOPEN_REDUCE_EXTREME_MAX
Definition: miopen.h:6174
MIOPEN_REDUCE_EXTREME_ARGMIN
@ MIOPEN_REDUCE_EXTREME_ARGMIN
Definition: miopen.h:6168
miopenTensorOpMin
@ miopenTensorOpMin
Definition: miopen.h:425
miopenTensorOpAdd
@ miopenTensorOpAdd
Definition: miopen.h:423
miopenTensorOpMul
@ miopenTensorOpMul
Definition: miopen.h:424
miopenTensorOpMax
@ miopenTensorOpMax
Definition: miopen.h:426
miopenBNSpatial
@ miopenBNSpatial
Definition: miopen.h:511
miopenBNPerActivation
@ miopenBNPerActivation
Definition: miopen.h:510
miopenLRNWithinChannel
@ miopenLRNWithinChannel
Definition: miopen.h:481
miopenLRNCrossChannel
@ miopenLRNCrossChannel
Definition: miopen.h:482
MIOPEN_SOFTMAX_MODE_INSTANCE
@ MIOPEN_SOFTMAX_MODE_INSTANCE
Definition: miopen.h:553
MIOPEN_SOFTMAX_MODE_CHANNEL
@ MIOPEN_SOFTMAX_MODE_CHANNEL
Definition: miopen.h:554
MIOPEN_SOFTMAX_FAST
@ MIOPEN_SOFTMAX_FAST
Definition: miopen.h:542
MIOPEN_SOFTMAX_ACCURATE
@ MIOPEN_SOFTMAX_ACCURATE
Definition: miopen.h:543
MIOPEN_SOFTMAX_LOG
@ MIOPEN_SOFTMAX_LOG
Definition: miopen.h:544
miopenConvAlgoPerf_t
Perf struct for forward, backward filter, or backward data algorithms.
Definition: miopen.h:1229
miopenConvAlgoPerf_t::fwd_algo
miopenConvFwdAlgorithm_t fwd_algo
Definition: miopen.h:1232
miopenConvAlgoPerf_t::bwd_data_algo
miopenConvBwdDataAlgorithm_t bwd_data_algo
Definition: miopen.h:1236
miopenConvAlgoPerf_t::memory
size_t memory
Definition: miopen.h:1240
miopenConvAlgoPerf_t::bwd_weights_algo
miopenConvBwdWeightsAlgorithm_t bwd_weights_algo
Definition: miopen.h:1233
miopenConvAlgoPerf_t::time
float time
Definition: miopen.h:1239
miopenConvSolution_t
Performance struct for forward, backward filter, or backward data algorithms in immediate mode.
Definition: miopen.h:1253
miopenConvSolution_t::algorithm
miopenConvAlgorithm_t algorithm
Definition: miopen.h:1260
miopenConvSolution_t::solution_id
uint64_t solution_id
Definition: miopen.h:1259
miopenConvSolution_t::workspace_size
size_t workspace_size
Definition: miopen.h:1257
miopenConvSolution_t::time
float time
Definition: miopen.h:1254
miopenTensorArgument_t
Values of a tensor or scalar argument for the miopenRunSolution function.
Definition: miopen.h:5905
miopenTensorArgument_t::id
miopenTensorArgumentId_t id
Definition: miopen.h:5908
miopenTensorArgument_t::buffer
void * buffer
Definition: miopen.h:5918
miopenTensorArgument_t::descriptor
miopenTensorDescriptor_t * descriptor
Definition: miopen.h:5914