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

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

MIOpen: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/docs-7.0.0/projects/miopen/include/miopen/miopen.h Source File
miopen.h
Go to the documentation of this file.
1 /*******************************************************************************
2  *
3  * MIT License
4  *
5  * Copyright (c) 2023 Advanced Micro Devices, Inc.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in all
15  * copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  *
25  *******************************************************************************/
26 #ifndef MIOPEN_GUARD_MIOPEN_H_
27 #define MIOPEN_GUARD_MIOPEN_H_
28 
29 #ifdef __clang__
30 #pragma clang diagnostic push
31 #pragma clang diagnostic ignored "-Wextern-c-compat"
32 #endif
33 
34 #include <stddef.h>
35 #include <stdbool.h>
36 #include <miopen/config.h>
37 #include <miopen/export.h>
38 
39 #if MIOPEN_BACKEND_OPENCL
40 #define CL_TARGET_OPENCL_VERSION 120
41 #if defined(__APPLE__) || defined(__MACOSX)
42 #include <OpenCL/cl.h>
43 #else
44 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS
45 #include <CL/cl.h>
46 #endif
47 
48 #elif MIOPEN_BACKEND_HIP
49 #include <hip/hip_runtime_api.h>
50 #endif
51 
52 /*
53  * @defgroup convolutions
54  * @defgroup pooling
55  * @defgroup handle
56  * @defgroup layernorm
57  * @defgroup LRN
58  * @defgroup batchnorm
59  * @defgroup activation
60  * @defgroup tensor
61  * @defgroup softmax
62  * @defgroup RNN
63  * @defgroup fusion
64  * @defgroup LossFunction
65  * @defgroup TensorReduce
66  * @defgroup find2
67  * @defgroup ReduceExtreme
68  * @defgroup groupnorm
69  * @defgroup cat
70  * @defgroup SGD
71  * @defgroup getitem
72  * @defgroup ReduceCalculation
73  * @defgroup RotaryPositionalEmbeddings
74  * @defgroup ReLU
75  *
76  */
77 
79 #define MIOPEN_DECLARE_OBJECT(name) \
80  struct name \
81  { \
82  }; \
83  typedef struct name* name##_t;
84 
85 #ifdef __cplusplus
86 extern "C" {
87 #endif
88 
89 #if MIOPEN_BACKEND_OPENCL
90 typedef cl_command_queue miopenAcceleratorQueue_t;
91 #elif MIOPEN_BACKEND_HIP
92 typedef hipStream_t miopenAcceleratorQueue_t;
93 #endif
94 
98 MIOPEN_DECLARE_OBJECT(miopenHandle);
99 
108 typedef enum
109 {
110  miopenStatusSuccess = 0,
111  miopenStatusNotInitialized = 1,
112  miopenStatusInvalidValue = 2,
113  miopenStatusBadParm = 3,
114  miopenStatusAllocFailed = 4,
115  miopenStatusInternalError = 5,
116  miopenStatusNotImplemented = 6,
117  miopenStatusUnknownError = 7,
118  miopenStatusUnsupportedOp = 8,
119  miopenStatusGpuOperationsSkipped = 9,
120  miopenStatusVersionMismatch = 10,
121 } miopenStatus_t;
122 
123 #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  miopenFloat8_fnuz = 7,
378  miopenBFloat8_fnuz = 8,
379  miopenInt64 = 9,
380 } miopenDataType_t;
381 
387 typedef enum
388 {
389  miopenTensorNCHW = 0,
390  miopenTensorNHWC = 1,
391  miopenTensorCHWN = 2,
392  miopenTensorNCHWc4 = 3,
393  miopenTensorNCHWc8 = 4,
394  miopenTensorCHWNc4 = 5,
395  miopenTensorCHWNc8 = 6,
396  miopenTensorNCDHW = 7,
397  miopenTensorNDHWC = 8,
398 } miopenTensorLayout_t;
399 
404 typedef enum
405 {
406  miopenIndexUint8 = 0,
407  miopenIndexUint16 = 1,
408  miopenIndexUint32 = 2,
409  miopenIndexUint64 = 3,
410 } miopenIndexType_t;
411 
416 typedef enum
417 {
418  miopenTensorOpAdd = 0,
419  miopenTensorOpMul = 1,
420  miopenTensorOpMin = 2,
421  miopenTensorOpMax = 3,
422 } miopenTensorOp_t;
423 
428 typedef enum
429 {
430  miopenConvolution = 0,
431  miopenTranspose = 1,
432  miopenGroupConv = 2,
433  miopenDepthwise = 3,
434 } miopenConvolutionMode_t;
435 
440 typedef enum
441 {
442  miopenPaddingDefault = 0,
443  miopenPaddingSame = 1,
444  miopenPaddingValid = 2,
445 } miopenPaddingMode_t;
446 
451 typedef enum
452 {
453  miopenPoolingMax = 0,
454  miopenPoolingAverage = 1,
455  miopenPoolingAverageInclusive = 2,
456 } miopenPoolingMode_t;
457 
464 typedef enum
465 {
466  miopenPoolingWorkspaceIndexMask = 0,
467  miopenPoolingWorkspaceIndexImage = 1,
468 } miopenPoolingWorkspaceIndexMode_t;
469 
474 typedef enum
475 {
476  miopenLRNWithinChannel = 0,
477  miopenLRNCrossChannel = 1,
478 } miopenLRNMode_t;
479 #ifdef MIOPEN_BETA_API
484 typedef enum
485 {
486  MIOPEN_ELEMENTWISE_AFFINE = 0,
487  MIOPEN_WEIGHT_BIAS =
488  1,
489  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =
490  2,
491  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,
493  MIOPEN_ELEMENTWISE_AFFINE_T5 =
494  4,
495  MIOPEN_WEIGHT_BIAS_T5 = 5,
497 } miopenNormMode_t;
498 #endif
503 typedef enum
504 {
505  miopenBNPerActivation = 0,
506  miopenBNSpatial = 1,
507 } miopenBatchNormMode_t;
508 
513 typedef enum
514 {
515  miopenActivationPASTHRU = 0,
516  miopenActivationLOGISTIC = 1,
517  miopenActivationTANH = 2,
518  miopenActivationRELU = 3,
519  miopenActivationSOFTRELU = 4,
520  miopenActivationABS = 5,
521  miopenActivationPOWER = 6,
522  miopenActivationCLIPPEDRELU =
523  7,
524  miopenActivationLEAKYRELU =
525  8,
526  miopenActivationELU =
527  9,
529  miopenActivationCLAMP = 10,
530 } miopenActivationMode_t;
531 
536 typedef enum
537 {
538  MIOPEN_SOFTMAX_FAST = 0,
539  MIOPEN_SOFTMAX_ACCURATE = 1,
540  MIOPEN_SOFTMAX_LOG = 2,
541 } miopenSoftmaxAlgorithm_t;
542 
547 typedef enum
548 {
549  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,
550  MIOPEN_SOFTMAX_MODE_CHANNEL =
551  1,
552 } miopenSoftmaxMode_t;
553 
561 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1
562 
567 typedef enum
568 {
569  MIOPEN_REDUCE_TENSOR_ADD = 0,
570  MIOPEN_REDUCE_TENSOR_MUL =
571  1,
572  MIOPEN_REDUCE_TENSOR_MIN =
573  2,
574  MIOPEN_REDUCE_TENSOR_MAX =
575  3,
576  MIOPEN_REDUCE_TENSOR_AMAX =
577  4,
578  MIOPEN_REDUCE_TENSOR_AVG =
579  5,
580  MIOPEN_REDUCE_TENSOR_NORM1 =
581  6,
582  MIOPEN_REDUCE_TENSOR_NORM2 = 7,
584  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =
585  // 8, /*!< the operation is same as MUL, but does not have the zero values considered */
586 } miopenReduceTensorOp_t;
587 
592 typedef enum
593 {
594  MIOPEN_NOT_PROPAGATE_NAN = 0,
595  MIOPEN_PROPAGATE_NAN = 1,
596 } miopenNanPropagation_t;
597 
602 typedef enum
603 {
604  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,
605  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,
606 } miopenReduceTensorIndices_t;
607 
612 typedef enum
613 {
614  MIOPEN_32BIT_INDICES = 0,
615  MIOPEN_64BIT_INDICES = 1,
616  MIOPEN_16BIT_INDICES = 2,
617  MIOPEN_8BIT_INDICES = 3,
618 } miopenIndicesType_t;
619 
624 typedef enum
625 {
626  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =
627  0,
630  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =
631  1,
633 #ifdef MIOPEN_BETA_API
634  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =
635  2,
639 #else
640 // miopenReserved1 = 2,
641 #endif
642 } miopenConvolutionAttrib_t;
643 
650 typedef enum
651 {
652  miopenConvolutionFindModeNormal =
653  1,
654  miopenConvolutionFindModeFast =
655  2,
658  miopenConvolutionFindModeHybrid =
659  3,
662  // miopenConvolutionFindModeReserved_4 = 4, /*!< Reserved - do not use */
663  miopenConvolutionFindModeDynamicHybrid =
664  5,
668  miopenConvolutionFindModeDefault =
669  miopenConvolutionFindModeDynamicHybrid
670 } miopenConvolutionFindMode_t;
671 
683 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);
684 
697 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(
698  miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w);
699 
710 MIOPEN_EXPORT miopenStatus_t
711 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,
712  miopenDataType_t dataType,
713  miopenTensorLayout_t tensorLayout,
714  const int* lens,
715  int num_lens);
735 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,
736  miopenDataType_t dataType,
737  int n,
738  int c,
739  int h,
740  int w,
741  int nStride,
742  int cStride,
743  int hStride,
744  int wStride);
745 
762 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
763  miopenDataType_t* dataType,
764  int* n,
765  int* c,
766  int* h,
767  int* w,
768  int* nStride,
769  int* cStride,
770  int* hStride,
771  int* wStride);
772 
783 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
784  miopenDataType_t dataType,
785  int nbDims,
786  const int* dimsA,
787  const int* stridesA);
788 
789 #ifdef MIOPEN_BETA_API
792 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,
793  miopenDataType_t dataType,
794  int nbDims,
795  const size_t* dimsA,
796  const size_t* stridesA);
797 #endif
798 
799 #ifdef MIOPEN_BETA_API
809 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,
810  miopenDataType_t cast_type);
811 #endif
812 
821 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,
822  int* size);
823 
832 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
833  miopenDataType_t* dataType,
834  int* dimsA,
835  int* stridesA);
836 
842 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);
843 
850 MIOPEN_EXPORT miopenStatus_t
851 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);
852 
858 MIOPEN_EXPORT miopenStatus_t
859 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);
860 
880 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,
881  miopenTensorOp_t tensorOp,
882  const void* alpha1,
883  const miopenTensorDescriptor_t aDesc,
884  const void* A,
885  const void* alpha2,
886  const miopenTensorDescriptor_t bDesc,
887  const void* B,
888  const void* beta,
889  const miopenTensorDescriptor_t cDesc,
890  void* C);
891 
902 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,
903  const miopenTensorDescriptor_t yDesc,
904  void* y,
905  const void* alpha);
906 
917 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,
918  const miopenTensorDescriptor_t yDesc,
919  void* y,
920  const void* alpha);
921 
928 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,
929  size_t* numBytes);
930 
948 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,
949  const void* alpha,
950  const miopenTensorDescriptor_t xDesc,
951  const void* x,
952  const void* beta,
953  const miopenTensorDescriptor_t yDesc,
954  void* y);
955 
957 // CLOSEOUT TENSOR DOXYGEN GROUP
958 
969 MIOPEN_EXPORT miopenStatus_t
970 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);
971 
987 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
988  miopenConvolutionMode_t c_mode,
989  int pad_h,
990  int pad_w,
991  int stride_h,
992  int stride_w,
993  int dilation_h,
994  int dilation_w);
995 
1006 MIOPEN_EXPORT miopenStatus_t
1007 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1008  int spatialDim,
1009  const int* padA,
1010  const int* strideA,
1011  const int* dilationA,
1012  miopenConvolutionMode_t c_mode);
1013 
1020 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,
1021  int* spatialDim);
1022 
1038 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
1039  miopenConvolutionMode_t* c_mode,
1040  int* pad_h,
1041  int* pad_w,
1042  int* stride_h,
1043  int* stride_w,
1044  int* dilation_h,
1045  int* dilation_w);
1046 
1058 MIOPEN_EXPORT miopenStatus_t
1059 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1060  int requestedSpatialDim,
1061  int* spatialDim,
1062  int* padA,
1063  int* strideA,
1064  int* dilationA,
1065  miopenConvolutionMode_t* c_mode);
1066 
1073 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1074  int* groupCount);
1075 
1089 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1090  int groupCount);
1091 
1104 MIOPEN_EXPORT miopenStatus_t
1105 miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w);
1106 
1119 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(
1120  miopenConvolutionDescriptor_t convDesc, int spatialDim, const int* adjA);
1121 
1139 MIOPEN_EXPORT miopenStatus_t
1140 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1141  const miopenTensorDescriptor_t inputTensorDesc,
1142  const miopenTensorDescriptor_t filterDesc,
1143  int* n,
1144  int* c,
1145  int* h,
1146  int* w);
1147 
1161 MIOPEN_EXPORT miopenStatus_t
1162 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1163  const miopenTensorDescriptor_t inputTensorDesc,
1164  const miopenTensorDescriptor_t filterDesc,
1165  int* nDim,
1166  int* outputTensorDimA);
1167 
1173 MIOPEN_EXPORT miopenStatus_t
1174 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);
1175 
1182 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1183  const miopenConvolutionAttrib_t attr,
1184  int value);
1185 
1192 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1193  const miopenConvolutionAttrib_t attr,
1194  int* value);
1195 
1209 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,
1210  miopenConvolutionFindMode_t findMode);
1211 
1218 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(
1219  const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);
1220 
1225 typedef enum
1226 {
1227  miopenConvolutionFwdAlgoGEMM = 0,
1228  miopenConvolutionFwdAlgoDirect = 1,
1229  miopenConvolutionFwdAlgoFFT = 2,
1230  miopenConvolutionFwdAlgoWinograd = 3,
1231  miopenConvolutionFwdAlgoImplicitGEMM = 5,
1232 } miopenConvFwdAlgorithm_t;
1233 
1237 typedef enum
1238 {
1239  miopenConvolutionBwdWeightsAlgoGEMM = 0,
1240  miopenConvolutionBwdWeightsAlgoDirect = 1,
1241  miopenConvolutionBwdWeightsAlgoWinograd = 3,
1242  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,
1243 } miopenConvBwdWeightsAlgorithm_t;
1244 
1248 typedef enum
1249 {
1250  miopenConvolutionBwdDataAlgoGEMM = 0,
1251  miopenConvolutionBwdDataAlgoDirect = 1,
1252  miopenConvolutionBwdDataAlgoFFT = 2,
1253  miopenConvolutionBwdDataAlgoWinograd = 3,
1254  miopenTransposeBwdDataAlgoGEMM =
1255  4,
1256  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,
1257 } miopenConvBwdDataAlgorithm_t;
1258 
1262 typedef enum
1263 {
1264  miopenConvolutionAlgoGEMM = 0,
1265  miopenConvolutionAlgoDirect = 1,
1266  miopenConvolutionAlgoFFT = 2,
1267  miopenConvolutionAlgoWinograd = 3,
1268  miopenConvolutionAlgoImplicitGEMM = 5,
1269 } miopenConvAlgorithm_t;
1270 
1277 typedef struct
1278 {
1279  union
1280  {
1281  miopenConvFwdAlgorithm_t fwd_algo;
1282  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;
1284  miopenConvBwdDataAlgorithm_t
1285  bwd_data_algo;
1286  };
1287 
1288  float time;
1289  size_t memory;
1291 } miopenConvAlgoPerf_t;
1292 
1301 typedef struct
1302 {
1303  float time;
1306  size_t workspace_size;
1308  uint64_t solution_id;
1309  miopenConvAlgorithm_t algorithm;
1311 } miopenConvSolution_t;
1312 
1328 MIOPEN_EXPORT miopenStatus_t
1329 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,
1330  const miopenTensorDescriptor_t wDesc,
1331  const miopenTensorDescriptor_t xDesc,
1332  const miopenConvolutionDescriptor_t convDesc,
1333  const miopenTensorDescriptor_t yDesc,
1334  size_t* solutionCount);
1335 
1359 MIOPEN_EXPORT miopenStatus_t
1360 miopenConvolutionForwardGetSolution(miopenHandle_t handle,
1361  const miopenTensorDescriptor_t wDesc,
1362  const miopenTensorDescriptor_t xDesc,
1363  const miopenConvolutionDescriptor_t convDesc,
1364  const miopenTensorDescriptor_t yDesc,
1365  const size_t maxSolutionCount,
1366  size_t* solutionCount,
1367  miopenConvSolution_t* solutions);
1368 
1386 MIOPEN_EXPORT miopenStatus_t
1387 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,
1388  const miopenTensorDescriptor_t wDesc,
1389  const miopenTensorDescriptor_t xDesc,
1390  const miopenConvolutionDescriptor_t convDesc,
1391  const miopenTensorDescriptor_t yDesc,
1392  const uint64_t solution_id,
1393  size_t* workSpaceSize);
1394 
1412 MIOPEN_EXPORT miopenStatus_t
1413 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,
1414  const miopenTensorDescriptor_t wDesc,
1415  const miopenTensorDescriptor_t xDesc,
1416  const miopenConvolutionDescriptor_t convDesc,
1417  const miopenTensorDescriptor_t yDesc,
1418  const uint64_t solution_id);
1419 
1437 MIOPEN_EXPORT miopenStatus_t
1438 miopenConvolutionForwardImmediate(miopenHandle_t handle,
1439  const miopenTensorDescriptor_t wDesc,
1440  const void* w,
1441  const miopenTensorDescriptor_t xDesc,
1442  const void* x,
1443  const miopenConvolutionDescriptor_t convDesc,
1444  const miopenTensorDescriptor_t yDesc,
1445  void* y,
1446  void* workSpace,
1447  size_t workSpaceSize,
1448  const uint64_t solution_id);
1449 
1467 MIOPEN_EXPORT miopenStatus_t
1468 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,
1469  const miopenTensorDescriptor_t dyDesc,
1470  const miopenTensorDescriptor_t wDesc,
1471  const miopenConvolutionDescriptor_t convDesc,
1472  const miopenTensorDescriptor_t dxDesc,
1473  size_t* solutionCount);
1474 
1499 MIOPEN_EXPORT miopenStatus_t
1500 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,
1501  const miopenTensorDescriptor_t dyDesc,
1502  const miopenTensorDescriptor_t wDesc,
1503  const miopenConvolutionDescriptor_t convDesc,
1504  const miopenTensorDescriptor_t dxDesc,
1505  const size_t maxSolutionCount,
1506  size_t* solutionCount,
1507  miopenConvSolution_t* solutions);
1508 
1526 MIOPEN_EXPORT miopenStatus_t
1527 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,
1528  const miopenTensorDescriptor_t dyDesc,
1529  const miopenTensorDescriptor_t wDesc,
1530  const miopenConvolutionDescriptor_t convDesc,
1531  const miopenTensorDescriptor_t dxDesc,
1532  const uint64_t solution_id,
1533  size_t* workSpaceSize);
1534 
1553 MIOPEN_EXPORT miopenStatus_t
1554 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,
1555  const miopenTensorDescriptor_t dyDesc,
1556  const miopenTensorDescriptor_t wDesc,
1557  const miopenConvolutionDescriptor_t convDesc,
1558  const miopenTensorDescriptor_t dxDesc,
1559  const uint64_t solution_id);
1560 
1578 MIOPEN_EXPORT miopenStatus_t
1579 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,
1580  const miopenTensorDescriptor_t dyDesc,
1581  const void* dy,
1582  const miopenTensorDescriptor_t wDesc,
1583  const void* w,
1584  const miopenConvolutionDescriptor_t convDesc,
1585  const miopenTensorDescriptor_t dxDesc,
1586  void* dx,
1587  void* workSpace,
1588  size_t workSpaceSize,
1589  const uint64_t solution_id);
1590 
1608 MIOPEN_EXPORT miopenStatus_t
1609 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,
1610  const miopenTensorDescriptor_t dyDesc,
1611  const miopenTensorDescriptor_t xDesc,
1612  const miopenConvolutionDescriptor_t convDesc,
1613  const miopenTensorDescriptor_t dwDesc,
1614  size_t* solutionCount);
1615 
1639 MIOPEN_EXPORT miopenStatus_t
1640 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,
1641  const miopenTensorDescriptor_t dyDesc,
1642  const miopenTensorDescriptor_t xDesc,
1643  const miopenConvolutionDescriptor_t convDesc,
1644  const miopenTensorDescriptor_t dwDesc,
1645  const size_t maxSolutionCount,
1646  size_t* solutionCount,
1647  miopenConvSolution_t* solutions);
1648 
1666 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(
1667  miopenHandle_t handle,
1668  const miopenTensorDescriptor_t dyDesc,
1669  const miopenTensorDescriptor_t xDesc,
1670  const miopenConvolutionDescriptor_t convDesc,
1671  const miopenTensorDescriptor_t dwDesc,
1672  const uint64_t solution_id,
1673  size_t* workSpaceSize);
1674 
1692 MIOPEN_EXPORT miopenStatus_t
1693 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,
1694  const miopenTensorDescriptor_t dyDesc,
1695  const miopenTensorDescriptor_t xDesc,
1696  const miopenConvolutionDescriptor_t convDesc,
1697  const miopenTensorDescriptor_t dwDesc,
1698  const uint64_t solution_id);
1699 
1718 MIOPEN_EXPORT miopenStatus_t
1719 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,
1720  const miopenTensorDescriptor_t dyDesc,
1721  const void* dy,
1722  const miopenTensorDescriptor_t xDesc,
1723  const void* x,
1724  const miopenConvolutionDescriptor_t convDesc,
1725  const miopenTensorDescriptor_t dwDesc,
1726  void* dw,
1727  void* workSpace,
1728  size_t workSpaceSize,
1729  const uint64_t solution_id);
1730 
1757 MIOPEN_EXPORT miopenStatus_t
1758 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,
1759  const miopenTensorDescriptor_t wDesc,
1760  const miopenTensorDescriptor_t xDesc,
1761  const miopenConvolutionDescriptor_t convDesc,
1762  const miopenTensorDescriptor_t yDesc,
1763  size_t* workSpaceSize);
1764 
1808 MIOPEN_EXPORT miopenStatus_t
1809 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,
1810  const miopenTensorDescriptor_t xDesc,
1811  const void* x,
1812  const miopenTensorDescriptor_t wDesc,
1813  const void* w,
1814  const miopenConvolutionDescriptor_t convDesc,
1815  const miopenTensorDescriptor_t yDesc,
1816  void* y,
1817  const int requestAlgoCount,
1818  int* returnedAlgoCount,
1819  miopenConvAlgoPerf_t* perfResults,
1820  void* workSpace,
1821  size_t workSpaceSize,
1822  bool exhaustiveSearch);
1823 
1858 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,
1859  const void* alpha,
1860  const miopenTensorDescriptor_t xDesc,
1861  const void* x,
1862  const miopenTensorDescriptor_t wDesc,
1863  const void* w,
1864  const miopenConvolutionDescriptor_t convDesc,
1865  miopenConvFwdAlgorithm_t algo,
1866  const void* beta,
1867  const miopenTensorDescriptor_t yDesc,
1868  void* y,
1869  void* workSpace,
1870  size_t workSpaceSize);
1871 
1887 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,
1888  const void* alpha,
1889  const miopenTensorDescriptor_t bDesc,
1890  const void* b,
1891  const void* beta,
1892  const miopenTensorDescriptor_t yDesc,
1893  void* y);
1894 
1922 MIOPEN_EXPORT miopenStatus_t
1923 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,
1924  const miopenTensorDescriptor_t dyDesc,
1925  const miopenTensorDescriptor_t wDesc,
1926  const miopenConvolutionDescriptor_t convDesc,
1927  const miopenTensorDescriptor_t dxDesc,
1928  size_t* workSpaceSize);
1929 
1973 MIOPEN_EXPORT miopenStatus_t
1974 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,
1975  const miopenTensorDescriptor_t dyDesc,
1976  const void* dy,
1977  const miopenTensorDescriptor_t wDesc,
1978  const void* w,
1979  const miopenConvolutionDescriptor_t convDesc,
1980  const miopenTensorDescriptor_t dxDesc,
1981  void* dx,
1982  const int requestAlgoCount,
1983  int* returnedAlgoCount,
1984  miopenConvAlgoPerf_t* perfResults,
1985  void* workSpace,
1986  size_t workSpaceSize,
1987  bool exhaustiveSearch);
1988 
2022 MIOPEN_EXPORT miopenStatus_t
2023 miopenConvolutionBackwardData(miopenHandle_t handle,
2024  const void* alpha,
2025  const miopenTensorDescriptor_t dyDesc,
2026  const void* dy,
2027  const miopenTensorDescriptor_t wDesc,
2028  const void* w,
2029  const miopenConvolutionDescriptor_t convDesc,
2030  miopenConvBwdDataAlgorithm_t algo,
2031  const void* beta,
2032  const miopenTensorDescriptor_t dxDesc,
2033  void* dx,
2034  void* workSpace,
2035  size_t workSpaceSize);
2036 
2064 MIOPEN_EXPORT miopenStatus_t
2065 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,
2066  const miopenTensorDescriptor_t dyDesc,
2067  const miopenTensorDescriptor_t xDesc,
2068  const miopenConvolutionDescriptor_t convDesc,
2069  const miopenTensorDescriptor_t dwDesc,
2070  size_t* workSpaceSize);
2071 
2115 MIOPEN_EXPORT miopenStatus_t
2116 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,
2117  const miopenTensorDescriptor_t dyDesc,
2118  const void* dy,
2119  const miopenTensorDescriptor_t xDesc,
2120  const void* x,
2121  const miopenConvolutionDescriptor_t convDesc,
2122  const miopenTensorDescriptor_t dwDesc,
2123  void* dw,
2124  const int requestAlgoCount,
2125  int* returnedAlgoCount,
2126  miopenConvAlgoPerf_t* perfResults,
2127  void* workSpace,
2128  size_t workSpaceSize,
2129  bool exhaustiveSearch);
2130 
2164 MIOPEN_EXPORT miopenStatus_t
2165 miopenConvolutionBackwardWeights(miopenHandle_t handle,
2166  const void* alpha,
2167  const miopenTensorDescriptor_t dyDesc,
2168  const void* dy,
2169  const miopenTensorDescriptor_t xDesc,
2170  const void* x,
2171  const miopenConvolutionDescriptor_t convDesc,
2172  miopenConvBwdWeightsAlgorithm_t algo,
2173  const void* beta,
2174  const miopenTensorDescriptor_t dwDesc,
2175  void* dw,
2176  void* workSpace,
2177  size_t workSpaceSize);
2178 
2194 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,
2195  const void* alpha,
2196  const miopenTensorDescriptor_t dyDesc,
2197  const void* dy,
2198  const void* beta,
2199  const miopenTensorDescriptor_t dbDesc,
2200  void* db);
2201 
2203 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP
2204 
2205 // Pooling APIs
2216 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);
2217 
2226 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2227  miopenIndexType_t index_type);
2228 
2236 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2237  miopenIndexType_t* index_type);
2238 
2246 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(
2247  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);
2248 
2255 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(
2256  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);
2257 
2272 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2273  miopenPoolingMode_t mode,
2274  int windowHeight,
2275  int windowWidth,
2276  int pad_h,
2277  int pad_w,
2278  int stride_h,
2279  int stride_w);
2280 
2295 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2296  miopenPoolingMode_t* mode,
2297  int* windowHeight,
2298  int* windowWidth,
2299  int* pad_h,
2300  int* pad_w,
2301  int* stride_h,
2302  int* stride_w);
2303 
2318 MIOPEN_EXPORT miopenStatus_t
2319 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2320  const miopenTensorDescriptor_t tensorDesc,
2321  int* n,
2322  int* c,
2323  int* h,
2324  int* w);
2325 
2341 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2342  const miopenPoolingMode_t mode,
2343  int nbDims,
2344  const int* windowDimA,
2345  const int* padA,
2346  const int* stridesA);
2347 
2364 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2365  int nbDimsRequested,
2366  miopenPoolingMode_t* mode,
2367  int* nbDims,
2368  int* windowDimA,
2369  int* padA,
2370  int* stridesA);
2371 
2384 MIOPEN_EXPORT miopenStatus_t
2385 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2386  const miopenTensorDescriptor_t tensorDesc,
2387  int dims,
2388  int* tensorDimArr);
2389 
2402 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2403  size_t* workSpaceSize);
2404 
2417 MIOPEN_EXPORT miopenStatus_t
2418 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,
2419  const miopenTensorDescriptor_t yDesc,
2420  size_t* workSpaceSize);
2421 
2442 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,
2443  const miopenPoolingDescriptor_t poolDesc,
2444  const void* alpha,
2445  const miopenTensorDescriptor_t xDesc,
2446  const void* x,
2447  const void* beta,
2448  const miopenTensorDescriptor_t yDesc,
2449  void* y,
2450  bool do_backward,
2451  void* workSpace,
2452  size_t workSpaceSize);
2453 
2474 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,
2475  const miopenPoolingDescriptor_t poolDesc,
2476  const void* alpha,
2477  const miopenTensorDescriptor_t yDesc,
2478  const void* y,
2479  const miopenTensorDescriptor_t dyDesc,
2480  const void* dy,
2481  const miopenTensorDescriptor_t xDesc,
2482  const void* x,
2483  const void* beta,
2484  const miopenTensorDescriptor_t dxDesc,
2485  void* dx,
2486  void* workSpace);
2487 
2493 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);
2494 
2496 // CLOSEOUT POOLING DOXYGEN GROUP
2497 
2498 // LRN APIs
2508 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);
2509 
2523 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2524  miopenLRNMode_t mode,
2525  unsigned int lrnN,
2526  double lrnAlpha,
2527  double lrnBeta,
2528  double lrnK);
2529 
2542 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2543  miopenLRNMode_t* mode,
2544  unsigned int* lrnN,
2545  double* lrnAlpha,
2546  double* lrnBeta,
2547  double* lrnK);
2548 
2558 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2559  size_t* workSpaceSize);
2560 
2579 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,
2580  const miopenLRNDescriptor_t lrnDesc,
2581  const void* alpha,
2582  const miopenTensorDescriptor_t xDesc,
2583  const void* x,
2584  const void* beta,
2585  const miopenTensorDescriptor_t yDesc,
2586  void* y,
2587  bool do_backward,
2588  void* workSpace);
2589 
2607 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,
2608  const miopenLRNDescriptor_t lrnDesc,
2609  const void* alpha,
2610  const miopenTensorDescriptor_t yDesc,
2611  const void* y,
2612  const miopenTensorDescriptor_t dyDesc,
2613  const void* dy,
2614  const miopenTensorDescriptor_t xDesc,
2615  const void* x,
2616  const void* beta,
2617  const miopenTensorDescriptor_t dxDesc,
2618  void* dx,
2619  const void* workSpace);
2620 
2626 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);
2627 
2629 // CLOSEOUT LRN DOXYGEN GROUP
2630 
2631 #ifdef MIOPEN_BETA_API
2632 // LayerNorm APIs
2657 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,
2658  miopenNormMode_t mode,
2659  const miopenTensorDescriptor_t xDesc,
2660  const void* x,
2661  const miopenTensorDescriptor_t weightDesc,
2662  const void* weight,
2663  const miopenTensorDescriptor_t biasDesc,
2664  const void* bias,
2665  const float epsilon,
2666  const int32_t normalized_dim,
2667  const miopenTensorDescriptor_t yDesc,
2668  void* y,
2669  const miopenTensorDescriptor_t meanDesc,
2670  void* mean,
2671  const miopenTensorDescriptor_t rstdDesc,
2672  void* rstd);
2673 
2675 // CLOSEOUT LAYERNORM DOXYGEN GROUP
2676 #endif
2677 
2678 #ifdef MIOPEN_BETA_API
2679 // Cat APIs
2695 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,
2696  const int32_t xCount,
2697  const miopenTensorDescriptor_t* xDescs,
2698  const void* const* xs,
2699  const miopenTensorDescriptor_t yDesc,
2700  void* y,
2701  const int32_t dim);
2702 
2704 // CLOSEOUT CAT DOXYGEN GROUP
2705 #endif
2706 
2707 // Batch-Normalization APIs
2729 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,
2730  const miopenTensorDescriptor_t xDesc,
2731  miopenBatchNormMode_t bn_mode);
2732 
2771 MIOPEN_EXPORT miopenStatus_t
2772 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,
2773  miopenBatchNormMode_t bn_mode,
2774  void* alpha,
2775  void* beta,
2776  const miopenTensorDescriptor_t xDesc,
2777  const void* x,
2778  const miopenTensorDescriptor_t yDesc,
2779  void* y,
2780  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
2781  void* bnScale,
2782  void* bnBias,
2783  double expAvgFactor,
2784  void* resultRunningMean,
2785  void* resultRunningVariance,
2786  double epsilon,
2787  void* resultSaveMean,
2788  void* resultSaveInvVariance);
2829 MIOPEN_EXPORT miopenStatus_t
2830 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,
2831  miopenBatchNormMode_t bn_mode,
2832  void* alpha,
2833  void* beta,
2834  const miopenTensorDescriptor_t xDesc,
2835  const void* x,
2836  const miopenTensorDescriptor_t yDesc,
2837  void* y,
2838  const miopenTensorDescriptor_t scaleDesc,
2839  const miopenTensorDescriptor_t biasVarDesc,
2840  const miopenTensorDescriptor_t savedMeanDesc,
2841  const miopenTensorDescriptor_t savedVarDesc,
2842  void* bnScale,
2843  void* bnBias,
2844  double expAvgFactor,
2845  void* resultRunningMean,
2846  void* resultRunningVariance,
2847  double epsilon,
2848  void* resultSaveMean,
2849  void* resultSaveInvVariance);
2891 MIOPEN_EXPORT miopenStatus_t
2892 miopenBatchNormForwardTrainingActivation(miopenHandle_t handle,
2893  miopenBatchNormMode_t bn_mode,
2894  void* alpha,
2895  void* beta,
2896  const miopenTensorDescriptor_t xDesc,
2897  const void* x,
2898  const miopenTensorDescriptor_t yDesc,
2899  void* y,
2900  const miopenTensorDescriptor_t scaleDesc,
2901  const miopenTensorDescriptor_t biasVarDesc,
2902  const miopenTensorDescriptor_t savedMeanDesc,
2903  const miopenTensorDescriptor_t savedVarDesc,
2904  void* bnScale,
2905  void* bnBias,
2906  double expAvgFactor,
2907  void* resultRunningMean,
2908  void* resultRunningVariance,
2909  double epsilon,
2910  void* resultSaveMean,
2911  void* resultSaveInvVariance,
2912  const miopenActivationDescriptor_t activDesc);
2913 
2943 MIOPEN_EXPORT miopenStatus_t
2944 miopenBatchNormalizationForwardInference(miopenHandle_t handle,
2945  miopenBatchNormMode_t bn_mode,
2946  void* alpha,
2947  void* beta,
2948  const miopenTensorDescriptor_t xDesc,
2949  const void* x,
2950  const miopenTensorDescriptor_t yDesc,
2951  void* y,
2952  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
2953  void* bnScale,
2954  void* bnBias,
2955  void* estimatedMean,
2956  void* estimatedVariance,
2957  double epsilon);
2958 
2990 MIOPEN_EXPORT miopenStatus_t
2991 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,
2992  miopenBatchNormMode_t bn_mode,
2993  void* alpha,
2994  void* beta,
2995  const miopenTensorDescriptor_t xDesc,
2996  const void* x,
2997  const miopenTensorDescriptor_t yDesc,
2998  void* y,
2999  const miopenTensorDescriptor_t scaleDesc,
3000  const miopenTensorDescriptor_t biasDesc,
3001  const miopenTensorDescriptor_t estMeanDesc,
3002  const miopenTensorDescriptor_t estVarianceDesc,
3003  void* bnScale,
3004  void* bnBias,
3005  void* estimatedMean,
3006  void* estimatedVariance,
3007  double epsilon);
3008 
3041 MIOPEN_EXPORT miopenStatus_t
3042 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,
3043  miopenBatchNormMode_t bn_mode,
3044  void* alpha,
3045  void* beta,
3046  const miopenTensorDescriptor_t xDesc,
3047  const void* x,
3048  const miopenTensorDescriptor_t yDesc,
3049  void* y,
3050  const miopenTensorDescriptor_t scaleDesc,
3051  const miopenTensorDescriptor_t biasDesc,
3052  const miopenTensorDescriptor_t estMeanDesc,
3053  const miopenTensorDescriptor_t estVarianceDesc,
3054  void* bnScale,
3055  void* bnBias,
3056  void* estimatedMean,
3057  void* estimatedVariance,
3058  double epsilon,
3059  const miopenActivationDescriptor_t activDesc);
3060 
3095 MIOPEN_EXPORT miopenStatus_t
3096 miopenBatchNormalizationBackward(miopenHandle_t handle,
3097  miopenBatchNormMode_t bn_mode,
3098  const void* alphaDataDiff,
3099  const void* betaDataDiff,
3100  const void* alphaParamDiff,
3101  const void* betaParamDiff,
3102  const miopenTensorDescriptor_t xDesc,
3103  const void* x,
3104  const miopenTensorDescriptor_t dyDesc,
3105  const void* dy,
3106  const miopenTensorDescriptor_t dxDesc,
3107  void* dx,
3108  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,
3109  const void* bnScale,
3110  void* resultBnScaleDiff,
3111  void* resultBnBiasDiff,
3112  double epsilon,
3113  const void* savedMean,
3114  const void* savedInvVariance);
3115 
3154 MIOPEN_EXPORT miopenStatus_t
3155 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,
3156  miopenBatchNormMode_t bn_mode,
3157  const void* alphaDataDiff,
3158  const void* betaDataDiff,
3159  const void* alphaParamDiff,
3160  const void* betaParamDiff,
3161  const miopenTensorDescriptor_t xDesc,
3162  const void* x,
3163  const miopenTensorDescriptor_t dyDesc,
3164  const void* dy,
3165  const miopenTensorDescriptor_t dxDesc,
3166  void* dx,
3167  const miopenTensorDescriptor_t scaleDesc,
3168  const miopenTensorDescriptor_t biasDesc,
3169  const miopenTensorDescriptor_t savedMeanDesc,
3170  const miopenTensorDescriptor_t savedVarDesc,
3171  const void* bnScale,
3172  void* resultBnScaleDiff,
3173  void* resultBnBiasDiff,
3174  double epsilon,
3175  const void* savedMean,
3176  const void* savedInvVariance);
3177 
3218 MIOPEN_EXPORT miopenStatus_t
3219 miopenBatchNormBackwardActivation(miopenHandle_t handle,
3220  miopenBatchNormMode_t bn_mode,
3221  const void* alphaDataDiff,
3222  const void* betaDataDiff,
3223  const void* alphaParamDiff,
3224  const void* betaParamDiff,
3225  const miopenTensorDescriptor_t xDesc,
3226  const void* x,
3227  const miopenTensorDescriptor_t dyDesc,
3228  const void* dy,
3229  const miopenTensorDescriptor_t dxDesc,
3230  void* dx,
3231  const miopenTensorDescriptor_t scaleDesc,
3232  const miopenTensorDescriptor_t biasDesc,
3233  const miopenTensorDescriptor_t savedMeanDesc,
3234  const miopenTensorDescriptor_t savedVarianceDesc,
3235  const void* bnScale,
3236  const void* bnBias,
3237  void* resultBnScaleDiff,
3238  void* resultBnBiasDiff,
3239  double epsilon,
3240  const void* savedMean,
3241  const void* savedInvVariance,
3242  const miopenActivationDescriptor_t activDesc);
3244 // CLOSEOUT BATCHNORM DOXYGEN GROUP
3245 
3246 // Activation APIs
3256 MIOPEN_EXPORT miopenStatus_t
3257 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);
3258 
3270 MIOPEN_EXPORT miopenStatus_t
3271 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3272  miopenActivationMode_t mode,
3273  double activAlpha,
3274  double activBeta,
3275  double activGamma);
3276 
3288 MIOPEN_EXPORT miopenStatus_t
3289 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3290  miopenActivationMode_t* mode,
3291  double* activAlpha,
3292  double* activBeta,
3293  double* activGamma);
3294 
3307 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,
3308  const miopenActivationDescriptor_t activDesc,
3309  const void* alpha,
3310  const miopenTensorDescriptor_t xDesc,
3311  const void* x,
3312  const void* beta,
3313  const miopenTensorDescriptor_t yDesc,
3314  void* y);
3315 
3332 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,
3333  const miopenActivationDescriptor_t activDesc,
3334  const void* alpha,
3335  const miopenTensorDescriptor_t yDesc,
3336  const void* y,
3337  const miopenTensorDescriptor_t dyDesc,
3338  const void* dy,
3339  const miopenTensorDescriptor_t xDesc,
3340  const void* x,
3341  const void* beta,
3342  const miopenTensorDescriptor_t dxDesc,
3343  void* dx);
3344 
3350 MIOPEN_EXPORT miopenStatus_t
3351 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);
3352 
3354 // CLOSEOUT ACTIVATION DOXYGEN GROUP
3355 
3356 #ifdef MIOPEN_BETA_API
3372 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,
3373  const miopenTensorDescriptor_t inputDesc,
3374  const void* input,
3375  const miopenTensorDescriptor_t outputDesc,
3376  void* output,
3377  const uint32_t dim);
3378 
3391 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,
3392  const miopenTensorDescriptor_t inputDesc,
3393  const void* input,
3394  const miopenTensorDescriptor_t outputGradDesc,
3395  const void* outputGrad,
3396  const miopenTensorDescriptor_t inputGradDesc,
3397  void* inputGrad,
3398  const uint32_t dim);
3399 
3401 // CLOSEOUT ACTIVATION DOXYGEN GROUP
3402 #endif // MIOPEN_BETA_API
3403 
3404 // Softmax APIs
3422 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,
3423  const void* alpha,
3424  const miopenTensorDescriptor_t xDesc,
3425  const void* x,
3426  const void* beta,
3427  const miopenTensorDescriptor_t yDesc,
3428  void* y);
3429 
3445 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,
3446  const void* alpha,
3447  const miopenTensorDescriptor_t yDesc,
3448  const void* y,
3449  const miopenTensorDescriptor_t dyDesc,
3450  const void* dy,
3451  const void* beta,
3452  const miopenTensorDescriptor_t dxDesc,
3453  void* dx);
3454 
3468 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,
3469  const void* alpha,
3470  const miopenTensorDescriptor_t xDesc,
3471  const void* x,
3472  const void* beta,
3473  const miopenTensorDescriptor_t yDesc,
3474  void* y,
3475  miopenSoftmaxAlgorithm_t algorithm,
3476  miopenSoftmaxMode_t mode);
3477 
3493 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,
3494  const void* alpha,
3495  const miopenTensorDescriptor_t yDesc,
3496  const void* y,
3497  const miopenTensorDescriptor_t dyDesc,
3498  const void* dy,
3499  const void* beta,
3500  const miopenTensorDescriptor_t dxDesc,
3501  void* dx,
3502  miopenSoftmaxAlgorithm_t algorithm,
3503  miopenSoftmaxMode_t mode);
3504 
3506 // CLOSEOUT SOFTMAX DOXYGEN GROUP
3507 
3511 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);
3512 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);
3513 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);
3514 
3523 typedef enum
3524 {
3525  miopenVerticalFusion = 0,
3526  miopenHorizontalFusion = 1,
3527 } miopenFusionDirection_t;
3528 
3536 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,
3537  const miopenFusionDirection_t fuseDirection,
3538  const miopenTensorDescriptor_t inputDesc);
3539 
3545 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);
3546 
3553 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,
3554  miopenFusionPlanDescriptor_t fusePlanDesc);
3555 
3566 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,
3567  const int op_idx,
3568  miopenFusionOpDescriptor_t* op);
3569 
3577 MIOPEN_EXPORT miopenStatus_t
3578 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,
3579  miopenFusionPlanDescriptor_t fusePlanDesc,
3580  size_t* workSpaceSize,
3581  miopenConvFwdAlgorithm_t algo);
3582 
3600 MIOPEN_EXPORT miopenStatus_t
3601 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,
3602  const int requestAlgoCount,
3603  int* returnedAlgoCount,
3604  miopenConvFwdAlgorithm_t* returnedAlgos);
3605 
3615 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(
3616  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);
3617 
3626 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3627  miopenFusionOpDescriptor_t* convOp,
3628  miopenConvolutionDescriptor_t convDesc,
3629  const miopenTensorDescriptor_t wDesc);
3630 
3631 //---
3632 
3633 // Activation forward create ops ---
3641 MIOPEN_EXPORT miopenStatus_t
3642 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3643  miopenFusionOpDescriptor_t* activFwdOp,
3644  miopenActivationMode_t mode);
3645 
3646 // Activation backward create ops ---
3654 MIOPEN_EXPORT miopenStatus_t
3655 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3656  miopenFusionOpDescriptor_t* activBwdOp,
3657  miopenActivationMode_t mode);
3658 
3659 // Bias create ops ---
3667 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3668  miopenFusionOpDescriptor_t* biasOp,
3669  const miopenTensorDescriptor_t bDesc);
3670 
3671 // Batch normalization create ops ---
3680 MIOPEN_EXPORT miopenStatus_t
3681 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,
3682  miopenFusionOpDescriptor_t* bnOp,
3683  const miopenBatchNormMode_t bn_mode,
3684  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);
3685 
3695 MIOPEN_EXPORT miopenStatus_t
3696 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3697  miopenFusionOpDescriptor_t* bnFwdOp,
3698  const miopenBatchNormMode_t bn_mode,
3699  bool runningMeanVariance);
3700 
3708 MIOPEN_EXPORT miopenStatus_t
3709 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3710  miopenFusionOpDescriptor_t* bnBwdOp,
3711  const miopenBatchNormMode_t bn_mode);
3712 
3713 //---
3719 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);
3720 
3726 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);
3727 
3728 // Convolution set arguments ---
3738 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,
3739  const miopenFusionOpDescriptor_t convOp,
3740  const void* alpha,
3741  const void* beta,
3742  const void* w);
3743 // Activation set arguments ---
3755 MIOPEN_EXPORT miopenStatus_t
3756 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,
3757  const miopenFusionOpDescriptor_t activFwdOp,
3758  const void* alpha,
3759  const void* beta,
3760  double activAlpha,
3761  double activBeta,
3762  double activGamma);
3763 
3777 MIOPEN_EXPORT miopenStatus_t
3778 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,
3779  const miopenFusionOpDescriptor_t activBwdOp,
3780  const void* alpha,
3781  const void* beta,
3782  const void* y,
3783  const void* reserved,
3784  double activAlpha,
3785  double activBeta,
3786  double activGamma);
3787 
3788 // Batch Normalization set arguments ---
3802 MIOPEN_EXPORT miopenStatus_t
3803 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,
3804  const miopenFusionOpDescriptor_t bnOp,
3805  const void* alpha,
3806  const void* beta,
3807  const void* bnScale,
3808  const void* bnBias,
3809  const void* estimatedMean,
3810  const void* estimatedVariance,
3811  double epsilon);
3812 
3829 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,
3830  const miopenFusionOpDescriptor_t bnOp,
3831  const void* alpha,
3832  const void* beta,
3833  const void* bnScale,
3834  const void* bnBias,
3835  void* savedMean,
3836  void* savedInvVariance,
3837  void* runningMean,
3838  void* runningVariance,
3839  double expAvgFactor,
3840  double epsilon);
3841 
3857 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,
3858  const miopenFusionOpDescriptor_t bnOp,
3859  const void* alpha,
3860  const void* beta,
3861  const void* x,
3862  const void* bnScale,
3863  const void* bnBias,
3864  void* resultBnScaleDiff,
3865  void* resultBnBiasDiff,
3866  const void* savedMean,
3867  const void* savedInvVariance);
3868 
3869 // Bias forward set arguments ---
3879 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,
3880  const miopenFusionOpDescriptor_t biasOp,
3881  const void* alpha,
3882  const void* beta,
3883  const void* bias);
3884 
3899 MIOPEN_EXPORT miopenStatus_t
3900 miopenExecuteFusionPlan(const miopenHandle_t handle,
3901  const miopenFusionPlanDescriptor_t fusePlanDesc,
3902  const miopenTensorDescriptor_t inputDesc,
3903  const void* input,
3904  const miopenTensorDescriptor_t outputDesc,
3905  void* output,
3906  miopenOperatorArgs_t args);
3907 
3922 MIOPEN_EXPORT miopenStatus_t
3923 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,
3924  const miopenFusionPlanDescriptor_t fusePlanDesc,
3925  const miopenTensorDescriptor_t inputDesc,
3926  const void* input,
3927  const miopenTensorDescriptor_t outputDesc,
3928  void* output,
3929  miopenOperatorArgs_t args,
3930  void* workspace,
3931  size_t workspaceSize);
3932 
3956 MIOPEN_EXPORT miopenStatus_t
3957 miopenConvolutionBiasActivationForward(miopenHandle_t handle,
3958  const void* alpha1,
3959  const miopenTensorDescriptor_t xDesc,
3960  const void* x,
3961  const miopenTensorDescriptor_t wDesc,
3962  const void* w,
3963  const miopenConvolutionDescriptor_t convDesc,
3964  miopenConvFwdAlgorithm_t algo,
3965  void* workspace,
3966  size_t workspaceSizeInBytes,
3967  const void* alpha2,
3968  const miopenTensorDescriptor_t zDesc,
3969  const void* z,
3970  const miopenTensorDescriptor_t biasDesc,
3971  const void* bias,
3972  const miopenActivationDescriptor_t activationDesc,
3973  const miopenTensorDescriptor_t yDesc,
3974  void* y);
3976 // CLOSEOUT FUSION DOXYGEN GROUP
3977 
3986 typedef enum
3987 {
3988  miopenRNNRELU = 0,
3989  miopenRNNTANH = 1,
3990  miopenLSTM = 2,
3991  miopenGRU = 3,
3992 } miopenRNNMode_t;
3993 
3997 typedef enum
3998 {
3999  miopenRNNlinear = 0,
4000  miopenRNNskip = 1,
4001 } miopenRNNInputMode_t;
4002 
4006 typedef enum
4007 {
4008  miopenRNNdefault = 0,
4010  miopenRNNfundamental = 1,
4012  miopenRNNroundedDynamic = 2,
4014 } miopenRNNAlgo_t;
4015 
4019 typedef enum
4020 {
4021  miopenRNNunidirection = 0,
4022  miopenRNNbidirection = 1,
4023 } miopenRNNDirectionMode_t;
4024 
4028 typedef enum
4029 {
4030  miopenRNNNoBias = 0,
4031  miopenRNNwithBias = 1,
4032 } miopenRNNBiasMode_t;
4033 
4037 typedef enum
4038 {
4039  miopenRNNAlgoGEMM = 0,
4040 } miopenRNNGEMMalgoMode_t;
4041 
4045 typedef enum
4046 {
4047  miopenRNNIONotPadded = 0,
4048  miopenRNNIOWithPadding = 1,
4049 } miopenRNNPaddingMode_t;
4050 
4054 typedef enum
4055 {
4056  miopenRNNTraining = 0,
4057  miopenRNNInference = 1,
4058 } miopenRNNFWDMode_t;
4059 
4063 typedef enum
4064 {
4065  miopenRNNDataUnknownLayout = 0,
4066  miopenRNNDataSeqMajorNotPadded = 1,
4067  miopenRNNDataSeqMajorPadded = 2,
4068  miopenRNNDataBatchMajorPadded = 3,
4069 } miopenRNNBaseLayout_t;
4070 
4077 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);
4078 
4091 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
4092  miopenRNNMode_t* rnnMode,
4093  miopenRNNAlgo_t* algoMode,
4094  miopenRNNInputMode_t* inputMode,
4095  miopenRNNDirectionMode_t* dirMode,
4096  miopenRNNBiasMode_t* biasMode,
4097  int* hiddenSize,
4098  int* layer);
4099 
4116 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
4117  int* hiddenSize,
4118  int* layer,
4119  miopenDropoutDescriptor_t* dropoutDesc,
4120  miopenRNNInputMode_t* inputMode,
4121  miopenRNNDirectionMode_t* dirMode,
4122  miopenRNNMode_t* rnnMode,
4123  miopenRNNBiasMode_t* biasMode,
4124  miopenRNNAlgo_t* algoMode,
4125  miopenDataType_t* dataType);
4126 
4132 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);
4133 
4149 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
4150  const int hsize,
4151  const int nlayers,
4152  miopenRNNInputMode_t inMode,
4153  miopenRNNDirectionMode_t direction,
4154  miopenRNNMode_t rnnMode,
4155  miopenRNNBiasMode_t biasMode,
4156  miopenRNNAlgo_t algo,
4157  miopenDataType_t dataType);
4158 
4177 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
4178  const int hsize,
4179  const int nlayers,
4180  miopenDropoutDescriptor_t dropoutDesc,
4181  miopenRNNInputMode_t inMode,
4182  miopenRNNDirectionMode_t direction,
4183  miopenRNNMode_t rnnMode,
4184  miopenRNNBiasMode_t biasMode,
4185  miopenRNNAlgo_t algo,
4186  miopenDataType_t dataType);
4187 
4202 MIOPEN_EXPORT miopenStatus_t
4203 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
4204  miopenDataType_t dataType,
4205  miopenRNNBaseLayout_t layout,
4206  int maxSequenceLen,
4207  int batchSize,
4208  int vectorSize,
4209  const int* sequenceLenArray,
4210  void* paddingMarker);
4211 
4230 MIOPEN_EXPORT miopenStatus_t
4231 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
4232  miopenDataType_t* dataType,
4233  miopenRNNBaseLayout_t* layout,
4234  int* maxSequenceLen,
4235  int* batchSize,
4236  int* vectorSize,
4237  int sequenceLenArrayLimit,
4238  int* sequenceLenArray,
4239  void* paddingMarker);
4240 
4257 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,
4258  const miopenRNNDescriptor_t rnnDesc,
4259  const int sequenceLen,
4260  const miopenTensorDescriptor_t* xDesc,
4261  size_t* numBytes);
4262 
4279 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,
4280  miopenRNNDescriptor_t rnnDesc,
4281  const int sequenceLen,
4282  const miopenTensorDescriptor_t* xDesc,
4283  size_t* numBytes);
4284 
4301 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,
4302  miopenRNNDescriptor_t rnnDesc,
4303  miopenSeqTensorDescriptor_t xDesc,
4304  miopenRNNFWDMode_t fwdMode,
4305  size_t* workSpaceSize,
4306  size_t* reserveSpaceSize);
4307 
4320 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,
4321  miopenRNNDescriptor_t rnnDesc,
4322  miopenTensorDescriptor_t xDesc,
4323  size_t* numBytes,
4324  miopenDataType_t dtype);
4325 
4338 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,
4339  miopenRNNDescriptor_t rnnDesc,
4340  miopenTensorDescriptor_t xDesc,
4341  miopenTensorDescriptor_t wDesc,
4342  miopenDataType_t dtype);
4343 
4361 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,
4362  miopenRNNDescriptor_t rnnDesc,
4363  const int seqLen,
4364  miopenTensorDescriptor_t* xDesc,
4365  size_t* numBytes);
4366 
4379 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,
4380  miopenRNNDescriptor_t rnnDesc,
4381  const int seqLen,
4382  miopenTensorDescriptor_t* xDesc,
4383  size_t* numBytes);
4384 
4425 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,
4426  miopenRNNDescriptor_t rnnDesc,
4427  const int layer,
4428  miopenTensorDescriptor_t xDesc,
4429  const int paramID,
4430  size_t* numBytes);
4431 
4469 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,
4470  miopenRNNDescriptor_t rnnDesc,
4471  const int layer,
4472  const int biasID,
4473  size_t* numBytes);
4474 
4533 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,
4534  miopenRNNDescriptor_t rnnDesc,
4535  const int layer,
4536  miopenTensorDescriptor_t xDesc,
4537  miopenTensorDescriptor_t wDesc,
4538  const void* w,
4539  const int paramID,
4540  miopenTensorDescriptor_t paramDesc,
4541  void* layerParam);
4542 
4600 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,
4601  miopenRNNDescriptor_t rnnDesc,
4602  const int layer,
4603  miopenTensorDescriptor_t xDesc,
4604  miopenTensorDescriptor_t wDesc,
4605  const void* w,
4606  const int biasID,
4607  miopenTensorDescriptor_t biasDesc,
4608  void* layerBias);
4609 
4664 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,
4665  const int layer,
4666  miopenTensorDescriptor_t xDesc,
4667  const int paramID,
4668  miopenTensorDescriptor_t paramDesc,
4669  size_t* layerParamOffset);
4670 
4721 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,
4722  const int layer,
4723  miopenTensorDescriptor_t xDesc,
4724  const int biasID,
4725  miopenTensorDescriptor_t biasDesc,
4726  size_t* layerBiasOffset);
4727 
4780 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,
4781  miopenRNNDescriptor_t rnnDesc,
4782  const int layer,
4783  miopenTensorDescriptor_t xDesc,
4784  miopenTensorDescriptor_t wDesc,
4785  void* w,
4786  const int paramID,
4787  miopenTensorDescriptor_t paramDesc,
4788  const void* layerParam);
4789 
4840 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,
4841  miopenRNNDescriptor_t rnnDesc,
4842  const int layer,
4843  miopenTensorDescriptor_t xDesc,
4844  miopenTensorDescriptor_t wDesc,
4845  void* w,
4846  const int biasID,
4847  miopenTensorDescriptor_t biasDesc,
4848  const void* layerBias);
4849 
4861 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
4862  miopenRNNPaddingMode_t paddingMode);
4863 
4871 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
4872  miopenRNNPaddingMode_t* paddingMode);
4873 
4924 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,
4925  const miopenRNNDescriptor_t rnnDesc,
4926  miopenRNNFWDMode_t fwdMode,
4927  const miopenSeqTensorDescriptor_t xDesc,
4928  const void* x,
4929  const miopenTensorDescriptor_t hDesc,
4930  const void* hx,
4931  void* hy,
4932  const miopenTensorDescriptor_t cDesc,
4933  const void* cx,
4934  void* cy,
4935  const miopenSeqTensorDescriptor_t yDesc,
4936  void* y,
4937  const void* w,
4938  size_t weightSpaceSize,
4939  void* workSpace,
4940  size_t workSpaceNumBytes,
4941  void* reserveSpace,
4942  size_t reserveSpaceNumBytes);
4943 
4993 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,
4994  const miopenRNNDescriptor_t rnnDesc,
4995  const miopenSeqTensorDescriptor_t yDesc,
4996  const void* y,
4997  const void* dy,
4998  const miopenTensorDescriptor_t hDesc,
4999  const void* hx,
5000  const void* dhy,
5001  void* dhx,
5002  const miopenTensorDescriptor_t cDesc,
5003  const void* cx,
5004  const void* dcy,
5005  void* dcx,
5006  const miopenSeqTensorDescriptor_t xDesc,
5007  void* dx,
5008  const void* w,
5009  size_t weightSpaceSize,
5010  void* workSpace,
5011  size_t workSpaceNumBytes,
5012  void* reserveSpace,
5013  size_t reserveSpaceNumBytes);
5014 
5048 MIOPEN_EXPORT miopenStatus_t
5049 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,
5050  const miopenRNNDescriptor_t rnnDesc,
5051  const miopenSeqTensorDescriptor_t xDesc,
5052  const void* x,
5053  const miopenTensorDescriptor_t hDesc,
5054  const void* hx,
5055  const miopenSeqTensorDescriptor_t yDesc,
5056  const void* y,
5057  void* dw,
5058  size_t weightSpaceSize,
5059  void* workSpace,
5060  size_t workSpaceNumBytes,
5061  const void* reserveSpace,
5062  size_t reserveSpaceNumBytes);
5063 
5121 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,
5122  const miopenRNNDescriptor_t rnnDesc,
5123  const int sequenceLen,
5124  const miopenTensorDescriptor_t* xDesc,
5125  const void* x,
5126  const miopenTensorDescriptor_t hxDesc,
5127  const void* hx,
5128  const miopenTensorDescriptor_t cxDesc,
5129  const void* cx,
5130  const miopenTensorDescriptor_t wDesc,
5131  const void* w,
5132  const miopenTensorDescriptor_t* yDesc,
5133  void* y,
5134  const miopenTensorDescriptor_t hyDesc,
5135  void* hy,
5136  const miopenTensorDescriptor_t cyDesc,
5137  void* cy,
5138  void* workSpace,
5139  size_t workSpaceNumBytes,
5140  void* reserveSpace,
5141  size_t reserveSpaceNumBytes);
5142 
5215 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,
5216  const miopenRNNDescriptor_t rnnDesc,
5217  const int sequenceLen,
5218  const miopenTensorDescriptor_t* yDesc,
5219  const void* y,
5220  const miopenTensorDescriptor_t* dyDesc,
5221  const void* dy,
5222  const miopenTensorDescriptor_t dhyDesc,
5223  const void* dhy,
5224  const miopenTensorDescriptor_t dcyDesc,
5225  const void* dcy,
5226  const miopenTensorDescriptor_t wDesc,
5227  const void* w,
5228  const miopenTensorDescriptor_t hxDesc,
5229  const void* hx,
5230  const miopenTensorDescriptor_t cxDesc,
5231  const void* cx,
5232  const miopenTensorDescriptor_t* dxDesc,
5233  void* dx,
5234  const miopenTensorDescriptor_t dhxDesc,
5235  void* dhx,
5236  const miopenTensorDescriptor_t dcxDesc,
5237  void* dcx,
5238  void* workSpace,
5239  size_t workSpaceNumBytes,
5240  void* reserveSpace,
5241  size_t reserveSpaceNumBytes);
5242 
5279 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,
5280  const miopenRNNDescriptor_t rnnDesc,
5281  const int sequenceLen,
5282  const miopenTensorDescriptor_t* xDesc,
5283  const void* x,
5284  const miopenTensorDescriptor_t hxDesc,
5285  const void* hx,
5286  const miopenTensorDescriptor_t* yDesc,
5287  const void* y,
5288  const miopenTensorDescriptor_t dwDesc,
5289  void* dw,
5290  void* workSpace,
5291  size_t workSpaceNumBytes,
5292  const void* reserveSpace,
5293  size_t reserveSpaceNumBytes);
5294 
5350 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,
5351  miopenRNNDescriptor_t rnnDesc,
5352  const int sequenceLen,
5353  const miopenTensorDescriptor_t* xDesc,
5354  const void* x,
5355  const miopenTensorDescriptor_t hxDesc,
5356  const void* hx,
5357  const miopenTensorDescriptor_t cxDesc,
5358  const void* cx,
5359  const miopenTensorDescriptor_t wDesc,
5360  const void* w,
5361  const miopenTensorDescriptor_t* yDesc,
5362  void* y,
5363  const miopenTensorDescriptor_t hyDesc,
5364  void* hy,
5365  const miopenTensorDescriptor_t cyDesc,
5366  void* cy,
5367  void* workSpace,
5368  size_t workSpaceNumBytes);
5369 
5371 // CLOSEOUT RNN DOXYGEN GROUP
5372 
5381 typedef enum
5382 {
5383  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,
5384 } miopenCTCLossAlgo_t;
5385 
5392 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);
5393 
5403 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5404  miopenDataType_t* dataType,
5405  int* blank_label_id,
5406  bool* apply_softmax_layer);
5407 
5413 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);
5414 
5424 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5425  miopenDataType_t dataType,
5426  const int blank_label_id,
5427  bool apply_softmax_layer);
5428 
5445 MIOPEN_EXPORT miopenStatus_t
5446 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,
5447  const miopenTensorDescriptor_t probsDesc,
5448  const miopenTensorDescriptor_t gradientsDesc,
5449  const int* labels,
5450  const int* labelLengths,
5451  const int* inputLengths,
5452  miopenCTCLossAlgo_t algo,
5453  const miopenCTCLossDescriptor_t ctcLossDesc,
5454  size_t* workSpaceSize);
5455 
5475 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,
5476  const miopenTensorDescriptor_t probsDesc,
5477  const void* probs,
5478  const int* labels,
5479  const int* labelLengths,
5480  const int* inputLengths,
5481  void* losses,
5482  const miopenTensorDescriptor_t gradientsDesc,
5483  void* gradients,
5484  miopenCTCLossAlgo_t algo,
5485  const miopenCTCLossDescriptor_t ctcLossDesc,
5486  void* workSpace,
5487  size_t workSpaceSize);
5488 
5490 // CLOSEOUT LossFunction DOXYGEN GROUP
5491 
5492 // Dropout APIs
5501 typedef enum
5502 {
5503  MIOPEN_RNG_PSEUDO_XORWOW = 0,
5504 } miopenRNGType_t;
5505 
5511 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);
5512 
5518 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);
5519 
5528 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,
5529  size_t* reserveSpaceSizeInBytes);
5530 
5539 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,
5540  size_t* stateSizeInBytes);
5541 
5558 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5559  miopenHandle_t handle,
5560  float* dropout,
5561  void** states,
5562  unsigned long long* seed,
5563  bool* use_mask,
5564  bool* state_evo,
5565  miopenRNGType_t* rng_mode);
5566 
5589 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5590  miopenHandle_t handle,
5591  float dropout,
5592  void* states,
5593  size_t stateSizeInBytes,
5594  unsigned long long seed,
5595  bool use_mask,
5596  bool state_evo,
5597  miopenRNGType_t rng_mode);
5598 
5618 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5619  miopenHandle_t handle,
5620  float dropout,
5621  void* states,
5622  size_t stateSizeInBytes,
5623  unsigned long long seed,
5624  bool use_mask,
5625  bool state_evo,
5626  miopenRNGType_t rng_mode);
5627 
5645 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,
5646  const miopenDropoutDescriptor_t dropoutDesc,
5647  const miopenTensorDescriptor_t noise_shape,
5648  const miopenTensorDescriptor_t xDesc,
5649  const void* x,
5650  const miopenTensorDescriptor_t yDesc,
5651  void* y,
5652  void* reserveSpace,
5653  size_t reserveSpaceSizeInBytes);
5654 
5672 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,
5673  const miopenDropoutDescriptor_t dropoutDesc,
5674  const miopenTensorDescriptor_t noise_shape,
5675  const miopenTensorDescriptor_t dyDesc,
5676  const void* dy,
5677  const miopenTensorDescriptor_t dxDesc,
5678  void* dx,
5679  void* reserveSpace,
5680  size_t reserveSpaceSizeInBytes);
5681 
5683 // CLOSEOUT DROPOUT DOXYGEN GROUP
5684 
5685 // TensorReduce APIs
5696 MIOPEN_EXPORT miopenStatus_t
5697 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);
5698 
5704 MIOPEN_EXPORT miopenStatus_t
5705 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);
5706 
5719 MIOPEN_EXPORT miopenStatus_t
5720 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,
5721  miopenReduceTensorOp_t reduceTensorOp,
5722  miopenDataType_t reduceTensorCompType,
5723  miopenNanPropagation_t reduceTensorNanOpt,
5724  miopenReduceTensorIndices_t reduceTensorIndices,
5725  miopenIndicesType_t reduceTensorIndicesType);
5726 
5742 MIOPEN_EXPORT miopenStatus_t
5743 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,
5744  miopenReduceTensorOp_t* reduceTensorOp,
5745  miopenDataType_t* reduceTensorCompType,
5746  miopenNanPropagation_t* reduceTensorNanOpt,
5747  miopenReduceTensorIndices_t* reduceTensorIndices,
5748  miopenIndicesType_t* reduceTensorIndicesType);
5749 
5759 MIOPEN_EXPORT miopenStatus_t
5760 miopenGetReductionIndicesSize(miopenHandle_t handle,
5761  const miopenReduceTensorDescriptor_t reduceTensorDesc,
5762  const miopenTensorDescriptor_t aDesc,
5763  const miopenTensorDescriptor_t cDesc,
5764  size_t* sizeInBytes);
5765 
5775 MIOPEN_EXPORT miopenStatus_t
5776 miopenGetReductionWorkspaceSize(miopenHandle_t handle,
5777  const miopenReduceTensorDescriptor_t reduceTensorDesc,
5778  const miopenTensorDescriptor_t aDesc,
5779  const miopenTensorDescriptor_t cDesc,
5780  size_t* sizeInBytes);
5781 
5805 MIOPEN_EXPORT miopenStatus_t
5806 miopenReduceTensor(miopenHandle_t handle,
5807  const miopenReduceTensorDescriptor_t reduceTensorDesc,
5808  void* indices,
5809  size_t indicesSizeInBytes,
5810  void* workspace,
5811  size_t workspaceSizeInBytes,
5812  const void* alpha,
5813  const miopenTensorDescriptor_t aDesc,
5814  const void* A,
5815  const void* beta,
5816  const miopenTensorDescriptor_t cDesc,
5817  void* C);
5818 
5820 // CLOSEOUT TensorReduce DOXYGEN GROUP
5821 
5822 // Find 2.0 API
5833 MIOPEN_DECLARE_OBJECT(miopenProblem);
5834 
5838 typedef enum
5839 {
5840  miopenProblemDirectionForward = 0,
5841  miopenProblemDirectionBackward = 1,
5842  miopenProblemDirectionBackwardWeights = 2,
5843 #ifdef MIOPEN_BETA_API
5844  miopenProblemDirectionInference = 4,
5845 #endif
5846 } miopenProblemDirection_t;
5847 
5851 typedef enum
5852 {
5853  miopenTensorArgumentIdInvalid = 0,
5854  miopenTensorConvolutionX = 1,
5855  miopenTensorConvolutionW = 2,
5856  miopenTensorConvolutionY = 3,
5857 
5858  miopenTensorMhaK = 4,
5859  miopenTensorMhaQ = 5,
5860  miopenTensorMhaV = 6,
5861  miopenTensorMhaDescaleK = 7,
5862  miopenTensorMhaDescaleQ = 8,
5863  miopenTensorMhaDescaleV = 9,
5864  miopenTensorMhaDescaleS = 10,
5865  miopenTensorMhaScaleS = 11,
5866  miopenTensorMhaScaleO = 12,
5867  miopenTensorMhaDropoutProbability = 13,
5868  miopenTensorMhaDropoutSeed = 14,
5869  miopenTensorMhaDropoutOffset = 15,
5870  miopenTensorMhaO = 16,
5871  miopenTensorMhaAmaxO = 17,
5872  miopenTensorMhaAmaxS = 18,
5873  miopenTensorMhaM = 19,
5874  miopenTensorMhaZInv = 20,
5875  miopenTensorMhaDO = 21,
5876  miopenTensorMhaDescaleO = 22,
5877  miopenTensorMhaDescaleDO = 23,
5878  miopenTensorMhaDescaleDS = 24,
5879  miopenTensorMhaScaleDS = 25,
5880  miopenTensorMhaScaleDQ = 26,
5881  miopenTensorMhaScaleDK = 27,
5882  miopenTensorMhaScaleDV = 28,
5883  miopenTensorMhaDQ = 29,
5884  miopenTensorMhaDK = 30,
5885  miopenTensorMhaDV = 31,
5886  miopenTensorMhaAmaxDQ = 32,
5887  miopenTensorMhaAmaxDK = 33,
5888  miopenTensorMhaAmaxDV = 34,
5889  miopenTensorMhaAmaxDS = 35,
5890  miopenTensorMhaBias = 36,
5891 
5892 #ifdef MIOPEN_BETA_API
5893  miopenTensorActivationX = 37,
5894  miopenTensorActivationY = 38,
5895  miopenTensorActivationDX = 39,
5896  miopenTensorActivationDY = 40,
5897  miopenTensorBiasX = 41,
5898  miopenTensorBiasY = 42,
5899  miopenTensorBias = 43,
5900  miopenTensorSoftmaxX = 44,
5901  miopenTensorSoftmaxY = 45,
5902  miopenTensorSoftmaxDX = 46,
5903  miopenTensorSoftmaxDY = 47,
5904  miopenTensorBatchnormX = 48,
5905  miopenTensorBatchnormY = 49,
5906  miopenTensorBatchnormRunningMean = 50,
5907  miopenTensorBatchnormRunningVariance = 51,
5908  miopenTensorBatchnormSavedMean = 52,
5909  miopenTensorBatchnormSavedVariance = 53,
5910  miopenTensorBatchnormScale = 54,
5911  miopenTensorBatchnormScaleDiff = 55,
5912  miopenTensorBatchnormEstimatedMean = 56,
5913  miopenTensorBatchnormEstimatedVariance = 57,
5914  miopenTensorBatchnormBias = 58,
5915  miopenTensorBatchnormBiasDiff = 59,
5916  miopenTensorBatchnormDX = 60,
5917  miopenTensorBatchnormDY = 61,
5918 #endif
5919 
5920  miopenTensorArgumentIsScalar = 1U << 31,
5921 
5922  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,
5923 #ifdef MIOPEN_BETA_API
5924  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,
5925  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,
5926 #endif
5927 } miopenTensorArgumentId_t;
5928 
5932 typedef enum
5933 {
5934  miopenFindResultsOrderByTime = 0,
5935  miopenFindResultsOrderByWorkspaceSize = 1,
5936 } miopenFindResultsOrder_t;
5937 
5945 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,
5946  miopenConvolutionDescriptor_t operatorDesc,
5947  miopenProblemDirection_t direction);
5948 
5960 typedef enum
5961 {
5962  miopenMhaMaskNone = 0,
5963  miopenMhaMaskCausal = 1,
5964 } miopenMhaMask_t;
5965 
5966 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,
5967  miopenMhaDescriptor_t operatorDesc,
5968  miopenProblemDirection_t direction);
5969 
5976 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);
5977 
5987 MIOPEN_EXPORT miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale);
5988 
5998 MIOPEN_EXPORT miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float* scale);
5999 
6006 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);
6007 
6019 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,
6020  float alpha,
6021  float beta,
6022  miopenSoftmaxAlgorithm_t algorithm,
6023  miopenSoftmaxMode_t mode);
6024 
6036 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,
6037  float* alpha,
6038  float* beta,
6039  miopenSoftmaxAlgorithm_t* algorithm,
6040  miopenSoftmaxMode_t* mode);
6041 
6047 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);
6048 
6056 MIOPEN_EXPORT miopenStatus_t
6057 miopenSetProblemTensorDescriptor(miopenProblem_t problem,
6058  miopenTensorArgumentId_t id,
6059  const miopenTensorDescriptor_t descriptor);
6060 
6063 MIOPEN_DECLARE_OBJECT(miopenFindOptions);
6064 
6070 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);
6071 
6077 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);
6078 
6085 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value);
6086 
6093 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,
6094  miopenFindResultsOrder_t value);
6095 
6103 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,
6104  size_t value);
6105 
6113 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,
6114  void* buffer,
6115  size_t size);
6116 
6125 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,
6126  miopenTensorArgumentId_t id,
6127  void* buffer);
6128 
6136 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,
6137  unsigned attach);
6138 
6141 MIOPEN_DECLARE_OBJECT(miopenSolution);
6142 
6154 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,
6155  miopenProblem_t problem,
6156  miopenFindOptions_t options,
6157  miopenSolution_t* solutions,
6158  size_t* numSolutions,
6159  size_t maxSolutions);
6160 
6163 struct miopenTensorArgument_t
6164 {
6165  /* @brief Identifier of the tensor argument.
6166  */
6167  miopenTensorArgumentId_t id;
6168  /* @brief Tensor descriptor to override the value stored in the solution.
6169  *
6170  * Some solvers may support overriding input and output tensor descriptors, but right now there
6171  * is no way to tell from the API. Intended for the future use.
6172  */
6173  miopenTensorDescriptor_t* descriptor;
6174  /* @brief Pointer to the device memory buffer to use for the operation or to the host memory if
6175  * the value is scalar.
6176  */
6177  void* buffer;
6178 };
6179 
6191 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,
6192  miopenSolution_t solution,
6193  size_t nInputs,
6194  const miopenTensorArgument_t* tensors,
6195  void* workspace,
6196  size_t workspaceSize);
6197 
6203 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);
6204 
6212 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,
6213  const char* data,
6214  size_t size);
6215 
6222 MIOPEN_EXPORT miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data);
6223 
6230 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size);
6231 
6238 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,
6239  size_t* workspaceSize);
6240 
6247 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time);
6248 
6255 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,
6256  uint64_t* solverId);
6257 
6264 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,
6265  miopenConvAlgorithm_t* result);
6266 
6267 #ifdef MIOPEN_BETA_API
6268 
6277 MIOPEN_EXPORT miopenStatus_t
6278 miopenCreateActivationProblem(miopenProblem_t* problem,
6279  miopenActivationDescriptor_t operatorDesc,
6280  miopenProblemDirection_t direction);
6281 
6290 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,
6291  miopenBatchNormMode_t mode,
6292  bool runningMeanVariance,
6293  miopenProblemDirection_t direction);
6294 
6314 MIOPEN_EXPORT miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2);
6315 
6323 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,
6324  miopenProblemDirection_t direction);
6325 
6334 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,
6335  miopenSoftmaxDescriptor_t operatorDesc,
6336  miopenProblemDirection_t direction);
6337 
6338 #endif
6339 
6341 // CLOSEOUT find2 DOXYGEN GROUP
6342 
6343 #ifdef MIOPEN_BETA_API
6344 
6349 typedef enum
6350 {
6351  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,
6352  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =
6353  1,
6354 } miopenReduceCalculationNanPropagation_t;
6355 
6356 // ReduceCalculation APIs
6365 typedef enum
6366 {
6367  MIOPEN_REDUCE_CALCULATION_PROD =
6368  1,
6369  MIOPEN_REDUCE_CALCULATION_SUM =
6370  2,
6371 } miopenReduceCalculationOp_t;
6372 
6382 MIOPEN_EXPORT miopenStatus_t
6383 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,
6384  const miopenTensorDescriptor_t xDesc,
6385  const int32_t dim,
6386  const miopenReduceCalculationOp_t reduceCalculationOp,
6387  const miopenTensorDescriptor_t reduceDesc,
6388  size_t* sizeInBytes);
6389 
6403 MIOPEN_EXPORT miopenStatus_t
6404 miopenReduceCalculationForward(miopenHandle_t handle,
6405  miopenReduceCalculationNanPropagation_t nanPropagation,
6406  void* workspace,
6407  size_t workspaceSizeInBytes,
6408  const miopenTensorDescriptor_t xDesc,
6409  const void* x,
6410  const int32_t dim,
6411  const miopenReduceCalculationOp_t reduceCalculationOp,
6412  const miopenTensorDescriptor_t reduceDesc,
6413  void* y);
6414 
6416 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP
6417 #endif // MIOPEN_BETA_API
6418 
6419 #ifdef MIOPEN_BETA_API
6420 
6425 typedef enum
6426 {
6427  MIOPEN_REDUCE_EXTREME_ARGMIN =
6428  1,
6429  MIOPEN_REDUCE_EXTREME_ARGMAX =
6430  2,
6431  MIOPEN_REDUCE_EXTREME_MIN =
6432  3,
6433  MIOPEN_REDUCE_EXTREME_MAX =
6434  4,
6435 } miopenReduceExtremeOp_t;
6436 
6437 // ReduceExtreme APIs
6457 MIOPEN_EXPORT miopenStatus_t
6458 miopenReduceExtremeForward(miopenHandle_t handle,
6459  const miopenTensorDescriptor_t xDesc,
6460  const void* x,
6461  const int32_t dim,
6462  const miopenReduceExtremeOp_t reduceExtremeOp,
6463  const miopenTensorDescriptor_t yDesc,
6464  void* y,
6465  const miopenTensorDescriptor_t indiceDesc,
6466  void* indice);
6467 
6469 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP
6470 #endif // MIOPEN_BETA_API
6471 
6472 #ifdef MIOPEN_BETA_API
6473 // GroupNorm APIs
6498 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,
6499  miopenNormMode_t mode,
6500  const miopenTensorDescriptor_t xDesc,
6501  const void* x,
6502  const miopenTensorDescriptor_t weightDesc,
6503  const void* weight,
6504  const miopenTensorDescriptor_t biasDesc,
6505  const void* bias,
6506  const uint64_t num_groups,
6507  const float epsilon,
6508  const miopenTensorDescriptor_t yDesc,
6509  void* y,
6510  const miopenTensorDescriptor_t meanDesc,
6511  void* mean,
6512  const miopenTensorDescriptor_t rstdDesc,
6513  void* rstd);
6514 
6516 // CLOSEOUT groupnorm DOXYGEN GROUP
6517 #endif // MIOPEN_BETA_API
6518 
6519 #ifdef MIOPEN_BETA_API
6520 // LayerNorm APIs
6547 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,
6548  miopenNormMode_t mode,
6549  const miopenTensorDescriptor_t xDesc,
6550  const void* x,
6551  const miopenTensorDescriptor_t x2Desc,
6552  const void* x2,
6553  const miopenTensorDescriptor_t weightDesc,
6554  const void* weight,
6555  const miopenTensorDescriptor_t biasDesc,
6556  const void* bias,
6557  const float epsilon,
6558  const int32_t normalized_dim,
6559  const miopenTensorDescriptor_t yDesc,
6560  void* y,
6561  const miopenTensorDescriptor_t meanDesc,
6562  void* mean,
6563  const miopenTensorDescriptor_t rstdDesc,
6564  void* rstd);
6565 
6567 // CLOSEOUT LAYERNORM DOXYGEN GROUP
6568 #endif // MIOPEN_BETA_API
6569 
6570 #ifdef MIOPEN_BETA_API
6571 // LayerNorm APIs
6591 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,
6592  miopenNormMode_t mode,
6593  const miopenTensorDescriptor_t xDesc,
6594  const void* x,
6595  const miopenTensorDescriptor_t weightDesc,
6596  const void* weight,
6597  const float epsilon,
6598  const miopenTensorDescriptor_t yDesc,
6599  void* y,
6600  const miopenTensorDescriptor_t rstdDesc,
6601  void* rstd);
6602 
6617 MIOPEN_EXPORT miopenStatus_t
6618 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,
6619  miopenNormMode_t mode,
6620  const miopenTensorDescriptor_t dyDesc,
6621  const miopenTensorDescriptor_t xDesc,
6622  const miopenTensorDescriptor_t weightDesc,
6623  const miopenTensorDescriptor_t rstdDesc,
6624  const miopenTensorDescriptor_t dxDesc,
6625  const miopenTensorDescriptor_t dwDesc,
6626  size_t* sizeInBytes);
6627 
6648 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,
6649  miopenNormMode_t mode,
6650  void* workspace,
6651  size_t workspaceSizeInBytes,
6652  const miopenTensorDescriptor_t dyDesc,
6653  const void* dy,
6654  const miopenTensorDescriptor_t xDesc,
6655  const void* x,
6656  const miopenTensorDescriptor_t weightDesc,
6657  const void* weight,
6658  const miopenTensorDescriptor_t rstdDesc,
6659  const void* rstd,
6660  const miopenTensorDescriptor_t dxDesc,
6661  void* dx,
6662  const miopenTensorDescriptor_t dwDesc,
6663  void* dw);
6665 // CLOSEOUT LAYERNORM DOXYGEN GROUP
6666 #endif // MIOPEN_BETA_API
6667 
6668 #ifdef MIOPEN_BETA_API
6669 // Graph API
6681 typedef enum
6682 {
6683  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,
6684  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,
6685  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,
6686  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,
6687  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,
6688  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,
6689  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,
6690  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,
6691  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,
6692  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,
6693  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,
6694  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,
6695  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,
6696  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
6697  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,
6698  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,
6699  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,
6700  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,
6701  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,
6702  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,
6703  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,
6704  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,
6705  MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,
6706  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,
6707  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,
6708  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,
6709  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,
6710  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,
6711  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,
6712  MIOPEN_BACKEND_RNG_DESCRIPTOR,
6713  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,
6714  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,
6715 } miopenBackendDescriptorType_t;
6716 
6724 typedef enum
6725 {
6726  MIOPEN_ATTR_POINTWISE_MODE = 0,
6727  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,
6728  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,
6729  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,
6730  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,
6731  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,
6732  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,
6733  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,
6734  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,
6735  MIOPEN_ATTR_POINTWISE_AXIS = 9,
6736 
6737  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,
6738  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,
6739  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,
6740  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,
6741  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,
6742  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,
6743  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,
6744 
6745  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,
6746  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,
6747  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,
6748  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,
6749 
6750  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,
6751  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,
6752  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,
6753 
6754  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,
6755  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,
6756  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,
6757  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,
6758  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,
6759  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,
6760 
6761  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,
6762  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,
6763  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,
6764  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,
6765 
6766  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,
6767  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,
6768 
6769  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,
6770  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,
6771  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,
6772  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,
6773  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,
6774  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,
6775  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,
6776  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,
6777  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,
6778  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,
6779  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,
6780  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,
6781  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,
6782  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,
6783  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,
6784  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,
6785  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,
6786  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,
6787  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,
6788  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,
6789  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,
6790  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,
6791  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,
6792  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,
6793  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,
6794  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,
6795  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,
6796 
6797  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,
6798  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,
6799  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,
6800  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,
6801  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,
6802 
6803  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,
6804  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,
6805  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,
6806  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,
6807  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,
6808  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,
6809  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,
6810  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,
6811  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,
6812  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,
6813  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,
6814  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,
6815  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,
6816  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,
6817  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,
6818  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,
6819  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,
6820 
6821  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,
6822  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,
6823  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,
6824 
6825  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,
6826  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,
6827  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,
6828  MIOPEN_ATTR_TENSOR_STRIDES = 903,
6829  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,
6830  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,
6831  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,
6832  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,
6833  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,
6834  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,
6835  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,
6836 
6837  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,
6838  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,
6839  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,
6840  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,
6841 
6842  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,
6843  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,
6844 
6845  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,
6846  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,
6847  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,
6848  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,
6849 
6850  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,
6851  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,
6852  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,
6853  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,
6854  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,
6855  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,
6856  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,
6857 
6858  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,
6859  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,
6860 
6861  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,
6862  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,
6863  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,
6864  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,
6865  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,
6866  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,
6867  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,
6868  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,
6869 
6870  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,
6871  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,
6872 
6873  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,
6874  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,
6875  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,
6876 
6877  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,
6878  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,
6879  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,
6880  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,
6881  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,
6882  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,
6883  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,
6884  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,
6885  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,
6886  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,
6887  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,
6888 
6889  MIOPEN_ATTR_RESAMPLE_MODE = 1700,
6890  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,
6891  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,
6892  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,
6893  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,
6894  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,
6895  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,
6896  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,
6897  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,
6898 
6899  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,
6900  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,
6901  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,
6902  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,
6903  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,
6904  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,
6905 
6906  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,
6907  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,
6908  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,
6909  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,
6910  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,
6911  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,
6912  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,
6913  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,
6914 
6915  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,
6916  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,
6917  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,
6918  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,
6919 
6920  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,
6921  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,
6922  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,
6923  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,
6924  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,
6925 
6926  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,
6927  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,
6928  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,
6929  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,
6930  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,
6931  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,
6932  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,
6933  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,
6934  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,
6935  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,
6936  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,
6937  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,
6938  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,
6939  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,
6940  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,
6941 
6942  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,
6943  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,
6944  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,
6945  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,
6946  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,
6947  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,
6948  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,
6949  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,
6950  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,
6951  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,
6952  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,
6953 
6954  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,
6955  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,
6956 
6957  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,
6958  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,
6959  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,
6960  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,
6961  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,
6962  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,
6963 
6964  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,
6965  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,
6966  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,
6967  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,
6968 
6969 } miopenBackendAttributeName_t;
6970 
6978 typedef enum
6979 {
6980  MIOPEN_TYPE_HANDLE = 0,
6981  MIOPEN_TYPE_DATA_TYPE,
6982  MIOPEN_TYPE_BOOLEAN,
6983  MIOPEN_TYPE_INT64,
6984  MIOPEN_TYPE_FLOAT,
6985  MIOPEN_TYPE_DOUBLE,
6986  MIOPEN_TYPE_VOID_PTR,
6987  MIOPEN_TYPE_CONVOLUTION_MODE,
6988  MIOPEN_TYPE_HEUR_MODE,
6989  MIOPEN_TYPE_KNOB_TYPE,
6990  MIOPEN_TYPE_NAN_PROPOGATION,
6991  MIOPEN_TYPE_NUMERICAL_NOTE,
6992  MIOPEN_TYPE_LAYOUT_TYPE,
6993  MIOPEN_TYPE_ATTRIB_NAME,
6994  MIOPEN_TYPE_POINTWISE_MODE,
6995  MIOPEN_TYPE_BACKEND_DESCRIPTOR,
6996  MIOPEN_TYPE_GENSTATS_MODE,
6997  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,
6998  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,
6999  MIOPEN_TYPE_BEHAVIOR_NOTE,
7000  MIOPEN_TYPE_TENSOR_REORDERING_MODE,
7001  MIOPEN_TYPE_RESAMPLE_MODE,
7002  MIOPEN_TYPE_PADDING_MODE,
7003  MIOPEN_TYPE_INT32,
7004  MIOPEN_TYPE_CHAR,
7005  MIOPEN_TYPE_SIGNAL_MODE,
7006  MIOPEN_TYPE_FRACTION,
7007  MIOPEN_TYPE_NORM_MODE,
7008  MIOPEN_TYPE_NORM_FWD_PHASE,
7009  MIOPEN_TYPE_RNG_DISTRIBUTION
7010 } miopenBackendAttributeType_t;
7011 
7017 typedef enum
7018 {
7020  MIOPEN_POINTWISE_ADD,
7021 
7024  MIOPEN_POINTWISE_ADD_SQUARE,
7025 
7027  MIOPEN_POINTWISE_DIV,
7028 
7030  MIOPEN_POINTWISE_MAX,
7031 
7033  MIOPEN_POINTWISE_MIN,
7034 
7037  MIOPEN_POINTWISE_MOD,
7038 
7040  MIOPEN_POINTWISE_MUL,
7041 
7043  MIOPEN_POINTWISE_POW,
7044 
7046  MIOPEN_POINTWISE_SUB,
7047 
7049  MIOPEN_POINTWISE_ABS,
7050 
7052  MIOPEN_POINTWISE_CEIL,
7053 
7055  MIOPEN_POINTWISE_COS,
7056 
7058  MIOPEN_POINTWISE_EXP,
7059 
7061  MIOPEN_POINTWISE_FLOOR,
7062 
7064  MIOPEN_POINTWISE_LOG,
7065 
7067  MIOPEN_POINTWISE_NEG,
7068 
7070  MIOPEN_POINTWISE_RSQRT,
7071 
7073  MIOPEN_POINTWISE_SIN,
7074 
7076  MIOPEN_POINTWISE_SQRT,
7077 
7079  MIOPEN_POINTWISE_TAN,
7080 
7082  MIOPEN_POINTWISE_ERF,
7083 
7087  MIOPEN_POINTWISE_IDENTITY,
7088 
7090  MIOPEN_POINTWISE_RELU_FWD,
7091 
7093  MIOPEN_POINTWISE_TANH_FWD,
7094 
7096  MIOPEN_POINTWISE_SIGMOID_FWD,
7097 
7099  MIOPEN_POINTWISE_ELU_FWD,
7100 
7103  MIOPEN_POINTWISE_GELU_FWD,
7104 
7106  MIOPEN_POINTWISE_SOFTPLUS_FWD,
7107 
7109  MIOPEN_POINTWISE_SWISH_FWD,
7110 
7114  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,
7115 
7118  MIOPEN_POINTWISE_RELU_BWD,
7119 
7121  MIOPEN_POINTWISE_TANH_BWD,
7122 
7124  MIOPEN_POINTWISE_SIGMOID_BWD,
7125 
7128  MIOPEN_POINTWISE_ELU_BWD,
7129 
7132  MIOPEN_POINTWISE_GELU_BWD,
7133 
7135  MIOPEN_POINTWISE_SOFTPLUS_BWD,
7136 
7138  MIOPEN_POINTWISE_SWISH_BWD,
7139 
7145  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,
7146 
7148  MIOPEN_POINTWISE_CMP_EQ,
7149 
7151  MIOPEN_POINTWISE_CMP_NEQ,
7152 
7154  MIOPEN_POINTWISE_CMP_GT,
7155 
7158  MIOPEN_POINTWISE_CMP_GE,
7159 
7161  MIOPEN_POINTWISE_CMP_LT,
7162 
7165  MIOPEN_POINTWISE_CMP_LE,
7166 
7168  MIOPEN_POINTWISE_LOGICAL_AND,
7169 
7171  MIOPEN_POINTWISE_LOGICAL_OR,
7172 
7174  MIOPEN_POINTWISE_LOGICAL_NOT,
7175 
7177  MIOPEN_POINTWISE_GEN_INDEX,
7178 
7181  MIOPEN_POINTWISE_BINARY_SELECT,
7182 
7185  MIOPEN_POINTWISE_RECIPROCAL
7186 } miopenPointwiseMode_t;
7187 
7193 typedef enum
7194 {
7195  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,
7196  MIOPEN_RNG_DISTRIBUTION_UNIFORM,
7197  MIOPEN_RNG_DISTRIBUTION_NORMAL,
7198 } miopenRngDistribution_t;
7199 
7200 typedef enum
7201 {
7202  /* IDENTITY alpha = 1.0 and beta = 0.0 */
7203  /* SCALE alpha = 4.2 and beta = 0.0 */
7204  /* BILINEAR alpha = 3.2 and beta = 1.1 */
7205  /* ERROR_STATE alpha = 0.0 and beta = 3.1 */
7206 
7207  DEFAULT = 0, /* alpha = 1.0 and beta = 0.0.*/
7208  SCALE = 1, /* alpha with some value and beta 0.0*/
7209  BILINEAR = 2, /* both alpha and beta with some value*/
7210  ERROR_STATE = 3, /* alpha 0.0 and beta with some value, this should not occur.
7211  But used to check for errors.*/
7212 } miopenAlphaBetaCase_t;
7217 typedef enum
7218 {
7219  MIOPEN_HEUR_MODE_INSTANT = 0,
7220  MIOPEN_HEUR_MODE_B = 1,
7221  MIOPEN_HEUR_MODE_FALLBACK = 2,
7222  MIOPEN_HEUR_MODE_A = 3,
7223  MIOPEN_HEUR_MODES_COUNT = 4,
7224 } miopenBackendHeurMode_t;
7225 
7238 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)
7239 
7240 
7253 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(
7254  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);
7255 
7285 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,
7286  miopenBackendAttributeName_t attributeName,
7287  miopenBackendAttributeType_t attributeType,
7288  int64_t elementCount,
7289  void* arrayOfElements);
7290 
7307 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);
7308 
7343 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,
7344  miopenBackendAttributeName_t attributeName,
7345  miopenBackendAttributeType_t attributeType,
7346  int64_t requestedElementCount,
7347  int64_t* elementCount,
7348  void* arrayOfElements);
7349 
7369 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,
7370  miopenBackendDescriptor_t executionPlan,
7371  miopenBackendDescriptor_t variantPack);
7372 
7389 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);
7390 
7408 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,
7409  miopenBackendDescriptorType_t descriptorType,
7410  size_t sizeInBytes);
7411 
7413 // CLOSEOUT BackendAPI DOXYGEN GROUP
7414 #endif // MIOPEN_BETA_API
7415 
7416 #ifdef MIOPEN_BETA_API
7417 // FusedAdam APIs
7560 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,
7561  const miopenTensorDescriptor_t paramDesc,
7562  void* param,
7563  const miopenTensorDescriptor_t gradDesc,
7564  const void* grad,
7565  const miopenTensorDescriptor_t expAvgDesc,
7566  void* expAvg,
7567  const miopenTensorDescriptor_t expAvgSqDesc,
7568  void* expAvgSq,
7569  const miopenTensorDescriptor_t maxExpAvgSqDesc,
7570  void* maxExpAvgSq,
7571  const miopenTensorDescriptor_t stateStepDesc,
7572  void* stateStep,
7573  const unsigned int state_step,
7574  const float lr,
7575  const float beta1,
7576  const float beta2,
7577  const float weight_decay,
7578  const float eps,
7579  const bool amsgrad,
7580  const bool maximize,
7581  const bool adamw,
7582  const miopenTensorDescriptor_t gradScaleDesc,
7583  const void* gradScale,
7584  const miopenTensorDescriptor_t foundInfDesc,
7585  const void* foundInf);
7586 
7727 MIOPEN_EXPORT miopenStatus_t
7728 miopenFusedAdamWithOutput(miopenHandle_t handle,
7729  const miopenTensorDescriptor_t paramInDesc,
7730  void* paramIn,
7731  const miopenTensorDescriptor_t paramOutDesc,
7732  void* paramOut,
7733  const miopenTensorDescriptor_t paramOutFloat16Desc,
7734  void* paramOutFloat16,
7735  const miopenTensorDescriptor_t gradInDesc,
7736  const void* gradIn,
7737  const miopenTensorDescriptor_t expAvgInDesc,
7738  void* expAvgIn,
7739  const miopenTensorDescriptor_t expAvgOutDesc,
7740  void* expAvgOut,
7741  const miopenTensorDescriptor_t expAvgSqInDesc,
7742  void* expAvgSqIn,
7743  const miopenTensorDescriptor_t expAvgSqOutDesc,
7744  void* expAvgSqOut,
7745  const miopenTensorDescriptor_t maxExpAvgSqInDesc,
7746  void* maxExpAvgSqIn,
7747  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,
7748  void* maxExpAvgSqOut,
7749  const miopenTensorDescriptor_t stateStepInDesc,
7750  void* stateStepIn,
7751  const miopenTensorDescriptor_t stateStepOutDesc,
7752  void* stateStepOut,
7753  const unsigned int state_step,
7754  const float lr,
7755  const float beta1,
7756  const float beta2,
7757  const float weight_decay,
7758  const float eps,
7759  const bool amsgrad,
7760  const bool maximize,
7761  const bool adamw,
7762  const miopenTensorDescriptor_t gradScaleDesc,
7763  const void* gradScale,
7764  const miopenTensorDescriptor_t foundInfDesc,
7765  const void* foundInf);
7766 
7768 // CLOSEOUT SGD DOXYGEN GROUP
7769 #endif // MIOPEN_BETA_API
7770 
7771 #ifdef MIOPEN_BETA_API
7772 // TransformersAdamW APIs
7863 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,
7864  const miopenTensorDescriptor_t paramDesc,
7865  void* param,
7866  const miopenTensorDescriptor_t gradDesc,
7867  const void* grad,
7868  const miopenTensorDescriptor_t expAvgDesc,
7869  void* expAvg,
7870  const miopenTensorDescriptor_t expAvgSqDesc,
7871  void* expAvgSq,
7872  const miopenTensorDescriptor_t stateStepDesc,
7873  void* stateStep,
7874  const unsigned int state_step,
7875  const float lr,
7876  const float beta1,
7877  const float beta2,
7878  const float weight_decay,
7879  const float eps,
7880  const bool correct_bias,
7881  const miopenTensorDescriptor_t gradScaleDesc,
7882  const void* gradScale,
7883  const miopenTensorDescriptor_t foundInfDesc,
7884  const void* foundInf);
7885 
8012 MIOPEN_EXPORT miopenStatus_t
8013 miopenTransformersAdamWWithOutput(miopenHandle_t handle,
8014  const miopenTensorDescriptor_t paramInDesc,
8015  void* paramIn,
8016  const miopenTensorDescriptor_t paramOutDesc,
8017  void* paramOut,
8018  const miopenTensorDescriptor_t paramOutFloat16Desc,
8019  void* paramOutFloat16,
8020  const miopenTensorDescriptor_t gradInDesc,
8021  const void* gradIn,
8022  const miopenTensorDescriptor_t expAvgInDesc,
8023  void* expAvgIn,
8024  const miopenTensorDescriptor_t expAvgOutDesc,
8025  void* expAvgOut,
8026  const miopenTensorDescriptor_t expAvgSqInDesc,
8027  void* expAvgSqIn,
8028  const miopenTensorDescriptor_t expAvgSqOutDesc,
8029  void* expAvgSqOut,
8030  const miopenTensorDescriptor_t stateStepInDesc,
8031  void* stateStepIn,
8032  const miopenTensorDescriptor_t stateStepOutDesc,
8033  void* stateStepOut,
8034  const unsigned int state_step,
8035  const float lr,
8036  const float beta1,
8037  const float beta2,
8038  const float weight_decay,
8039  const float eps,
8040  const float step_size,
8041  const bool correct_bias,
8042  const miopenTensorDescriptor_t gradScaleDesc,
8043  const void* gradScale,
8044  const miopenTensorDescriptor_t foundInfDesc,
8045  const void* foundInf);
8046 
8048 // CLOSEOUT SGD DOXYGEN GROUP
8049 #endif // MIOPEN_BETA_API
8050 
8051 #ifdef MIOPEN_BETA_API
8052 // GetItem APIs
8065 MIOPEN_EXPORT miopenStatus_t
8066 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,
8067  uint32_t indexCount,
8068  const miopenTensorDescriptor_t* indexDescs,
8069  size_t* sizeInBytes);
8070 
8095 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,
8096  void* workspace,
8097  size_t workspaceSizeInBytes,
8098  const miopenTensorDescriptor_t dyDesc,
8099  const void* dy,
8100  uint32_t indexCount,
8101  const miopenTensorDescriptor_t* indexDescs,
8102  const void* const* indexs,
8103  const miopenTensorDescriptor_t dxDesc,
8104  void* dx,
8105  const miopenTensorDescriptor_t errorDesc,
8106  void* error,
8107  uint32_t dimCount,
8108  const int32_t* dims,
8109  uint32_t sliceCount,
8110  const int32_t* slices,
8111  uint32_t offset);
8112 
8114 // CLOSEOUT GETITEM DOXYGEN GROUP
8115 #endif // MIOPEN_BETA_API
8116 
8117 #ifdef MIOPEN_BETA_API
8118 // RotaryPositionalEmbeddings APIs
8136 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,
8137  const miopenTensorDescriptor_t xDesc,
8138  const void* x,
8139  const miopenTensorDescriptor_t cosDesc,
8140  const void* cos,
8141  const miopenTensorDescriptor_t sinDesc,
8142  const void* sin,
8143  const miopenTensorDescriptor_t yDesc,
8144  void* y);
8145 
8159 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,
8160  const miopenTensorDescriptor_t dyDesc,
8161  const void* dy,
8162  const miopenTensorDescriptor_t cosDesc,
8163  const void* cos,
8164  const miopenTensorDescriptor_t sinDesc,
8165  const void* sin,
8166  const miopenTensorDescriptor_t dxDesc,
8167  void* dx);
8169 // CLOSEOUT ROPE DOXYGEN GROUP
8170 // kthvalue APIs
8191 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,
8192  miopenTensorDescriptor_t inputDesc,
8193  const void* input,
8194  miopenTensorDescriptor_t outputDesc,
8195  void* output,
8196  miopenTensorDescriptor_t indicesDesc,
8197  size_t* indices,
8198  size_t k,
8199  int32_t dim = -1,
8200  bool keepDim = false);
8201 
8203 // CLOSEOUT kthvalue DOXYGEN GROUP
8204 #endif // MIOPEN_BETA_API
8205 
8206 #ifdef MIOPEN_BETA_API
8220 MIOPEN_EXPORT miopenStatus_t
8221 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,
8222  miopenTensorDescriptor_t inputDesc,
8223  miopenTensorDescriptor_t weightDesc,
8224  size_t* sizeInBytes);
8225 
8242 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,
8243  void* workspace,
8244  size_t workspaceSizeInBytes,
8245  miopenTensorDescriptor_t inputDesc,
8246  const void* input,
8247  miopenTensorDescriptor_t weightDesc,
8248  const void* weight,
8249  miopenTensorDescriptor_t doutputDesc,
8250  const void* doutput,
8251  miopenTensorDescriptor_t dinputDesc,
8252  void* dinput,
8253  miopenTensorDescriptor_t dweightDesc,
8254  void* dweight);
8255 
8257 // CLOSEOUT RELU DOXYGEN GROUP
8258 #endif // MIOPEN_BETA_API
8259 
8260 #ifdef MIOPEN_BETA_API
8261 
8266 typedef enum
8267 {
8268  MIOPEN_LOSS_REDUCTION_NONE = 0,
8269  MIOPEN_LOSS_REDUCTION_SUM = 1,
8270  MIOPEN_LOSS_REDUCTION_MEAN = 2,
8272 } miopenLossReductionMode_t;
8273 
8274 // SoftMarginLoss APIs
8292 MIOPEN_EXPORT miopenStatus_t
8293 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8294  miopenTensorDescriptor_t inputDesc,
8295  miopenTensorDescriptor_t targetDesc,
8296  miopenTensorDescriptor_t outputDesc,
8297  miopenLossReductionMode_t reduction,
8298  size_t* sizeInBytes);
8299 
8316 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,
8317  miopenTensorDescriptor_t inputDesc,
8318  const void* input,
8319  miopenTensorDescriptor_t targetDesc,
8320  const void* target,
8321  miopenTensorDescriptor_t outputDesc,
8322  void* output,
8323  miopenLossReductionMode_t reduction,
8324  void* workspace = nullptr,
8325  size_t workspaceSizeInBytes = 0);
8326 
8341 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,
8342  miopenTensorDescriptor_t inputDesc,
8343  const void* input,
8344  miopenTensorDescriptor_t targetDesc,
8345  const void* target,
8346  miopenTensorDescriptor_t doutputDesc,
8347  const void* doutput,
8348  miopenTensorDescriptor_t dinputDesc,
8349  void* dinput,
8350  miopenLossReductionMode_t reduction);
8351 
8353 // CLOSEOUT LossFunction DOXYGEN GROUP
8354 #endif
8355 
8356 #ifdef MIOPEN_BETA_API
8357 // MultiMarginLoss APIs
8381 MIOPEN_EXPORT miopenStatus_t
8382 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8383  miopenTensorDescriptor_t inputDesc,
8384  miopenTensorDescriptor_t targetDesc,
8385  miopenTensorDescriptor_t weightDesc,
8386  miopenTensorDescriptor_t outputDesc,
8387  long p,
8388  float margin,
8389  miopenLossReductionMode_t reduction,
8390  size_t* sizeInBytes);
8391 
8419 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,
8420  miopenTensorDescriptor_t inputDesc,
8421  const void* input,
8422  miopenTensorDescriptor_t targetDesc,
8423  const void* target,
8424  miopenTensorDescriptor_t weightDesc,
8425  const void* weight,
8426  miopenTensorDescriptor_t outputDesc,
8427  void* output,
8428  long p,
8429  float margin,
8430  miopenLossReductionMode_t reduction,
8431  void* workspace,
8432  size_t workspaceSizeInBytes);
8433 
8435 // CLOSEOUT LossFunction DOXYGEN GROUP
8436 #endif // MIOPEN_BETA_API
8437 
8438 #ifdef __cplusplus
8439 }
8440 #endif
8441 
8442 #ifdef __clang__
8443 #pragma clang diagnostic pop
8444 #endif
8445 
8446 #endif // MIOPEN_GUARD_MIOPEN_H_
miopenCreateOpActivationBackward
miopenStatus_t miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *activBwdOp, miopenActivationMode_t mode)
Creates a backward activation operator.
miopenCreateOpBatchNormForward
miopenStatus_t miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnFwdOp, const miopenBatchNormMode_t bn_mode, bool runningMeanVariance)
Creates a forward training batch normalization operator.
miopenFusionPlanConvolutionGetAlgo
miopenStatus_t miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, const int requestAlgoCount, int *returnedAlgoCount, miopenConvFwdAlgorithm_t *returnedAlgos)
Returns the supported algorithms for the convolution operator in the Fusion Plan.
miopenFusionPlanGetWorkSpaceSize
miopenStatus_t miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle, miopenFusionPlanDescriptor_t fusePlanDesc, size_t *workSpaceSize, miopenConvFwdAlgorithm_t algo)
Query the workspace size required for the fusion plan.
miopenFusionPlanConvolutionSetAlgo
miopenStatus_t miopenFusionPlanConvolutionSetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo)
Requests the fusion runtime to choose a particular algorithm for the added convolution operation.
miopenCreateOpBatchNormInference
miopenStatus_t miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnOp, const miopenBatchNormMode_t bn_mode, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc)
Creates a forward inference batch normalization operator.
miopenSetOpArgsBiasForward
miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t biasOp, const void *alpha, const void *beta, const void *bias)
Sets the arguments for forward bias op.
miopenCreateOpConvForward
miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *convOp, miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t wDesc)
Creates forward convolution operator.
miopenSetOpArgsBatchNormInference
miopenStatus_t miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *bnScale, const void *bnBias, const void *estimatedMean, const void *estimatedVariance, double epsilon)
Sets the arguments for inference batch normalization op.
miopenSetOpArgsBatchNormForward
miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *bnScale, const void *bnBias, void *savedMean, void *savedInvVariance, void *runningMean, void *runningVariance, double expAvgFactor, double epsilon)
Sets the arguments for forward batch normalization op.
miopenExecuteFusionPlan
miopenStatus_t miopenExecuteFusionPlan(const miopenHandle_t handle, const miopenFusionPlanDescriptor_t fusePlanDesc, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, miopenOperatorArgs_t args)
Executes the fusion plan. Only compatible with NHWC/NDHWC tensor layouts.
miopenFusionPlanGetOp
miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc, const int op_idx, miopenFusionOpDescriptor_t *op)
Allows access to the operators in a fusion plan.
miopenDestroyFusionPlan
miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc)
Destroy the fusion plan descriptor object.
miopenCreateOpActivationForward
miopenStatus_t miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *activFwdOp, miopenActivationMode_t mode)
Creates a forward activation operator.
miopenExecuteFusionPlan_v2
miopenStatus_t miopenExecuteFusionPlan_v2(const miopenHandle_t handle, const miopenFusionPlanDescriptor_t fusePlanDesc, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, miopenOperatorArgs_t args, void *workspace, size_t workspaceSize)
Executes the fusion plan with a workspace buffer for layout transformations.
miopenFusionDirection_t
miopenFusionDirection_t
Kernel fusion direction in the network.
Definition: miopen.h:3524
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:3526
miopenVerticalFusion
@ miopenVerticalFusion
Definition: miopen.h:3525
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:7218
miopenPointwiseMode_t
miopenPointwiseMode_t
Intended poinwise math operation for a pointwise operation descriptor.
Definition: miopen.h:7018
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:6725
miopenRngDistribution_t
miopenRngDistribution_t
Distribution for random number generation.
Definition: miopen.h:7194
miopenBackendDescriptorType_t
miopenBackendDescriptorType_t
Descriptor type.
Definition: miopen.h:6682
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:7201
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:6979
MIOPEN_HEUR_MODE_INSTANT
@ MIOPEN_HEUR_MODE_INSTANT
Definition: miopen.h:7219
MIOPEN_HEUR_MODE_A
@ MIOPEN_HEUR_MODE_A
Definition: miopen.h:7222
MIOPEN_HEUR_MODE_B
@ MIOPEN_HEUR_MODE_B
Definition: miopen.h:7220
MIOPEN_HEUR_MODES_COUNT
@ MIOPEN_HEUR_MODES_COUNT
Definition: miopen.h:7223
MIOPEN_HEUR_MODE_FALLBACK
@ MIOPEN_HEUR_MODE_FALLBACK
Definition: miopen.h:7221
MIOPEN_POINTWISE_SOFTPLUS_FWD
@ MIOPEN_POINTWISE_SOFTPLUS_FWD
Definition: miopen.h:7106
MIOPEN_POINTWISE_ELU_FWD
@ MIOPEN_POINTWISE_ELU_FWD
Definition: miopen.h:7099
MIOPEN_POINTWISE_RELU_FWD
@ MIOPEN_POINTWISE_RELU_FWD
Definition: miopen.h:7090
MIOPEN_POINTWISE_DIV
@ MIOPEN_POINTWISE_DIV
Definition: miopen.h:7027
MIOPEN_POINTWISE_SIGMOID_BWD
@ MIOPEN_POINTWISE_SIGMOID_BWD
Definition: miopen.h:7124
MIOPEN_POINTWISE_POW
@ MIOPEN_POINTWISE_POW
Definition: miopen.h:7043
MIOPEN_POINTWISE_MOD
@ MIOPEN_POINTWISE_MOD
Definition: miopen.h:7037
MIOPEN_POINTWISE_SQRT
@ MIOPEN_POINTWISE_SQRT
Definition: miopen.h:7076
MIOPEN_POINTWISE_BINARY_SELECT
@ MIOPEN_POINTWISE_BINARY_SELECT
Definition: miopen.h:7181
MIOPEN_POINTWISE_GELU_BWD
@ MIOPEN_POINTWISE_GELU_BWD
Definition: miopen.h:7132
MIOPEN_POINTWISE_MIN
@ MIOPEN_POINTWISE_MIN
Definition: miopen.h:7033
MIOPEN_POINTWISE_CMP_NEQ
@ MIOPEN_POINTWISE_CMP_NEQ
Definition: miopen.h:7151
MIOPEN_POINTWISE_FLOOR
@ MIOPEN_POINTWISE_FLOOR
Definition: miopen.h:7061
MIOPEN_POINTWISE_RSQRT
@ MIOPEN_POINTWISE_RSQRT
Definition: miopen.h:7070
MIOPEN_POINTWISE_CMP_EQ
@ MIOPEN_POINTWISE_CMP_EQ
Definition: miopen.h:7148
MIOPEN_POINTWISE_CMP_GE
@ MIOPEN_POINTWISE_CMP_GE
Definition: miopen.h:7158
MIOPEN_POINTWISE_ADD_SQUARE
@ MIOPEN_POINTWISE_ADD_SQUARE
Definition: miopen.h:7024
MIOPEN_POINTWISE_ERF
@ MIOPEN_POINTWISE_ERF
Definition: miopen.h:7082
MIOPEN_POINTWISE_SWISH_FWD
@ MIOPEN_POINTWISE_SWISH_FWD
Definition: miopen.h:7109
MIOPEN_POINTWISE_LOG
@ MIOPEN_POINTWISE_LOG
Definition: miopen.h:7064
MIOPEN_POINTWISE_SUB
@ MIOPEN_POINTWISE_SUB
Definition: miopen.h:7046
MIOPEN_POINTWISE_NEG
@ MIOPEN_POINTWISE_NEG
Definition: miopen.h:7067
MIOPEN_POINTWISE_LOGICAL_AND
@ MIOPEN_POINTWISE_LOGICAL_AND
Definition: miopen.h:7168
MIOPEN_POINTWISE_SWISH_BWD
@ MIOPEN_POINTWISE_SWISH_BWD
Definition: miopen.h:7138
MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
Definition: miopen.h:7114
MIOPEN_POINTWISE_SIN
@ MIOPEN_POINTWISE_SIN
Definition: miopen.h:7073
MIOPEN_POINTWISE_RECIPROCAL
@ MIOPEN_POINTWISE_RECIPROCAL
Definition: miopen.h:7185
MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
Definition: miopen.h:7145
MIOPEN_POINTWISE_GELU_FWD
@ MIOPEN_POINTWISE_GELU_FWD
Definition: miopen.h:7103
MIOPEN_POINTWISE_ABS
@ MIOPEN_POINTWISE_ABS
Definition: miopen.h:7049
MIOPEN_POINTWISE_CMP_LT
@ MIOPEN_POINTWISE_CMP_LT
Definition: miopen.h:7161
MIOPEN_POINTWISE_EXP
@ MIOPEN_POINTWISE_EXP
Definition: miopen.h:7058
MIOPEN_POINTWISE_GEN_INDEX
@ MIOPEN_POINTWISE_GEN_INDEX
Definition: miopen.h:7177
MIOPEN_POINTWISE_CEIL
@ MIOPEN_POINTWISE_CEIL
Definition: miopen.h:7052
MIOPEN_POINTWISE_LOGICAL_NOT
@ MIOPEN_POINTWISE_LOGICAL_NOT
Definition: miopen.h:7174
MIOPEN_POINTWISE_SIGMOID_FWD
@ MIOPEN_POINTWISE_SIGMOID_FWD
Definition: miopen.h:7096
MIOPEN_POINTWISE_SOFTPLUS_BWD
@ MIOPEN_POINTWISE_SOFTPLUS_BWD
Definition: miopen.h:7135
MIOPEN_POINTWISE_LOGICAL_OR
@ MIOPEN_POINTWISE_LOGICAL_OR
Definition: miopen.h:7171
MIOPEN_POINTWISE_TAN
@ MIOPEN_POINTWISE_TAN
Definition: miopen.h:7079
MIOPEN_POINTWISE_ELU_BWD
@ MIOPEN_POINTWISE_ELU_BWD
Definition: miopen.h:7128
MIOPEN_POINTWISE_IDENTITY
@ MIOPEN_POINTWISE_IDENTITY
Definition: miopen.h:7087
MIOPEN_POINTWISE_CMP_LE
@ MIOPEN_POINTWISE_CMP_LE
Definition: miopen.h:7165
MIOPEN_POINTWISE_COS
@ MIOPEN_POINTWISE_COS
Definition: miopen.h:7055
MIOPEN_POINTWISE_TANH_BWD
@ MIOPEN_POINTWISE_TANH_BWD
Definition: miopen.h:7121
MIOPEN_POINTWISE_MUL
@ MIOPEN_POINTWISE_MUL
Definition: miopen.h:7040
MIOPEN_POINTWISE_TANH_FWD
@ MIOPEN_POINTWISE_TANH_FWD
Definition: miopen.h:7093
MIOPEN_POINTWISE_RELU_BWD
@ MIOPEN_POINTWISE_RELU_BWD
Definition: miopen.h:7118
MIOPEN_POINTWISE_ADD
@ MIOPEN_POINTWISE_ADD
Definition: miopen.h:7020
MIOPEN_POINTWISE_MAX
@ MIOPEN_POINTWISE_MAX
Definition: miopen.h:7030
MIOPEN_POINTWISE_CMP_GT
@ MIOPEN_POINTWISE_CMP_GT
Definition: miopen.h:7154
MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
Definition: miopen.h:6942
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
Definition: miopen.h:6772
MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
Definition: miopen.h:6896
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
Definition: miopen.h:6899
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
Definition: miopen.h:6778
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
Definition: miopen.h:6769
MIOPEN_ATTR_OPERATION_SIGNAL_MODE
@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE
Definition: miopen.h:6920
MIOPEN_ATTR_OPERATION_RNG_DESC
@ MIOPEN_ATTR_OPERATION_RNG_DESC
Definition: miopen.h:6966
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
Definition: miopen.h:6770
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
Definition: miopen.h:6883
MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
Definition: miopen.h:6945
MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
Definition: miopen.h:6933
MIOPEN_ATTR_OPERATIONGRAPH_OPS
@ MIOPEN_ATTR_OPERATIONGRAPH_OPS
Definition: miopen.h:6822
MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
Definition: miopen.h:6846
MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
Definition: miopen.h:6741
MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
Definition: miopen.h:6924
MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
Definition: miopen.h:6949
MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
Definition: miopen.h:6952
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
Definition: miopen.h:6913
MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
Definition: miopen.h:6742
MIOPEN_ATTR_REDUCTION_OPERATOR
@ MIOPEN_ATTR_REDUCTION_OPERATOR
Definition: miopen.h:6870
MIOPEN_ATTR_OPERATION_MATMUL_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_DESC
Definition: miopen.h:6864
MIOPEN_ATTR_CONVOLUTION_DILATIONS
@ MIOPEN_ATTR_CONVOLUTION_DILATIONS
Definition: miopen.h:6739
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
Definition: miopen.h:6907
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
Definition: miopen.h:6791
MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
Definition: miopen.h:6891
MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
Definition: miopen.h:6757
MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
Definition: miopen.h:6929
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
Definition: miopen.h:6811
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
Definition: miopen.h:6879
MIOPEN_ATTR_KNOB_INFO_TYPE
@ MIOPEN_ATTR_KNOB_INFO_TYPE
Definition: miopen.h:6845
MIOPEN_ATTR_LAYOUT_INFO_TYPES
@ MIOPEN_ATTR_LAYOUT_INFO_TYPES
Definition: miopen.h:6843
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
Definition: miopen.h:6805
MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
Definition: miopen.h:6821
MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
Definition: miopen.h:6946
MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
Definition: miopen.h:6961
MIOPEN_ATTR_POINTWISE_MATH_PREC
@ MIOPEN_ATTR_POINTWISE_MATH_PREC
Definition: miopen.h:6727
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
Definition: miopen.h:6867
MIOPEN_ATTR_OPERATION_GENSTATS_MODE
@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE
Definition: miopen.h:6797
MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
Definition: miopen.h:6767
MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
Definition: miopen.h:6839
MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
Definition: miopen.h:6874
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
Definition: miopen.h:6782
MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
Definition: miopen.h:6840
MIOPEN_ATTR_TENSOR_IS_BY_VALUE
@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE
Definition: miopen.h:6833
MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
Definition: miopen.h:6926
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
Definition: miopen.h:6771
MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
Definition: miopen.h:6803
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
Definition: miopen.h:6936
MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
Definition: miopen.h:6954
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
Definition: miopen.h:6912
MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
Definition: miopen.h:6788
MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
Definition: miopen.h:6837
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
Definition: miopen.h:6882
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
Definition: miopen.h:6902
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
Definition: miopen.h:6807
MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
Definition: miopen.h:6922
MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
Definition: miopen.h:6921
MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
Definition: miopen.h:6795
MIOPEN_ATTR_ENGINEHEUR_RESULTS
@ MIOPEN_ATTR_ENGINEHEUR_RESULTS
Definition: miopen.h:6747
MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
Definition: miopen.h:6825
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
Definition: miopen.h:6785
MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
Definition: miopen.h:6817
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
Definition: miopen.h:6887
MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
Definition: miopen.h:6798
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
Definition: miopen.h:6935
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
Definition: miopen.h:6815
MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
Definition: miopen.h:6754
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
Definition: miopen.h:6881
MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
Definition: miopen.h:6918
MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
Definition: miopen.h:6948
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
Definition: miopen.h:6776
MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
Definition: miopen.h:6756
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
Definition: miopen.h:6779
MIOPEN_ATTR_TENSOR_VECTOR_COUNT
@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT
Definition: miopen.h:6829
MIOPEN_ATTR_OPERATION_MATMUL_CDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC
Definition: miopen.h:6863
MIOPEN_ATTR_REDUCTION_COMP_TYPE
@ MIOPEN_ATTR_REDUCTION_COMP_TYPE
Definition: miopen.h:6871
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
Definition: miopen.h:6910
MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
Definition: miopen.h:6830
MIOPEN_ATTR_TENSOR_DIMENSIONS
@ MIOPEN_ATTR_TENSOR_DIMENSIONS
Definition: miopen.h:6827
MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
Definition: miopen.h:6800
MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
Definition: miopen.h:6917
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
Definition: miopen.h:6792
MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
Definition: miopen.h:6853
MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
Definition: miopen.h:6855
MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
Definition: miopen.h:6759
MIOPEN_ATTR_RESAMPLE_STRIDES
@ MIOPEN_ATTR_RESAMPLE_STRIDES
Definition: miopen.h:6894
MIOPEN_ATTR_POINTWISE_ELU_ALPHA
@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA
Definition: miopen.h:6732
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
Definition: miopen.h:6938
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
Definition: miopen.h:6908
MIOPEN_ATTR_OPERATION_RNG_SEED
@ MIOPEN_ATTR_OPERATION_RNG_SEED
Definition: miopen.h:6965
MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
Definition: miopen.h:6943
MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
Definition: miopen.h:6793
MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
Definition: miopen.h:6916
MIOPEN_ATTR_RESAMPLE_MODE
@ MIOPEN_ATTR_RESAMPLE_MODE
Definition: miopen.h:6889
MIOPEN_ATTR_RNG_DISTRIBUTION
@ MIOPEN_ATTR_RNG_DISTRIBUTION
Definition: miopen.h:6957
MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
Definition: miopen.h:6944
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
Definition: miopen.h:6866
MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
Definition: miopen.h:6927
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
Definition: miopen.h:6731
MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
Definition: miopen.h:6955
MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
Definition: miopen.h:6838
MIOPEN_ATTR_POINTWISE_AXIS
@ MIOPEN_ATTR_POINTWISE_AXIS
Definition: miopen.h:6735
MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
Definition: miopen.h:6939
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
Definition: miopen.h:6729
MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
Definition: miopen.h:6850
MIOPEN_ATTR_OPERATION_MATMUL_BDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC
Definition: miopen.h:6862
MIOPEN_ATTR_TENSOR_DATA_TYPE
@ MIOPEN_ATTR_TENSOR_DATA_TYPE
Definition: miopen.h:6826
MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
Definition: miopen.h:6923
MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
Definition: miopen.h:6847
MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
Definition: miopen.h:6932
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
Definition: miopen.h:6904
MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
Definition: miopen.h:6893
MIOPEN_ATTR_MATMUL_COMP_TYPE
@ MIOPEN_ATTR_MATMUL_COMP_TYPE
Definition: miopen.h:6858
MIOPEN_ATTR_TENSOR_UNIQUE_ID
@ MIOPEN_ATTR_TENSOR_UNIQUE_ID
Definition: miopen.h:6831
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
Definition: miopen.h:6885
MIOPEN_ATTR_OPERATION_CONCAT_AXIS
@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS
Definition: miopen.h:6915
MIOPEN_ATTR_OPERATION_RNG_YDESC
@ MIOPEN_ATTR_OPERATION_RNG_YDESC
Definition: miopen.h:6964
MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
Definition: miopen.h:6851
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
Definition: miopen.h:6777
MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
Definition: miopen.h:6746
MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
Definition: miopen.h:6835
MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
Definition: miopen.h:6733
MIOPEN_ATTR_TENSOR_IS_VIRTUAL
@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL
Definition: miopen.h:6832
MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
Definition: miopen.h:6752
MIOPEN_ATTR_MATMUL_PADDING_VALUE
@ MIOPEN_ATTR_MATMUL_PADDING_VALUE
Definition: miopen.h:6859
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
Definition: miopen.h:6819
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
Definition: miopen.h:6814
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
Definition: miopen.h:6773
MIOPEN_ATTR_KNOB_INFO_STRIDE
@ MIOPEN_ATTR_KNOB_INFO_STRIDE
Definition: miopen.h:6848
MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
Definition: miopen.h:6895
MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
Definition: miopen.h:6790
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
Definition: miopen.h:6900
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
Definition: miopen.h:6880
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
Definition: miopen.h:6780
MIOPEN_ATTR_CONVOLUTION_CONV_MODE
@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE
Definition: miopen.h:6738
MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
Definition: miopen.h:6873
MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
Definition: miopen.h:6758
MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
Definition: miopen.h:6804
MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
Definition: miopen.h:6856
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
Definition: miopen.h:6816
MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
Definition: miopen.h:6766
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
Definition: miopen.h:6906
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
Definition: miopen.h:6809
MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
Definition: miopen.h:6794
MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
Definition: miopen.h:6934
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
Definition: miopen.h:6886
MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
Definition: miopen.h:6967
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
Definition: miopen.h:6774
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
Definition: miopen.h:6810
MIOPEN_ATTR_ENGINE_LAYOUT_INFO
@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO
Definition: miopen.h:6854
MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
Definition: miopen.h:6761
MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
Definition: miopen.h:6737
MIOPEN_ATTR_RESAMPLE_COMP_TYPE
@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE
Definition: miopen.h:6890
MIOPEN_ATTR_ENGINECFG_ENGINE
@ MIOPEN_ATTR_ENGINECFG_ENGINE
Definition: miopen.h:6750
MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
Definition: miopen.h:6892
MIOPEN_ATTR_RESAMPLE_PADDING_MODE
@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE
Definition: miopen.h:6897
MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
Definition: miopen.h:6743
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
Definition: miopen.h:6937
MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
Definition: miopen.h:6799
MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
Definition: miopen.h:6930
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
Definition: miopen.h:6806
MIOPEN_ATTR_ENGINE_KNOB_INFO
@ MIOPEN_ATTR_ENGINE_KNOB_INFO
Definition: miopen.h:6852
MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
Definition: miopen.h:6865
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
Definition: miopen.h:6784
MIOPEN_ATTR_TENSOR_REORDERING_MODE
@ MIOPEN_ATTR_TENSOR_REORDERING_MODE
Definition: miopen.h:6834
MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
Definition: miopen.h:6762
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
Definition: miopen.h:6868
MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
Definition: miopen.h:6787
MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
Definition: miopen.h:6959
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
Definition: miopen.h:6763
MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
Definition: miopen.h:6842
MIOPEN_ATTR_ENGINEHEUR_MODE
@ MIOPEN_ATTR_ENGINEHEUR_MODE
Definition: miopen.h:6745
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
Definition: miopen.h:6909
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
Definition: miopen.h:6911
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
Definition: miopen.h:6818
MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
Definition: miopen.h:6789
MIOPEN_ATTR_POINTWISE_MODE
@ MIOPEN_ATTR_POINTWISE_MODE
Definition: miopen.h:6726
MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
Definition: miopen.h:6751
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
Definition: miopen.h:6786
MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
Definition: miopen.h:6951
MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
Definition: miopen.h:6728
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
Definition: miopen.h:6764
MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
Definition: miopen.h:6730
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
Definition: miopen.h:6884
MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
Definition: miopen.h:6962
MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
Definition: miopen.h:6748
MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
Definition: miopen.h:6808
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
Definition: miopen.h:6812
MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
Definition: miopen.h:6958
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
Definition: miopen.h:6877
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
Definition: miopen.h:6878
MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
Definition: miopen.h:6940
MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
Definition: miopen.h:6931
MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
Definition: miopen.h:6801
MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
Definition: miopen.h:6755
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
Definition: miopen.h:6903
MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
Definition: miopen.h:6950
MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
Definition: miopen.h:6947
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
Definition: miopen.h:6775
MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
Definition: miopen.h:6960
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
Definition: miopen.h:6783
MIOPEN_ATTR_TENSOR_STRIDES
@ MIOPEN_ATTR_TENSOR_STRIDES
Definition: miopen.h:6828
MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
Definition: miopen.h:6740
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
Definition: miopen.h:6781
MIOPEN_ATTR_POINTWISE_SWISH_BETA
@ MIOPEN_ATTR_POINTWISE_SWISH_BETA
Definition: miopen.h:6734
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
Definition: miopen.h:6901
MIOPEN_ATTR_OPERATION_REDUCTION_DESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC
Definition: miopen.h:6875
MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
Definition: miopen.h:6928
MIOPEN_ATTR_OPERATION_MATMUL_ADESC
@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC
Definition: miopen.h:6861
MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
Definition: miopen.h:6823
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
Definition: miopen.h:6813
MIOPEN_RNG_DISTRIBUTION_BERNOULLI
@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI
Definition: miopen.h:7195
MIOPEN_RNG_DISTRIBUTION_UNIFORM
@ MIOPEN_RNG_DISTRIBUTION_UNIFORM
Definition: miopen.h:7196
MIOPEN_RNG_DISTRIBUTION_NORMAL
@ MIOPEN_RNG_DISTRIBUTION_NORMAL
Definition: miopen.h:7197
MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
Definition: miopen.h:6693
MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
Definition: miopen.h:6711
MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
Definition: miopen.h:6685
MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
Definition: miopen.h:6709
MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
Definition: miopen.h:6704
MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
Definition: miopen.h:6683
MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
Definition: miopen.h:6706
MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
Definition: miopen.h:6690
MIOPEN_BACKEND_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_RNG_DESCRIPTOR
Definition: miopen.h:6712
MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
Definition: miopen.h:6701
MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
Definition: miopen.h:6700
MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
Definition: miopen.h:6686
MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
Definition: miopen.h:6705
MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
Definition: miopen.h:6691
MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
Definition: miopen.h:6702
MIOPEN_BACKEND_TENSOR_DESCRIPTOR
@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR
Definition: miopen.h:6713
MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
Definition: miopen.h:6703
MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
Definition: miopen.h:6708
MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
Definition: miopen.h:6696
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
Definition: miopen.h:6695
MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
Definition: miopen.h:6688
MIOPEN_BACKEND_ENGINE_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR
Definition: miopen.h:6684
MIOPEN_BACKEND_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR
Definition: miopen.h:6692
MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
Definition: miopen.h:6697
MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
Definition: miopen.h:6714
MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
Definition: miopen.h:6710
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
Definition: miopen.h:6694
MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
Definition: miopen.h:6698
MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
Definition: miopen.h:6699
MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
Definition: miopen.h:6707
MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
Definition: miopen.h:6687
MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
Definition: miopen.h:6689
SCALE
@ SCALE
Definition: miopen.h:7208
BILINEAR
@ BILINEAR
Definition: miopen.h:7209
DEFAULT
@ DEFAULT
Definition: miopen.h:7207
ERROR_STATE
@ ERROR_STATE
Definition: miopen.h:7210
MIOPEN_TYPE_RNG_DISTRIBUTION
@ MIOPEN_TYPE_RNG_DISTRIBUTION
Definition: miopen.h:7009
MIOPEN_TYPE_FLOAT
@ MIOPEN_TYPE_FLOAT
Definition: miopen.h:6984
MIOPEN_TYPE_NUMERICAL_NOTE
@ MIOPEN_TYPE_NUMERICAL_NOTE
Definition: miopen.h:6991
MIOPEN_TYPE_RESAMPLE_MODE
@ MIOPEN_TYPE_RESAMPLE_MODE
Definition: miopen.h:7001
MIOPEN_TYPE_INT32
@ MIOPEN_TYPE_INT32
Definition: miopen.h:7003
MIOPEN_TYPE_POINTWISE_MODE
@ MIOPEN_TYPE_POINTWISE_MODE
Definition: miopen.h:6994
MIOPEN_TYPE_HANDLE
@ MIOPEN_TYPE_HANDLE
Definition: miopen.h:6980
MIOPEN_TYPE_HEUR_MODE
@ MIOPEN_TYPE_HEUR_MODE
Definition: miopen.h:6988
MIOPEN_TYPE_CONVOLUTION_MODE
@ MIOPEN_TYPE_CONVOLUTION_MODE
Definition: miopen.h:6987
MIOPEN_TYPE_TENSOR_REORDERING_MODE
@ MIOPEN_TYPE_TENSOR_REORDERING_MODE
Definition: miopen.h:7000
MIOPEN_TYPE_BOOLEAN
@ MIOPEN_TYPE_BOOLEAN
Definition: miopen.h:6982
MIOPEN_TYPE_NORM_MODE
@ MIOPEN_TYPE_NORM_MODE
Definition: miopen.h:7007
MIOPEN_TYPE_FRACTION
@ MIOPEN_TYPE_FRACTION
Definition: miopen.h:7006
MIOPEN_TYPE_BACKEND_DESCRIPTOR
@ MIOPEN_TYPE_BACKEND_DESCRIPTOR
Definition: miopen.h:6995
MIOPEN_TYPE_ATTRIB_NAME
@ MIOPEN_TYPE_ATTRIB_NAME
Definition: miopen.h:6993
MIOPEN_TYPE_BEHAVIOR_NOTE
@ MIOPEN_TYPE_BEHAVIOR_NOTE
Definition: miopen.h:6999
MIOPEN_TYPE_DATA_TYPE
@ MIOPEN_TYPE_DATA_TYPE
Definition: miopen.h:6981
MIOPEN_TYPE_NAN_PROPOGATION
@ MIOPEN_TYPE_NAN_PROPOGATION
Definition: miopen.h:6990
MIOPEN_TYPE_DOUBLE
@ MIOPEN_TYPE_DOUBLE
Definition: miopen.h:6985
MIOPEN_TYPE_SIGNAL_MODE
@ MIOPEN_TYPE_SIGNAL_MODE
Definition: miopen.h:7005
MIOPEN_TYPE_CHAR
@ MIOPEN_TYPE_CHAR
Definition: miopen.h:7004
MIOPEN_TYPE_PADDING_MODE
@ MIOPEN_TYPE_PADDING_MODE
Definition: miopen.h:7002
MIOPEN_TYPE_INT64
@ MIOPEN_TYPE_INT64
Definition: miopen.h:6983
MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
Definition: miopen.h:6998
MIOPEN_TYPE_LAYOUT_TYPE
@ MIOPEN_TYPE_LAYOUT_TYPE
Definition: miopen.h:6992
MIOPEN_TYPE_GENSTATS_MODE
@ MIOPEN_TYPE_GENSTATS_MODE
Definition: miopen.h:6996
MIOPEN_TYPE_VOID_PTR
@ MIOPEN_TYPE_VOID_PTR
Definition: miopen.h:6986
MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
Definition: miopen.h:6997
MIOPEN_TYPE_KNOB_TYPE
@ MIOPEN_TYPE_KNOB_TYPE
Definition: miopen.h:6989
MIOPEN_TYPE_NORM_FWD_PHASE
@ MIOPEN_TYPE_NORM_FWD_PHASE
Definition: miopen.h:7008
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:475
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:8267
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:5382
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:5383
miopenRNNMode_t
miopenRNNMode_t
Definition: miopen.h:3987
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:3998
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:4020
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:4029
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:4064
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:4007
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:4055
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:4038
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:4046
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:3989
miopenLSTM
@ miopenLSTM
Definition: miopen.h:3990
miopenGRU
@ miopenGRU
Definition: miopen.h:3991
miopenRNNRELU
@ miopenRNNRELU
Definition: miopen.h:3988
miopenRNNlinear
@ miopenRNNlinear
Definition: miopen.h:3999
miopenRNNskip
@ miopenRNNskip
Definition: miopen.h:4000
miopenRNNbidirection
@ miopenRNNbidirection
Definition: miopen.h:4022
miopenRNNunidirection
@ miopenRNNunidirection
Definition: miopen.h:4021
miopenRNNwithBias
@ miopenRNNwithBias
Definition: miopen.h:4031
miopenRNNNoBias
@ miopenRNNNoBias
Definition: miopen.h:4030
miopenRNNDataSeqMajorPadded
@ miopenRNNDataSeqMajorPadded
Definition: miopen.h:4067
miopenRNNDataSeqMajorNotPadded
@ miopenRNNDataSeqMajorNotPadded
Definition: miopen.h:4066
miopenRNNDataBatchMajorPadded
@ miopenRNNDataBatchMajorPadded
Definition: miopen.h:4068
miopenRNNDataUnknownLayout
@ miopenRNNDataUnknownLayout
Definition: miopen.h:4065
miopenRNNroundedDynamic
@ miopenRNNroundedDynamic
Definition: miopen.h:4012
miopenRNNfundamental
@ miopenRNNfundamental
Definition: miopen.h:4010
miopenRNNdefault
@ miopenRNNdefault
Definition: miopen.h:4008
miopenRNNTraining
@ miopenRNNTraining
Definition: miopen.h:4056
miopenRNNInference
@ miopenRNNInference
Definition: miopen.h:4057
miopenRNNAlgoGEMM
@ miopenRNNAlgoGEMM
Definition: miopen.h:4039
miopenRNNIOWithPadding
@ miopenRNNIOWithPadding
Definition: miopen.h:4048
miopenRNNIONotPadded
@ miopenRNNIONotPadded
Definition: miopen.h:4047
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:6426
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:603
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:568
miopenIndicesType_t
miopenIndicesType_t
Definition: miopen.h:613
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:514
miopenSetActivationDescriptor
miopenStatus_t miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc, miopenActivationMode_t mode, double activAlpha, double activBeta, double activGamma)
Sets the activation layer descriptor details.
miopenCreateActivationDescriptor
miopenStatus_t miopenCreateActivationDescriptor(miopenActivationDescriptor_t *activDesc)
Creates the Activation descriptor object.
miopenGetActivationDescriptor
miopenStatus_t miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc, miopenActivationMode_t *mode, double *activAlpha, double *activBeta, double *activGamma)
Gets the activation layer descriptor details.
miopenGLUForward
miopenStatus_t miopenGLUForward(miopenHandle_t handle, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, const uint32_t dim)
Execute a GLU forward layer.
miopenDestroyActivationDescriptor
miopenStatus_t miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc)
Destroys the activation descriptor object.
miopenBatchNormalizationForwardInference
miopenStatus_t miopenBatchNormalizationForwardInference(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon)
Execute forward inference layer for batch normalization.
miopenBatchNormalizationForwardInference_V2
miopenStatus_t miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon)
Execute forward inference layer for batch normalization.
miopenBatchNormForwardTrainingActivation
miopenStatus_t miopenBatchNormForwardTrainingActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, void *resultRunningMean, void *resultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance, const miopenActivationDescriptor_t activDesc)
Execute forward training layer for batch normalization with fused activation.
miopenBatchNormBackwardActivation
miopenStatus_t miopenBatchNormBackwardActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, const void *alphaDataDiff, const void *betaDataDiff, const void *alphaParamDiff, const void *betaParamDiff, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarianceDesc, const void *bnScale, const void *bnBias, void *resultBnScaleDiff, void *resultBnBiasDiff, double epsilon, const void *savedMean, const void *savedInvVariance, const miopenActivationDescriptor_t activDesc)
Execute backwards propagation layer for batch normalization with fused activation.
miopenBatchNormalizationForwardTraining
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:504
miopenBatchNormForwardInferenceActivation
miopenStatus_t miopenBatchNormForwardInferenceActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon, const miopenActivationDescriptor_t activDesc)
Execute forward inference layer for batch normalization with fused activation.
miopenDeriveBNTensorDescriptor
miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc, const miopenTensorDescriptor_t xDesc, miopenBatchNormMode_t bn_mode)
Derive tensor for gamma and beta from input tensor descriptor.
miopenCatForward
miopenStatus_t miopenCatForward(miopenHandle_t handle, const int32_t xCount, const miopenTensorDescriptor_t *xDescs, const void *const *xs, const miopenTensorDescriptor_t yDesc, void *y, const int32_t dim)
Execute a cat forward layer.
miopenInitConvolutionNdDescriptor
miopenStatus_t miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc, int spatialDim, const int *padA, const int *strideA, const int *dilationA, miopenConvolutionMode_t c_mode)
Creates a N-dimensional convolution layer descriptor.
miopenConvolutionForwardImmediate
miopenStatus_t miopenConvolutionForwardImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, void *y, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)
Executes the Forward convolution operation based on the provided solution ID.
miopenConvolutionBackwardDataCompileSolution
miopenStatus_t miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const uint64_t solution_id)
Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionBac...
miopenConvolutionForwardGetSolutionWorkspaceSize
miopenStatus_t miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const uint64_t solution_id, size_t *workSpaceSize)
Returns the workspace size required for a particular solution id.
miopenConvolutionForward
miopenStatus_t miopenConvolutionForward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvFwdAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, void *workSpace, size_t workSpaceSize)
Execute a forward convolution layer.
miopenGetConvolutionGroupCount
miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)
Get the number of groups to be used in Group/Depthwise convolution.
miopenGetConvolutionFindMode
miopenStatus_t miopenGetConvolutionFindMode(const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t *findMode)
Reads the Find Mode attribute from the convolution descriptor.
miopenInitConvolutionDescriptor
miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc, miopenConvolutionMode_t c_mode, int pad_h, int pad_w, int stride_h, int stride_w, int dilation_h, int dilation_w)
Creates a 2-D convolution layer descriptor.
miopenConvAlgorithm_t
miopenConvAlgorithm_t
Definition: miopen.h:1263
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:1226
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:1249
miopenConvolutionAttrib_t
miopenConvolutionAttrib_t
Definition: miopen.h:625
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:429
miopenSetConvolutionAttribute
miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc, const miopenConvolutionAttrib_t attr, int value)
Set the attribute of the convolution descriptor.
miopenConvolutionBackwardDataImmediate
miopenStatus_t miopenConvolutionBackwardDataImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)
Executes the Backward convolution w-r-t data operation based on the provided solution ID.
miopenSetTransposeConvNdOutputPadding
miopenStatus_t miopenSetTransposeConvNdOutputPadding(miopenConvolutionDescriptor_t convDesc, int spatialDim, const int *adjA)
Set the output padding to be used in N-dimensional Transpose convolution.
miopenSetConvolutionFindMode
miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t findMode)
Sets the Find Mode attribute in the convolution descriptor.
miopenSetTransposeConvOutputPadding
miopenStatus_t miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w)
Set the output padding to be used in 2-D Transpose convolution.
miopenConvolutionFindMode_t
miopenConvolutionFindMode_t
Definition: miopen.h:651
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:1238
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:1265
miopenConvolutionAlgoWinograd
@ miopenConvolutionAlgoWinograd
Definition: miopen.h:1267
miopenConvolutionAlgoFFT
@ miopenConvolutionAlgoFFT
Definition: miopen.h:1266
miopenConvolutionAlgoImplicitGEMM
@ miopenConvolutionAlgoImplicitGEMM
Definition: miopen.h:1268
miopenConvolutionAlgoGEMM
@ miopenConvolutionAlgoGEMM
Definition: miopen.h:1264
miopenConvolutionFwdAlgoFFT
@ miopenConvolutionFwdAlgoFFT
Definition: miopen.h:1229
miopenConvolutionFwdAlgoImplicitGEMM
@ miopenConvolutionFwdAlgoImplicitGEMM
Definition: miopen.h:1231
miopenConvolutionFwdAlgoGEMM
@ miopenConvolutionFwdAlgoGEMM
Definition: miopen.h:1227
miopenConvolutionFwdAlgoWinograd
@ miopenConvolutionFwdAlgoWinograd
Definition: miopen.h:1230
miopenConvolutionFwdAlgoDirect
@ miopenConvolutionFwdAlgoDirect
Definition: miopen.h:1228
miopenTransposeBwdDataAlgoGEMM
@ miopenTransposeBwdDataAlgoGEMM
Definition: miopen.h:1254
miopenConvolutionBwdDataAlgoDirect
@ miopenConvolutionBwdDataAlgoDirect
Definition: miopen.h:1251
miopenConvolutionBwdDataAlgoGEMM
@ miopenConvolutionBwdDataAlgoGEMM
Definition: miopen.h:1250
miopenConvolutionBwdDataAlgoFFT
@ miopenConvolutionBwdDataAlgoFFT
Definition: miopen.h:1252
miopenConvolutionBwdDataAlgoWinograd
@ miopenConvolutionBwdDataAlgoWinograd
Definition: miopen.h:1253
miopenConvolutionBwdDataAlgoImplicitGEMM
@ miopenConvolutionBwdDataAlgoImplicitGEMM
Definition: miopen.h:1256
miopenConvolutionBwdWeightsAlgoGEMM
@ miopenConvolutionBwdWeightsAlgoGEMM
Definition: miopen.h:1239
miopenConvolutionBwdWeightsAlgoWinograd
@ miopenConvolutionBwdWeightsAlgoWinograd
Definition: miopen.h:1241
miopenConvolutionBwdWeightsAlgoDirect
@ miopenConvolutionBwdWeightsAlgoDirect
Definition: miopen.h:1240
miopenConvolutionBwdWeightsAlgoImplicitGEMM
@ miopenConvolutionBwdWeightsAlgoImplicitGEMM
Definition: miopen.h:1242
miopenDestroyDropoutDescriptor
miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)
Destroys the dropout descriptor object.
miopenRNGType_t
miopenRNGType_t
Definition: miopen.h:5502
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:5503
miopenFindResultsOrder_t
miopenFindResultsOrder_t
Definition: miopen.h:5933
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:5961
miopenSetMhaDescriptor
miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale)
Sets the Mha descriptor details.
miopenSetFindOptionWorkspaceLimit
miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options, size_t value)
Sets the workspace limit find option. Default value is maximum of size_t.
miopenSetFindOptionPreallocatedTensor
miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options, miopenTensorArgumentId_t id, void *buffer)
Attaches a preallocated tensor to find options. If not used, buffers are allocated by MIOpen internal...
miopenCreateSoftmaxProblem
miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t *problem, miopenSoftmaxDescriptor_t operatorDesc, miopenProblemDirection_t direction)
Initializes a problem object describing a softmax operation.
miopenDestroyFindOptions
miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options)
Destroys miopenFindOptions object.
miopenSetFindOptionAttachBinaries
miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options, unsigned attach)
Forces library to attach kernel binaries to solutions for later saving. This allows zero lookup miope...
miopenFuseProblems
miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2)
Fuse two problems into a single one. Problems can be either regular, or fused. No problems are dispos...
miopenGetSolutionSize
miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t *size)
Reads the expected size of a solution.
miopenTensorArgumentId_t
miopenTensorArgumentId_t
Definition: miopen.h:5852
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:5839
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:5935
miopenFindResultsOrderByTime
@ miopenFindResultsOrderByTime
Definition: miopen.h:5934
miopenMhaMaskCausal
@ miopenMhaMaskCausal
Definition: miopen.h:5963
miopenMhaMaskNone
@ miopenMhaMaskNone
Definition: miopen.h:5962
miopenTensorMhaDescaleS
@ miopenTensorMhaDescaleS
Definition: miopen.h:5864
miopenTensorMhaO
@ miopenTensorMhaO
Definition: miopen.h:5870
miopenTensorMhaAmaxDV
@ miopenTensorMhaAmaxDV
Definition: miopen.h:5888
miopenTensorBatchnormScaleDiff
@ miopenTensorBatchnormScaleDiff
Definition: miopen.h:5911
miopenTensorMhaMask
@ miopenTensorMhaMask
Definition: miopen.h:5922
miopenTensorMhaDescaleDS
@ miopenTensorMhaDescaleDS
Definition: miopen.h:5878
miopenTensorMhaDropoutSeed
@ miopenTensorMhaDropoutSeed
Definition: miopen.h:5868
miopenTensorBatchnormSavedMean
@ miopenTensorBatchnormSavedMean
Definition: miopen.h:5908
miopenTensorActivationDY
@ miopenTensorActivationDY
Definition: miopen.h:5896
miopenTensorBatchnormDX
@ miopenTensorBatchnormDX
Definition: miopen.h:5916
miopenTensorMhaDescaleV
@ miopenTensorMhaDescaleV
Definition: miopen.h:5863
miopenTensorMhaK
@ miopenTensorMhaK
Definition: miopen.h:5858
miopenTensorConvolutionX
@ miopenTensorConvolutionX
Definition: miopen.h:5854
miopenTensorMhaAmaxDK
@ miopenTensorMhaAmaxDK
Definition: miopen.h:5887
miopenTensorMhaScaleDS
@ miopenTensorMhaScaleDS
Definition: miopen.h:5879
miopenTensorBatchnormBias
@ miopenTensorBatchnormBias
Definition: miopen.h:5914
miopenTensorMhaM
@ miopenTensorMhaM
Definition: miopen.h:5873
miopenTensorBatchnormRunningMean
@ miopenTensorBatchnormRunningMean
Definition: miopen.h:5906
miopenTensorMhaDropoutProbability
@ miopenTensorMhaDropoutProbability
Definition: miopen.h:5867
miopenTensorSoftmaxY
@ miopenTensorSoftmaxY
Definition: miopen.h:5901
miopenTensorSoftmaxDY
@ miopenTensorSoftmaxDY
Definition: miopen.h:5903
miopenTensorMhaDescaleO
@ miopenTensorMhaDescaleO
Definition: miopen.h:5876
miopenTensorMhaScaleO
@ miopenTensorMhaScaleO
Definition: miopen.h:5866
miopenScalarBatchnormExpAvgFactor
@ miopenScalarBatchnormExpAvgFactor
Definition: miopen.h:5924
miopenTensorBatchnormScale
@ miopenTensorBatchnormScale
Definition: miopen.h:5910
miopenTensorBatchnormRunningVariance
@ miopenTensorBatchnormRunningVariance
Definition: miopen.h:5907
miopenTensorActivationDX
@ miopenTensorActivationDX
Definition: miopen.h:5895
miopenTensorMhaScaleDK
@ miopenTensorMhaScaleDK
Definition: miopen.h:5881
miopenTensorMhaV
@ miopenTensorMhaV
Definition: miopen.h:5860
miopenTensorMhaAmaxS
@ miopenTensorMhaAmaxS
Definition: miopen.h:5872
miopenTensorBatchnormBiasDiff
@ miopenTensorBatchnormBiasDiff
Definition: miopen.h:5915
miopenTensorBatchnormSavedVariance
@ miopenTensorBatchnormSavedVariance
Definition: miopen.h:5909
miopenTensorActivationX
@ miopenTensorActivationX
Definition: miopen.h:5893
miopenTensorMhaScaleDV
@ miopenTensorMhaScaleDV
Definition: miopen.h:5882
miopenTensorMhaAmaxO
@ miopenTensorMhaAmaxO
Definition: miopen.h:5871
miopenScalarBatchnormEpsilon
@ miopenScalarBatchnormEpsilon
Definition: miopen.h:5925
miopenTensorMhaScaleDQ
@ miopenTensorMhaScaleDQ
Definition: miopen.h:5880
miopenTensorSoftmaxDX
@ miopenTensorSoftmaxDX
Definition: miopen.h:5902
miopenTensorMhaAmaxDS
@ miopenTensorMhaAmaxDS
Definition: miopen.h:5889
miopenTensorMhaDV
@ miopenTensorMhaDV
Definition: miopen.h:5885
miopenTensorMhaQ
@ miopenTensorMhaQ
Definition: miopen.h:5859
miopenTensorMhaAmaxDQ
@ miopenTensorMhaAmaxDQ
Definition: miopen.h:5886
miopenTensorConvolutionY
@ miopenTensorConvolutionY
Definition: miopen.h:5856
miopenTensorBatchnormEstimatedMean
@ miopenTensorBatchnormEstimatedMean
Definition: miopen.h:5912
miopenTensorBatchnormDY
@ miopenTensorBatchnormDY
Definition: miopen.h:5917
miopenTensorMhaZInv
@ miopenTensorMhaZInv
Definition: miopen.h:5874
miopenTensorMhaDescaleQ
@ miopenTensorMhaDescaleQ
Definition: miopen.h:5862
miopenTensorMhaBias
@ miopenTensorMhaBias
Definition: miopen.h:5890
miopenTensorBatchnormEstimatedVariance
@ miopenTensorBatchnormEstimatedVariance
Definition: miopen.h:5913
miopenTensorArgumentIsScalar
@ miopenTensorArgumentIsScalar
Definition: miopen.h:5920
miopenTensorArgumentIdInvalid
@ miopenTensorArgumentIdInvalid
Definition: miopen.h:5853
miopenTensorMhaDO
@ miopenTensorMhaDO
Definition: miopen.h:5875
miopenTensorMhaDescaleDO
@ miopenTensorMhaDescaleDO
Definition: miopen.h:5877
miopenTensorConvolutionW
@ miopenTensorConvolutionW
Definition: miopen.h:5855
miopenTensorMhaDescaleK
@ miopenTensorMhaDescaleK
Definition: miopen.h:5861
miopenTensorMhaDropoutOffset
@ miopenTensorMhaDropoutOffset
Definition: miopen.h:5869
miopenTensorBiasY
@ miopenTensorBiasY
Definition: miopen.h:5898
miopenTensorMhaDQ
@ miopenTensorMhaDQ
Definition: miopen.h:5883
miopenTensorSoftmaxX
@ miopenTensorSoftmaxX
Definition: miopen.h:5900
miopenTensorBatchnormY
@ miopenTensorBatchnormY
Definition: miopen.h:5905
miopenTensorMhaScaleS
@ miopenTensorMhaScaleS
Definition: miopen.h:5865
miopenTensorBias
@ miopenTensorBias
Definition: miopen.h:5899
miopenTensorActivationY
@ miopenTensorActivationY
Definition: miopen.h:5894
miopenTensorBatchnormX
@ miopenTensorBatchnormX
Definition: miopen.h:5904
miopenTensorBiasX
@ miopenTensorBiasX
Definition: miopen.h:5897
miopenTensorMhaDK
@ miopenTensorMhaDK
Definition: miopen.h:5884
miopenProblemDirectionBackwardWeights
@ miopenProblemDirectionBackwardWeights
Definition: miopen.h:5842
miopenProblemDirectionInference
@ miopenProblemDirectionInference
Definition: miopen.h:5844
miopenProblemDirectionForward
@ miopenProblemDirectionForward
Definition: miopen.h:5840
miopenProblemDirectionBackward
@ miopenProblemDirectionBackward
Definition: miopen.h:5841
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:485
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:452
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:405
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:465
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:6366
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:6367
MIOPEN_REDUCE_CALCULATION_SUM
@ MIOPEN_REDUCE_CALCULATION_SUM
Definition: miopen.h:6369
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:548
miopenSoftmaxAlgorithm_t
miopenSoftmaxAlgorithm_t
Definition: miopen.h:537
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:388
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:417
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:441
miopenPaddingDefault
@ miopenPaddingDefault
Definition: miopen.h:442
miopenPaddingSame
@ miopenPaddingSame
Definition: miopen.h:443
miopenPaddingValid
@ miopenPaddingValid
Definition: miopen.h:444
miopenReduceCalculationNanPropagation_t
miopenReduceCalculationNanPropagation_t
Definition: miopen.h:6350
MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
Definition: miopen.h:6352
MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
Definition: miopen.h:6351
MIOPEN_DECLARE_OBJECT
#define MIOPEN_DECLARE_OBJECT(name)
Definition: miopen.h:79
miopenNanPropagation_t
miopenNanPropagation_t
Definition: miopen.h:593
MIOPEN_PROPAGATE_NAN
@ MIOPEN_PROPAGATE_NAN
Definition: miopen.h:595
MIOPEN_NOT_PROPAGATE_NAN
@ MIOPEN_NOT_PROPAGATE_NAN
Definition: miopen.h:594
MIOPEN_LOSS_REDUCTION_MEAN
@ MIOPEN_LOSS_REDUCTION_MEAN
Definition: miopen.h:8270
MIOPEN_LOSS_REDUCTION_SUM
@ MIOPEN_LOSS_REDUCTION_SUM
Definition: miopen.h:8269
MIOPEN_LOSS_REDUCTION_NONE
@ MIOPEN_LOSS_REDUCTION_NONE
Definition: miopen.h:8268
miopenPoolingAverage
@ miopenPoolingAverage
Definition: miopen.h:454
miopenPoolingAverageInclusive
@ miopenPoolingAverageInclusive
Definition: miopen.h:455
miopenPoolingMax
@ miopenPoolingMax
Definition: miopen.h:453
miopenTensorCHWN
@ miopenTensorCHWN
Definition: miopen.h:391
miopenTensorNHWC
@ miopenTensorNHWC
Definition: miopen.h:390
miopenTensorNDHWC
@ miopenTensorNDHWC
Definition: miopen.h:397
miopenTensorNCHW
@ miopenTensorNCHW
Definition: miopen.h:389
miopenTensorCHWNc4
@ miopenTensorCHWNc4
Definition: miopen.h:394
miopenTensorNCHWc8
@ miopenTensorNCHWc8
Definition: miopen.h:393
miopenTensorNCDHW
@ miopenTensorNCDHW
Definition: miopen.h:396
miopenTensorCHWNc8
@ miopenTensorCHWNc8
Definition: miopen.h:395
miopenTensorNCHWc4
@ miopenTensorNCHWc4
Definition: miopen.h:392
MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES
@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES
Definition: miopen.h:605
MIOPEN_REDUCE_TENSOR_NO_INDICES
@ MIOPEN_REDUCE_TENSOR_NO_INDICES
Definition: miopen.h:604
miopenActivationLEAKYRELU
@ miopenActivationLEAKYRELU
Definition: miopen.h:524
miopenActivationPASTHRU
@ miopenActivationPASTHRU
Definition: miopen.h:515
miopenActivationABS
@ miopenActivationABS
Definition: miopen.h:520
miopenActivationLOGISTIC
@ miopenActivationLOGISTIC
Definition: miopen.h:516
miopenActivationCLIPPEDRELU
@ miopenActivationCLIPPEDRELU
Definition: miopen.h:522
miopenActivationRELU
@ miopenActivationRELU
Definition: miopen.h:518
miopenActivationPOWER
@ miopenActivationPOWER
Definition: miopen.h:521
miopenActivationELU
@ miopenActivationELU
Definition: miopen.h:526
miopenActivationCLAMP
@ miopenActivationCLAMP
Definition: miopen.h:529
miopenActivationSOFTRELU
@ miopenActivationSOFTRELU
Definition: miopen.h:519
miopenActivationTANH
@ miopenActivationTANH
Definition: miopen.h:517
MIOPEN_REDUCE_TENSOR_MUL
@ MIOPEN_REDUCE_TENSOR_MUL
Definition: miopen.h:570
MIOPEN_REDUCE_TENSOR_MAX
@ MIOPEN_REDUCE_TENSOR_MAX
Definition: miopen.h:574
MIOPEN_REDUCE_TENSOR_AVG
@ MIOPEN_REDUCE_TENSOR_AVG
Definition: miopen.h:578
MIOPEN_REDUCE_TENSOR_NORM1
@ MIOPEN_REDUCE_TENSOR_NORM1
Definition: miopen.h:580
MIOPEN_REDUCE_TENSOR_AMAX
@ MIOPEN_REDUCE_TENSOR_AMAX
Definition: miopen.h:576
MIOPEN_REDUCE_TENSOR_MIN
@ MIOPEN_REDUCE_TENSOR_MIN
Definition: miopen.h:572
MIOPEN_REDUCE_TENSOR_ADD
@ MIOPEN_REDUCE_TENSOR_ADD
Definition: miopen.h:569
MIOPEN_REDUCE_TENSOR_NORM2
@ MIOPEN_REDUCE_TENSOR_NORM2
Definition: miopen.h:582
MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC
@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC
Definition: miopen.h:630
MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE
@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE
Definition: miopen.h:634
MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL
@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL
Definition: miopen.h:626
miopenIndexUint16
@ miopenIndexUint16
Definition: miopen.h:407
miopenIndexUint64
@ miopenIndexUint64
Definition: miopen.h:409
miopenIndexUint32
@ miopenIndexUint32
Definition: miopen.h:408
miopenIndexUint8
@ miopenIndexUint8
Definition: miopen.h:406
miopenFloat
@ miopenFloat
Definition: miopen.h:370
miopenBFloat8_fnuz
@ miopenBFloat8_fnuz
Definition: miopen.h:378
miopenBFloat16
@ miopenBFloat16
Definition: miopen.h:374
miopenInt8
@ miopenInt8
Definition: miopen.h:372
miopenInt32
@ miopenInt32
Definition: miopen.h:371
miopenHalf
@ miopenHalf
Definition: miopen.h:369
miopenInt64
@ miopenInt64
Definition: miopen.h:379
miopenDouble
@ miopenDouble
Definition: miopen.h:376
miopenFloat8_fnuz
@ miopenFloat8_fnuz
Definition: miopen.h:377
MIOPEN_8BIT_INDICES
@ MIOPEN_8BIT_INDICES
Definition: miopen.h:617
MIOPEN_32BIT_INDICES
@ MIOPEN_32BIT_INDICES
Definition: miopen.h:614
MIOPEN_16BIT_INDICES
@ MIOPEN_16BIT_INDICES
Definition: miopen.h:616
MIOPEN_64BIT_INDICES
@ MIOPEN_64BIT_INDICES
Definition: miopen.h:615
miopenPoolingWorkspaceIndexImage
@ miopenPoolingWorkspaceIndexImage
Definition: miopen.h:467
miopenPoolingWorkspaceIndexMask
@ miopenPoolingWorkspaceIndexMask
Definition: miopen.h:466
miopenDepthwise
@ miopenDepthwise
Definition: miopen.h:433
miopenGroupConv
@ miopenGroupConv
Definition: miopen.h:432
miopenTranspose
@ miopenTranspose
Definition: miopen.h:431
miopenConvolution
@ miopenConvolution
Definition: miopen.h:430
MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD
@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD
Definition: miopen.h:489
MIOPEN_WEIGHT_BIAS
@ MIOPEN_WEIGHT_BIAS
Definition: miopen.h:487
MIOPEN_ELEMENTWISE_AFFINE
@ MIOPEN_ELEMENTWISE_AFFINE
Definition: miopen.h:486
MIOPEN_WEIGHT_BIAS_T5
@ MIOPEN_WEIGHT_BIAS_T5
Definition: miopen.h:495
MIOPEN_ELEMENTWISE_AFFINE_T5
@ MIOPEN_ELEMENTWISE_AFFINE_T5
Definition: miopen.h:493
MIOPEN_WEIGHT_BIAS_FUSED_ADD
@ MIOPEN_WEIGHT_BIAS_FUSED_ADD
Definition: miopen.h:491
MIOPEN_REDUCE_EXTREME_ARGMAX
@ MIOPEN_REDUCE_EXTREME_ARGMAX
Definition: miopen.h:6429
MIOPEN_REDUCE_EXTREME_MIN
@ MIOPEN_REDUCE_EXTREME_MIN
Definition: miopen.h:6431
MIOPEN_REDUCE_EXTREME_MAX
@ MIOPEN_REDUCE_EXTREME_MAX
Definition: miopen.h:6433
MIOPEN_REDUCE_EXTREME_ARGMIN
@ MIOPEN_REDUCE_EXTREME_ARGMIN
Definition: miopen.h:6427
miopenTensorOpMin
@ miopenTensorOpMin
Definition: miopen.h:420
miopenTensorOpAdd
@ miopenTensorOpAdd
Definition: miopen.h:418
miopenTensorOpMul
@ miopenTensorOpMul
Definition: miopen.h:419
miopenTensorOpMax
@ miopenTensorOpMax
Definition: miopen.h:421
miopenBNSpatial
@ miopenBNSpatial
Definition: miopen.h:506
miopenBNPerActivation
@ miopenBNPerActivation
Definition: miopen.h:505
miopenConvolutionFindModeDynamicHybrid
@ miopenConvolutionFindModeDynamicHybrid
Definition: miopen.h:663
miopenConvolutionFindModeDefault
@ miopenConvolutionFindModeDefault
Definition: miopen.h:668
miopenConvolutionFindModeHybrid
@ miopenConvolutionFindModeHybrid
Definition: miopen.h:658
miopenConvolutionFindModeFast
@ miopenConvolutionFindModeFast
Definition: miopen.h:654
miopenConvolutionFindModeNormal
@ miopenConvolutionFindModeNormal
Definition: miopen.h:652
miopenLRNWithinChannel
@ miopenLRNWithinChannel
Definition: miopen.h:476
miopenLRNCrossChannel
@ miopenLRNCrossChannel
Definition: miopen.h:477
MIOPEN_SOFTMAX_MODE_INSTANCE
@ MIOPEN_SOFTMAX_MODE_INSTANCE
Definition: miopen.h:549
MIOPEN_SOFTMAX_MODE_CHANNEL
@ MIOPEN_SOFTMAX_MODE_CHANNEL
Definition: miopen.h:550
MIOPEN_SOFTMAX_FAST
@ MIOPEN_SOFTMAX_FAST
Definition: miopen.h:538
MIOPEN_SOFTMAX_ACCURATE
@ MIOPEN_SOFTMAX_ACCURATE
Definition: miopen.h:539
MIOPEN_SOFTMAX_LOG
@ MIOPEN_SOFTMAX_LOG
Definition: miopen.h:540
miopenConvAlgoPerf_t
Perf struct for forward, backward filter, or backward data algorithms.
Definition: miopen.h:1278
miopenConvAlgoPerf_t::fwd_algo
miopenConvFwdAlgorithm_t fwd_algo
Definition: miopen.h:1281
miopenConvAlgoPerf_t::bwd_data_algo
miopenConvBwdDataAlgorithm_t bwd_data_algo
Definition: miopen.h:1285
miopenConvAlgoPerf_t::memory
size_t memory
Definition: miopen.h:1289
miopenConvAlgoPerf_t::bwd_weights_algo
miopenConvBwdWeightsAlgorithm_t bwd_weights_algo
Definition: miopen.h:1282
miopenConvAlgoPerf_t::time
float time
Definition: miopen.h:1288
miopenConvSolution_t
Performance struct for forward, backward filter, or backward data algorithms in immediate mode.
Definition: miopen.h:1302
miopenConvSolution_t::algorithm
miopenConvAlgorithm_t algorithm
Definition: miopen.h:1309
miopenConvSolution_t::solution_id
uint64_t solution_id
Definition: miopen.h:1308
miopenConvSolution_t::workspace_size
size_t workspace_size
Definition: miopen.h:1306
miopenConvSolution_t::time
float time
Definition: miopen.h:1303
miopenTensorArgument_t
Values of a tensor or scalar argument for the miopenRunSolution function.
Definition: miopen.h:6164
miopenTensorArgument_t::id
miopenTensorArgumentId_t id
Definition: miopen.h:6167
miopenTensorArgument_t::buffer
void * buffer
Definition: miopen.h:6177
miopenTensorArgument_t::descriptor
miopenTensorDescriptor_t * descriptor
Definition: miopen.h:6173