Skip to main content
`Ctrl`+`K`

# /build/miopen-N02n9r/miopen-7.2.4+dfsg/include/miopen/miopen.h Source File

MIOpen: /build/miopen-N02n9r/miopen-7.2.4+dfsg/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
104
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
138MIOPEN_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
173MIOPEN_EXPORT miopenStatus_t miopenGetVersion(size_t* major, size_t* minor, size_t* patch);
174
183MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);
184
196MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,
197 miopenAcceleratorQueue_t stream);
198
205MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);
206
214MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,
215 miopenAcceleratorQueue_t streamID);
216
224MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,
225 miopenAcceleratorQueue_t* streamID);
226
243MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,
244 miopenAllocatorFunction allocator,
245 miopenDeallocatorFunction deallocator,
246 void* allocatorContext);
247
259MIOPEN_EXPORT miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float* time);
260
268MIOPEN_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 miopenConvolutionFindModeTrustVerify = 6,
669 miopenConvolutionFindModeTrustVerifyFull = 7,
670 miopenConvolutionFindModeDefault =
671 miopenConvolutionFindModeDynamicHybrid
672} miopenConvolutionFindMode_t;
673
678
685MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);
686
699MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(
700 miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w);
701
712MIOPEN_EXPORT miopenStatus_t
713 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,
714 miopenDataType_t dataType,
715 miopenTensorLayout_t tensorLayout,
716 const int* lens,
717 int num_lens);
737MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,
738 miopenDataType_t dataType,
739 int n,
740 int c,
741 int h,
742 int w,
743 int nStride,
744 int cStride,
745 int hStride,
746 int wStride);
747
764MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
765 miopenDataType_t* dataType,
766 int* n,
767 int* c,
768 int* h,
769 int* w,
770 int* nStride,
771 int* cStride,
772 int* hStride,
773 int* wStride);
774
785MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
786 miopenDataType_t dataType,
787 int nbDims,
788 const int* dimsA,
789 const int* stridesA);
790
791#ifdef MIOPEN_BETA_API
794MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,
795 miopenDataType_t dataType,
796 int nbDims,
797 const size_t* dimsA,
798 const size_t* stridesA);
799#endif
800
801#ifdef MIOPEN_BETA_API
811MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,
812 miopenDataType_t cast_type);
813#endif
814
823MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,
824 int* size);
825
834MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
835 miopenDataType_t* dataType,
836 int* dimsA,
837 int* stridesA);
838
844MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);
845
852MIOPEN_EXPORT miopenStatus_t
853 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);
854
860MIOPEN_EXPORT miopenStatus_t
861 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);
862
882MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,
883 miopenTensorOp_t tensorOp,
884 const void* alpha1,
885 const miopenTensorDescriptor_t aDesc,
886 const void* A,
887 const void* alpha2,
888 const miopenTensorDescriptor_t bDesc,
889 const void* B,
890 const void* beta,
891 const miopenTensorDescriptor_t cDesc,
892 void* C);
893
904MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,
905 const miopenTensorDescriptor_t yDesc,
906 void* y,
907 const void* alpha);
908
919MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,
920 const miopenTensorDescriptor_t yDesc,
921 void* y,
922 const void* alpha);
923
930MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,
931 size_t* numBytes);
932
950MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,
951 const void* alpha,
952 const miopenTensorDescriptor_t xDesc,
953 const void* x,
954 const void* beta,
955 const miopenTensorDescriptor_t yDesc,
956 void* y);
957
959// CLOSEOUT TENSOR DOXYGEN GROUP
960
965
971MIOPEN_EXPORT miopenStatus_t
972 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);
973
989MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
990 miopenConvolutionMode_t c_mode,
991 int pad_h,
992 int pad_w,
993 int stride_h,
994 int stride_w,
995 int dilation_h,
996 int dilation_w);
997
1008MIOPEN_EXPORT miopenStatus_t
1009 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1010 int spatialDim,
1011 const int* padA,
1012 const int* strideA,
1013 const int* dilationA,
1014 miopenConvolutionMode_t c_mode);
1015
1022MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,
1023 int* spatialDim);
1024
1040MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,
1041 miopenConvolutionMode_t* c_mode,
1042 int* pad_h,
1043 int* pad_w,
1044 int* stride_h,
1045 int* stride_w,
1046 int* dilation_h,
1047 int* dilation_w);
1048
1060MIOPEN_EXPORT miopenStatus_t
1061 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
1062 int requestedSpatialDim,
1063 int* spatialDim,
1064 int* padA,
1065 int* strideA,
1066 int* dilationA,
1067 miopenConvolutionMode_t* c_mode);
1068
1075MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1076 int* groupCount);
1077
1091MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
1092 int groupCount);
1093
1106MIOPEN_EXPORT miopenStatus_t
1107 miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w);
1108
1121MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(
1122 miopenConvolutionDescriptor_t convDesc, int spatialDim, const int* adjA);
1123
1141MIOPEN_EXPORT miopenStatus_t
1142 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1143 const miopenTensorDescriptor_t inputTensorDesc,
1144 const miopenTensorDescriptor_t filterDesc,
1145 int* n,
1146 int* c,
1147 int* h,
1148 int* w);
1149
1163MIOPEN_EXPORT miopenStatus_t
1164 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
1165 const miopenTensorDescriptor_t inputTensorDesc,
1166 const miopenTensorDescriptor_t filterDesc,
1167 int* nDim,
1168 int* outputTensorDimA);
1169
1175MIOPEN_EXPORT miopenStatus_t
1176 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);
1177
1184MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1185 const miopenConvolutionAttrib_t attr,
1186 int value);
1187
1194MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
1195 const miopenConvolutionAttrib_t attr,
1196 int* value);
1197
1211MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,
1212 miopenConvolutionFindMode_t findMode);
1213
1220MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(
1221 const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);
1222
1227 typedef enum
1228{
1229 miopenConvolutionFwdAlgoGEMM = 0,
1230 miopenConvolutionFwdAlgoDirect = 1,
1231 miopenConvolutionFwdAlgoFFT = 2,
1232 miopenConvolutionFwdAlgoWinograd = 3,
1233 miopenConvolutionFwdAlgoImplicitGEMM = 5,
1234} miopenConvFwdAlgorithm_t;
1235
1239 typedef enum
1240{
1241 miopenConvolutionBwdWeightsAlgoGEMM = 0,
1242 miopenConvolutionBwdWeightsAlgoDirect = 1,
1243 miopenConvolutionBwdWeightsAlgoWinograd = 3,
1244 miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,
1245} miopenConvBwdWeightsAlgorithm_t;
1246
1250 typedef enum
1251{
1252 miopenConvolutionBwdDataAlgoGEMM = 0,
1253 miopenConvolutionBwdDataAlgoDirect = 1,
1254 miopenConvolutionBwdDataAlgoFFT = 2,
1255 miopenConvolutionBwdDataAlgoWinograd = 3,
1256 miopenTransposeBwdDataAlgoGEMM =
1257 4,
1258 miopenConvolutionBwdDataAlgoImplicitGEMM = 5,
1259} miopenConvBwdDataAlgorithm_t;
1260
1264 typedef enum
1265{
1266 miopenConvolutionAlgoGEMM = 0,
1267 miopenConvolutionAlgoDirect = 1,
1268 miopenConvolutionAlgoFFT = 2,
1269 miopenConvolutionAlgoWinograd = 3,
1270 miopenConvolutionAlgoImplicitGEMM = 5,
1271} miopenConvAlgorithm_t;
1272
1279 typedef struct
1280{
1281 union
1282 {
1283 miopenConvFwdAlgorithm_t fwd_algo;
1284 miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;
1286 miopenConvBwdDataAlgorithm_t
1287 bwd_data_algo;
1288 };
1289
1290 float time;
1291 size_t memory;
1292
1293} miopenConvAlgoPerf_t;
1294
1303 typedef struct
1304{
1305 float time;
1308 size_t workspace_size;
1310 uint64_t solution_id;
1311 miopenConvAlgorithm_t algorithm;
1312
1313} miopenConvSolution_t;
1314
1330MIOPEN_EXPORT miopenStatus_t
1331 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,
1332 const miopenTensorDescriptor_t wDesc,
1333 const miopenTensorDescriptor_t xDesc,
1334 const miopenConvolutionDescriptor_t convDesc,
1335 const miopenTensorDescriptor_t yDesc,
1336 size_t* solutionCount);
1337
1361MIOPEN_EXPORT miopenStatus_t
1362 miopenConvolutionForwardGetSolution(miopenHandle_t handle,
1363 const miopenTensorDescriptor_t wDesc,
1364 const miopenTensorDescriptor_t xDesc,
1365 const miopenConvolutionDescriptor_t convDesc,
1366 const miopenTensorDescriptor_t yDesc,
1367 const size_t maxSolutionCount,
1368 size_t* solutionCount,
1369 miopenConvSolution_t* solutions);
1370
1388MIOPEN_EXPORT miopenStatus_t
1389 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,
1390 const miopenTensorDescriptor_t wDesc,
1391 const miopenTensorDescriptor_t xDesc,
1392 const miopenConvolutionDescriptor_t convDesc,
1393 const miopenTensorDescriptor_t yDesc,
1394 const uint64_t solution_id,
1395 size_t* workSpaceSize);
1396
1414MIOPEN_EXPORT miopenStatus_t
1415 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,
1416 const miopenTensorDescriptor_t wDesc,
1417 const miopenTensorDescriptor_t xDesc,
1418 const miopenConvolutionDescriptor_t convDesc,
1419 const miopenTensorDescriptor_t yDesc,
1420 const uint64_t solution_id);
1421
1439MIOPEN_EXPORT miopenStatus_t
1440 miopenConvolutionForwardImmediate(miopenHandle_t handle,
1441 const miopenTensorDescriptor_t wDesc,
1442 const void* w,
1443 const miopenTensorDescriptor_t xDesc,
1444 const void* x,
1445 const miopenConvolutionDescriptor_t convDesc,
1446 const miopenTensorDescriptor_t yDesc,
1447 void* y,
1448 void* workSpace,
1449 size_t workSpaceSize,
1450 const uint64_t solution_id);
1451
1469MIOPEN_EXPORT miopenStatus_t
1470 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,
1471 const miopenTensorDescriptor_t dyDesc,
1472 const miopenTensorDescriptor_t wDesc,
1473 const miopenConvolutionDescriptor_t convDesc,
1474 const miopenTensorDescriptor_t dxDesc,
1475 size_t* solutionCount);
1476
1501MIOPEN_EXPORT miopenStatus_t
1502 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,
1503 const miopenTensorDescriptor_t dyDesc,
1504 const miopenTensorDescriptor_t wDesc,
1505 const miopenConvolutionDescriptor_t convDesc,
1506 const miopenTensorDescriptor_t dxDesc,
1507 const size_t maxSolutionCount,
1508 size_t* solutionCount,
1509 miopenConvSolution_t* solutions);
1510
1528MIOPEN_EXPORT miopenStatus_t
1529 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,
1530 const miopenTensorDescriptor_t dyDesc,
1531 const miopenTensorDescriptor_t wDesc,
1532 const miopenConvolutionDescriptor_t convDesc,
1533 const miopenTensorDescriptor_t dxDesc,
1534 const uint64_t solution_id,
1535 size_t* workSpaceSize);
1536
1555MIOPEN_EXPORT miopenStatus_t
1556 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,
1557 const miopenTensorDescriptor_t dyDesc,
1558 const miopenTensorDescriptor_t wDesc,
1559 const miopenConvolutionDescriptor_t convDesc,
1560 const miopenTensorDescriptor_t dxDesc,
1561 const uint64_t solution_id);
1562
1580MIOPEN_EXPORT miopenStatus_t
1581 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,
1582 const miopenTensorDescriptor_t dyDesc,
1583 const void* dy,
1584 const miopenTensorDescriptor_t wDesc,
1585 const void* w,
1586 const miopenConvolutionDescriptor_t convDesc,
1587 const miopenTensorDescriptor_t dxDesc,
1588 void* dx,
1589 void* workSpace,
1590 size_t workSpaceSize,
1591 const uint64_t solution_id);
1592
1610MIOPEN_EXPORT miopenStatus_t
1611 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,
1612 const miopenTensorDescriptor_t dyDesc,
1613 const miopenTensorDescriptor_t xDesc,
1614 const miopenConvolutionDescriptor_t convDesc,
1615 const miopenTensorDescriptor_t dwDesc,
1616 size_t* solutionCount);
1617
1641MIOPEN_EXPORT miopenStatus_t
1642 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,
1643 const miopenTensorDescriptor_t dyDesc,
1644 const miopenTensorDescriptor_t xDesc,
1645 const miopenConvolutionDescriptor_t convDesc,
1646 const miopenTensorDescriptor_t dwDesc,
1647 const size_t maxSolutionCount,
1648 size_t* solutionCount,
1649 miopenConvSolution_t* solutions);
1650
1668MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(
1669 miopenHandle_t handle,
1670 const miopenTensorDescriptor_t dyDesc,
1671 const miopenTensorDescriptor_t xDesc,
1672 const miopenConvolutionDescriptor_t convDesc,
1673 const miopenTensorDescriptor_t dwDesc,
1674 const uint64_t solution_id,
1675 size_t* workSpaceSize);
1676
1694MIOPEN_EXPORT miopenStatus_t
1695 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,
1696 const miopenTensorDescriptor_t dyDesc,
1697 const miopenTensorDescriptor_t xDesc,
1698 const miopenConvolutionDescriptor_t convDesc,
1699 const miopenTensorDescriptor_t dwDesc,
1700 const uint64_t solution_id);
1701
1720MIOPEN_EXPORT miopenStatus_t
1721 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,
1722 const miopenTensorDescriptor_t dyDesc,
1723 const void* dy,
1724 const miopenTensorDescriptor_t xDesc,
1725 const void* x,
1726 const miopenConvolutionDescriptor_t convDesc,
1727 const miopenTensorDescriptor_t dwDesc,
1728 void* dw,
1729 void* workSpace,
1730 size_t workSpaceSize,
1731 const uint64_t solution_id);
1732
1759MIOPEN_EXPORT miopenStatus_t
1760 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,
1761 const miopenTensorDescriptor_t wDesc,
1762 const miopenTensorDescriptor_t xDesc,
1763 const miopenConvolutionDescriptor_t convDesc,
1764 const miopenTensorDescriptor_t yDesc,
1765 size_t* workSpaceSize);
1766
1810MIOPEN_EXPORT miopenStatus_t
1811 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,
1812 const miopenTensorDescriptor_t xDesc,
1813 const void* x,
1814 const miopenTensorDescriptor_t wDesc,
1815 const void* w,
1816 const miopenConvolutionDescriptor_t convDesc,
1817 const miopenTensorDescriptor_t yDesc,
1818 void* y,
1819 const int requestAlgoCount,
1820 int* returnedAlgoCount,
1821 miopenConvAlgoPerf_t* perfResults,
1822 void* workSpace,
1823 size_t workSpaceSize,
1824 bool exhaustiveSearch);
1825
1860MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,
1861 const void* alpha,
1862 const miopenTensorDescriptor_t xDesc,
1863 const void* x,
1864 const miopenTensorDescriptor_t wDesc,
1865 const void* w,
1866 const miopenConvolutionDescriptor_t convDesc,
1867 miopenConvFwdAlgorithm_t algo,
1868 const void* beta,
1869 const miopenTensorDescriptor_t yDesc,
1870 void* y,
1871 void* workSpace,
1872 size_t workSpaceSize);
1873
1889MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,
1890 const void* alpha,
1891 const miopenTensorDescriptor_t bDesc,
1892 const void* b,
1893 const void* beta,
1894 const miopenTensorDescriptor_t yDesc,
1895 void* y);
1896
1924MIOPEN_EXPORT miopenStatus_t
1925 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,
1926 const miopenTensorDescriptor_t dyDesc,
1927 const miopenTensorDescriptor_t wDesc,
1928 const miopenConvolutionDescriptor_t convDesc,
1929 const miopenTensorDescriptor_t dxDesc,
1930 size_t* workSpaceSize);
1931
1975MIOPEN_EXPORT miopenStatus_t
1976 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,
1977 const miopenTensorDescriptor_t dyDesc,
1978 const void* dy,
1979 const miopenTensorDescriptor_t wDesc,
1980 const void* w,
1981 const miopenConvolutionDescriptor_t convDesc,
1982 const miopenTensorDescriptor_t dxDesc,
1983 void* dx,
1984 const int requestAlgoCount,
1985 int* returnedAlgoCount,
1986 miopenConvAlgoPerf_t* perfResults,
1987 void* workSpace,
1988 size_t workSpaceSize,
1989 bool exhaustiveSearch);
1990
2024MIOPEN_EXPORT miopenStatus_t
2025 miopenConvolutionBackwardData(miopenHandle_t handle,
2026 const void* alpha,
2027 const miopenTensorDescriptor_t dyDesc,
2028 const void* dy,
2029 const miopenTensorDescriptor_t wDesc,
2030 const void* w,
2031 const miopenConvolutionDescriptor_t convDesc,
2032 miopenConvBwdDataAlgorithm_t algo,
2033 const void* beta,
2034 const miopenTensorDescriptor_t dxDesc,
2035 void* dx,
2036 void* workSpace,
2037 size_t workSpaceSize);
2038
2066MIOPEN_EXPORT miopenStatus_t
2067 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,
2068 const miopenTensorDescriptor_t dyDesc,
2069 const miopenTensorDescriptor_t xDesc,
2070 const miopenConvolutionDescriptor_t convDesc,
2071 const miopenTensorDescriptor_t dwDesc,
2072 size_t* workSpaceSize);
2073
2117MIOPEN_EXPORT miopenStatus_t
2118 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,
2119 const miopenTensorDescriptor_t dyDesc,
2120 const void* dy,
2121 const miopenTensorDescriptor_t xDesc,
2122 const void* x,
2123 const miopenConvolutionDescriptor_t convDesc,
2124 const miopenTensorDescriptor_t dwDesc,
2125 void* dw,
2126 const int requestAlgoCount,
2127 int* returnedAlgoCount,
2128 miopenConvAlgoPerf_t* perfResults,
2129 void* workSpace,
2130 size_t workSpaceSize,
2131 bool exhaustiveSearch);
2132
2166MIOPEN_EXPORT miopenStatus_t
2167 miopenConvolutionBackwardWeights(miopenHandle_t handle,
2168 const void* alpha,
2169 const miopenTensorDescriptor_t dyDesc,
2170 const void* dy,
2171 const miopenTensorDescriptor_t xDesc,
2172 const void* x,
2173 const miopenConvolutionDescriptor_t convDesc,
2174 miopenConvBwdWeightsAlgorithm_t algo,
2175 const void* beta,
2176 const miopenTensorDescriptor_t dwDesc,
2177 void* dw,
2178 void* workSpace,
2179 size_t workSpaceSize);
2180
2196MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,
2197 const void* alpha,
2198 const miopenTensorDescriptor_t dyDesc,
2199 const void* dy,
2200 const void* beta,
2201 const miopenTensorDescriptor_t dbDesc,
2202 void* db);
2203
2205// CLOSEOUT CONVOLUTIONS DOXYGEN GROUP
2206
2207// Pooling APIs
2212
2218MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);
2219
2228MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2229 miopenIndexType_t index_type);
2230
2238MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
2239 miopenIndexType_t* index_type);
2240
2248MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(
2249 miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);
2250
2257MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(
2258 miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);
2259
2274MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2275 miopenPoolingMode_t mode,
2276 int windowHeight,
2277 int windowWidth,
2278 int pad_h,
2279 int pad_w,
2280 int stride_h,
2281 int stride_w);
2282
2297MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2298 miopenPoolingMode_t* mode,
2299 int* windowHeight,
2300 int* windowWidth,
2301 int* pad_h,
2302 int* pad_w,
2303 int* stride_h,
2304 int* stride_w);
2305
2320MIOPEN_EXPORT miopenStatus_t
2321 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2322 const miopenTensorDescriptor_t tensorDesc,
2323 int* n,
2324 int* c,
2325 int* h,
2326 int* w);
2327
2343MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
2344 const miopenPoolingMode_t mode,
2345 int nbDims,
2346 const int* windowDimA,
2347 const int* padA,
2348 const int* stridesA);
2349
2366MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
2367 int nbDimsRequested,
2368 miopenPoolingMode_t* mode,
2369 int* nbDims,
2370 int* windowDimA,
2371 int* padA,
2372 int* stridesA);
2373
2386MIOPEN_EXPORT miopenStatus_t
2387 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
2388 const miopenTensorDescriptor_t tensorDesc,
2389 int dims,
2390 int* tensorDimArr);
2391
2404MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2405 size_t* workSpaceSize);
2406
2419MIOPEN_EXPORT miopenStatus_t
2420 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,
2421 const miopenTensorDescriptor_t yDesc,
2422 size_t* workSpaceSize);
2423
2444MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,
2445 const miopenPoolingDescriptor_t poolDesc,
2446 const void* alpha,
2447 const miopenTensorDescriptor_t xDesc,
2448 const void* x,
2449 const void* beta,
2450 const miopenTensorDescriptor_t yDesc,
2451 void* y,
2452 bool do_backward,
2453 void* workSpace,
2454 size_t workSpaceSize);
2455
2476MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,
2477 const miopenPoolingDescriptor_t poolDesc,
2478 const void* alpha,
2479 const miopenTensorDescriptor_t yDesc,
2480 const void* y,
2481 const miopenTensorDescriptor_t dyDesc,
2482 const void* dy,
2483 const miopenTensorDescriptor_t xDesc,
2484 const void* x,
2485 const void* beta,
2486 const miopenTensorDescriptor_t dxDesc,
2487 void* dx,
2488 void* workSpace);
2489
2495MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);
2496
2498// CLOSEOUT POOLING DOXYGEN GROUP
2499
2500// LRN APIs
2510MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);
2511
2525MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2526 miopenLRNMode_t mode,
2527 unsigned int lrnN,
2528 double lrnAlpha,
2529 double lrnBeta,
2530 double lrnK);
2531
2544MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
2545 miopenLRNMode_t* mode,
2546 unsigned int* lrnN,
2547 double* lrnAlpha,
2548 double* lrnBeta,
2549 double* lrnK);
2550
2560MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
2561 size_t* workSpaceSize);
2562
2581MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,
2582 const miopenLRNDescriptor_t lrnDesc,
2583 const void* alpha,
2584 const miopenTensorDescriptor_t xDesc,
2585 const void* x,
2586 const void* beta,
2587 const miopenTensorDescriptor_t yDesc,
2588 void* y,
2589 bool do_backward,
2590 void* workSpace);
2591
2609MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,
2610 const miopenLRNDescriptor_t lrnDesc,
2611 const void* alpha,
2612 const miopenTensorDescriptor_t yDesc,
2613 const void* y,
2614 const miopenTensorDescriptor_t dyDesc,
2615 const void* dy,
2616 const miopenTensorDescriptor_t xDesc,
2617 const void* x,
2618 const void* beta,
2619 const miopenTensorDescriptor_t dxDesc,
2620 void* dx,
2621 const void* workSpace);
2622
2628MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);
2629
2631// CLOSEOUT LRN DOXYGEN GROUP
2632
2633#ifdef MIOPEN_BETA_API
2634// LayerNorm APIs
2659MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,
2660 miopenNormMode_t mode,
2661 const miopenTensorDescriptor_t xDesc,
2662 const void* x,
2663 const miopenTensorDescriptor_t weightDesc,
2664 const void* weight,
2665 const miopenTensorDescriptor_t biasDesc,
2666 const void* bias,
2667 const float epsilon,
2668 const int32_t normalized_dim,
2669 const miopenTensorDescriptor_t yDesc,
2670 void* y,
2671 const miopenTensorDescriptor_t meanDesc,
2672 void* mean,
2673 const miopenTensorDescriptor_t rstdDesc,
2674 void* rstd);
2675
2693MIOPEN_EXPORT miopenStatus_t
2694 miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle,
2695 miopenNormMode_t mode,
2696 const miopenTensorDescriptor_t dyDesc,
2697 const miopenTensorDescriptor_t xDesc,
2698 const miopenTensorDescriptor_t weightDesc,
2699 const miopenTensorDescriptor_t meanDesc,
2700 const miopenTensorDescriptor_t rstdDesc,
2701 const int32_t normalized_dim,
2702 const miopenTensorDescriptor_t dxDesc,
2703 const miopenTensorDescriptor_t dwDesc,
2704 const miopenTensorDescriptor_t dbDesc,
2705 size_t* sizeInBytes);
2706
2732MIOPEN_EXPORT miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle,
2733 miopenNormMode_t mode,
2734 void* workspace,
2735 size_t workspaceSizeInBytes,
2736 const miopenTensorDescriptor_t dyDesc,
2737 const void* dy,
2738 const miopenTensorDescriptor_t xDesc,
2739 const void* x,
2740 const miopenTensorDescriptor_t weightDesc,
2741 const void* weight,
2742 const miopenTensorDescriptor_t meanDesc,
2743 const void* mean,
2744 const miopenTensorDescriptor_t rstdDesc,
2745 const void* rstd,
2746 const int32_t normalized_dim,
2747 const miopenTensorDescriptor_t dxDesc,
2748 void* dx,
2749 const miopenTensorDescriptor_t dwDesc,
2750 void* dw,
2751 const miopenTensorDescriptor_t dbDesc,
2752 void* db);
2753
2755// CLOSEOUT LAYERNORM DOXYGEN GROUP
2756#endif
2757
2758#ifdef MIOPEN_BETA_API
2759// Cat APIs
2775MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,
2776 const int32_t xCount,
2777 const miopenTensorDescriptor_t* xDescs,
2778 const void* const* xs,
2779 const miopenTensorDescriptor_t yDesc,
2780 void* y,
2781 const int32_t dim);
2782
2784// CLOSEOUT CAT DOXYGEN GROUP
2785#endif
2786
2787// Batch-Normalization APIs
2792
2809MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,
2810 const miopenTensorDescriptor_t xDesc,
2811 miopenBatchNormMode_t bn_mode);
2812
2851MIOPEN_EXPORT miopenStatus_t
2852 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,
2853 miopenBatchNormMode_t bn_mode,
2854 void* alpha,
2855 void* beta,
2856 const miopenTensorDescriptor_t xDesc,
2857 const void* x,
2858 const miopenTensorDescriptor_t yDesc,
2859 void* y,
2860 const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
2861 void* bnScale,
2862 void* bnBias,
2863 double expAvgFactor,
2864 void* resultRunningMean,
2865 void* resultRunningVariance,
2866 double epsilon,
2867 void* resultSaveMean,
2868 void* resultSaveInvVariance);
2909MIOPEN_EXPORT miopenStatus_t
2910 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,
2911 miopenBatchNormMode_t bn_mode,
2912 void* alpha,
2913 void* beta,
2914 const miopenTensorDescriptor_t xDesc,
2915 const void* x,
2916 const miopenTensorDescriptor_t yDesc,
2917 void* y,
2918 const miopenTensorDescriptor_t scaleDesc,
2919 const miopenTensorDescriptor_t biasVarDesc,
2920 const miopenTensorDescriptor_t savedMeanDesc,
2921 const miopenTensorDescriptor_t savedVarDesc,
2922 void* bnScale,
2923 void* bnBias,
2924 double expAvgFactor,
2925 void* resultRunningMean,
2926 void* resultRunningVariance,
2927 double epsilon,
2928 void* resultSaveMean,
2929 void* resultSaveInvVariance);
2971MIOPEN_EXPORT miopenStatus_t
2972 miopenBatchNormForwardTrainingActivation(miopenHandle_t handle,
2973 miopenBatchNormMode_t bn_mode,
2974 void* alpha,
2975 void* beta,
2976 const miopenTensorDescriptor_t xDesc,
2977 const void* x,
2978 const miopenTensorDescriptor_t yDesc,
2979 void* y,
2980 const miopenTensorDescriptor_t scaleDesc,
2981 const miopenTensorDescriptor_t biasVarDesc,
2982 const miopenTensorDescriptor_t savedMeanDesc,
2983 const miopenTensorDescriptor_t savedVarDesc,
2984 void* bnScale,
2985 void* bnBias,
2986 double expAvgFactor,
2987 void* resultRunningMean,
2988 void* resultRunningVariance,
2989 double epsilon,
2990 void* resultSaveMean,
2991 void* resultSaveInvVariance,
2992 const miopenActivationDescriptor_t activDesc);
2993
3023MIOPEN_EXPORT miopenStatus_t
3024 miopenBatchNormalizationForwardInference(miopenHandle_t handle,
3025 miopenBatchNormMode_t bn_mode,
3026 void* alpha,
3027 void* beta,
3028 const miopenTensorDescriptor_t xDesc,
3029 const void* x,
3030 const miopenTensorDescriptor_t yDesc,
3031 void* y,
3032 const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,
3033 void* bnScale,
3034 void* bnBias,
3035 void* estimatedMean,
3036 void* estimatedVariance,
3037 double epsilon);
3038
3070MIOPEN_EXPORT miopenStatus_t
3071 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,
3072 miopenBatchNormMode_t bn_mode,
3073 void* alpha,
3074 void* beta,
3075 const miopenTensorDescriptor_t xDesc,
3076 const void* x,
3077 const miopenTensorDescriptor_t yDesc,
3078 void* y,
3079 const miopenTensorDescriptor_t scaleDesc,
3080 const miopenTensorDescriptor_t biasDesc,
3081 const miopenTensorDescriptor_t estMeanDesc,
3082 const miopenTensorDescriptor_t estVarianceDesc,
3083 void* bnScale,
3084 void* bnBias,
3085 void* estimatedMean,
3086 void* estimatedVariance,
3087 double epsilon);
3088
3121MIOPEN_EXPORT miopenStatus_t
3122 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,
3123 miopenBatchNormMode_t bn_mode,
3124 void* alpha,
3125 void* beta,
3126 const miopenTensorDescriptor_t xDesc,
3127 const void* x,
3128 const miopenTensorDescriptor_t yDesc,
3129 void* y,
3130 const miopenTensorDescriptor_t scaleDesc,
3131 const miopenTensorDescriptor_t biasDesc,
3132 const miopenTensorDescriptor_t estMeanDesc,
3133 const miopenTensorDescriptor_t estVarianceDesc,
3134 void* bnScale,
3135 void* bnBias,
3136 void* estimatedMean,
3137 void* estimatedVariance,
3138 double epsilon,
3139 const miopenActivationDescriptor_t activDesc);
3140
3175MIOPEN_EXPORT miopenStatus_t
3176 miopenBatchNormalizationBackward(miopenHandle_t handle,
3177 miopenBatchNormMode_t bn_mode,
3178 const void* alphaDataDiff,
3179 const void* betaDataDiff,
3180 const void* alphaParamDiff,
3181 const void* betaParamDiff,
3182 const miopenTensorDescriptor_t xDesc,
3183 const void* x,
3184 const miopenTensorDescriptor_t dyDesc,
3185 const void* dy,
3186 const miopenTensorDescriptor_t dxDesc,
3187 void* dx,
3188 const miopenTensorDescriptor_t bnScaleBiasDiffDesc,
3189 const void* bnScale,
3190 void* resultBnScaleDiff,
3191 void* resultBnBiasDiff,
3192 double epsilon,
3193 const void* savedMean,
3194 const void* savedInvVariance);
3195
3234MIOPEN_EXPORT miopenStatus_t
3235 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,
3236 miopenBatchNormMode_t bn_mode,
3237 const void* alphaDataDiff,
3238 const void* betaDataDiff,
3239 const void* alphaParamDiff,
3240 const void* betaParamDiff,
3241 const miopenTensorDescriptor_t xDesc,
3242 const void* x,
3243 const miopenTensorDescriptor_t dyDesc,
3244 const void* dy,
3245 const miopenTensorDescriptor_t dxDesc,
3246 void* dx,
3247 const miopenTensorDescriptor_t scaleDesc,
3248 const miopenTensorDescriptor_t biasDesc,
3249 const miopenTensorDescriptor_t savedMeanDesc,
3250 const miopenTensorDescriptor_t savedVarDesc,
3251 const void* bnScale,
3252 void* resultBnScaleDiff,
3253 void* resultBnBiasDiff,
3254 double epsilon,
3255 const void* savedMean,
3256 const void* savedInvVariance);
3257
3298MIOPEN_EXPORT miopenStatus_t
3299 miopenBatchNormBackwardActivation(miopenHandle_t handle,
3300 miopenBatchNormMode_t bn_mode,
3301 const void* alphaDataDiff,
3302 const void* betaDataDiff,
3303 const void* alphaParamDiff,
3304 const void* betaParamDiff,
3305 const miopenTensorDescriptor_t xDesc,
3306 const void* x,
3307 const miopenTensorDescriptor_t dyDesc,
3308 const void* dy,
3309 const miopenTensorDescriptor_t dxDesc,
3310 void* dx,
3311 const miopenTensorDescriptor_t scaleDesc,
3312 const miopenTensorDescriptor_t biasDesc,
3313 const miopenTensorDescriptor_t savedMeanDesc,
3314 const miopenTensorDescriptor_t savedVarianceDesc,
3315 const void* bnScale,
3316 const void* bnBias,
3317 void* resultBnScaleDiff,
3318 void* resultBnBiasDiff,
3319 double epsilon,
3320 const void* savedMean,
3321 const void* savedInvVariance,
3322 const miopenActivationDescriptor_t activDesc);
3324// CLOSEOUT BATCHNORM DOXYGEN GROUP
3325
3326// Activation APIs
3336MIOPEN_EXPORT miopenStatus_t
3337 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);
3338
3350MIOPEN_EXPORT miopenStatus_t
3351 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3352 miopenActivationMode_t mode,
3353 double activAlpha,
3354 double activBeta,
3355 double activGamma);
3356
3368MIOPEN_EXPORT miopenStatus_t
3369 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
3370 miopenActivationMode_t* mode,
3371 double* activAlpha,
3372 double* activBeta,
3373 double* activGamma);
3374
3387MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,
3388 const miopenActivationDescriptor_t activDesc,
3389 const void* alpha,
3390 const miopenTensorDescriptor_t xDesc,
3391 const void* x,
3392 const void* beta,
3393 const miopenTensorDescriptor_t yDesc,
3394 void* y);
3395
3412MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,
3413 const miopenActivationDescriptor_t activDesc,
3414 const void* alpha,
3415 const miopenTensorDescriptor_t yDesc,
3416 const void* y,
3417 const miopenTensorDescriptor_t dyDesc,
3418 const void* dy,
3419 const miopenTensorDescriptor_t xDesc,
3420 const void* x,
3421 const void* beta,
3422 const miopenTensorDescriptor_t dxDesc,
3423 void* dx);
3424
3430MIOPEN_EXPORT miopenStatus_t
3431 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);
3432
3434// CLOSEOUT ACTIVATION DOXYGEN GROUP
3435
3436#ifdef MIOPEN_BETA_API
3441
3452MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,
3453 const miopenTensorDescriptor_t inputDesc,
3454 const void* input,
3455 const miopenTensorDescriptor_t outputDesc,
3456 void* output,
3457 const uint32_t dim);
3458
3471MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,
3472 const miopenTensorDescriptor_t inputDesc,
3473 const void* input,
3474 const miopenTensorDescriptor_t outputGradDesc,
3475 const void* outputGrad,
3476 const miopenTensorDescriptor_t inputGradDesc,
3477 void* inputGrad,
3478 const uint32_t dim);
3479
3481// CLOSEOUT ACTIVATION DOXYGEN GROUP
3482#endif // MIOPEN_BETA_API
3483
3484// Softmax APIs
3502MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,
3503 const void* alpha,
3504 const miopenTensorDescriptor_t xDesc,
3505 const void* x,
3506 const void* beta,
3507 const miopenTensorDescriptor_t yDesc,
3508 void* y);
3509
3525MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,
3526 const void* alpha,
3527 const miopenTensorDescriptor_t yDesc,
3528 const void* y,
3529 const miopenTensorDescriptor_t dyDesc,
3530 const void* dy,
3531 const void* beta,
3532 const miopenTensorDescriptor_t dxDesc,
3533 void* dx);
3534
3548MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,
3549 const void* alpha,
3550 const miopenTensorDescriptor_t xDesc,
3551 const void* x,
3552 const void* beta,
3553 const miopenTensorDescriptor_t yDesc,
3554 void* y,
3555 miopenSoftmaxAlgorithm_t algorithm,
3556 miopenSoftmaxMode_t mode);
3557
3573MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,
3574 const void* alpha,
3575 const miopenTensorDescriptor_t yDesc,
3576 const void* y,
3577 const miopenTensorDescriptor_t dyDesc,
3578 const void* dy,
3579 const void* beta,
3580 const miopenTensorDescriptor_t dxDesc,
3581 void* dx,
3582 miopenSoftmaxAlgorithm_t algorithm,
3583 miopenSoftmaxMode_t mode);
3584
3586// CLOSEOUT SOFTMAX DOXYGEN GROUP
3587
3591 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);
3592 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);
3593 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);
3594
3599
3603 typedef enum
3604{
3605 miopenVerticalFusion = 0,
3606 miopenHorizontalFusion = 1,
3607} miopenFusionDirection_t;
3608
3616MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,
3617 const miopenFusionDirection_t fuseDirection,
3618 const miopenTensorDescriptor_t inputDesc);
3619
3625MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);
3626
3633MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,
3634 miopenFusionPlanDescriptor_t fusePlanDesc);
3635
3646MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,
3647 const int op_idx,
3648 miopenFusionOpDescriptor_t* op);
3649
3657MIOPEN_EXPORT miopenStatus_t
3658 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,
3659 miopenFusionPlanDescriptor_t fusePlanDesc,
3660 size_t* workSpaceSize,
3661 miopenConvFwdAlgorithm_t algo);
3662
3680MIOPEN_EXPORT miopenStatus_t
3681 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,
3682 const int requestAlgoCount,
3683 int* returnedAlgoCount,
3684 miopenConvFwdAlgorithm_t* returnedAlgos);
3685
3695MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(
3696 miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);
3697
3706MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3707 miopenFusionOpDescriptor_t* convOp,
3708 miopenConvolutionDescriptor_t convDesc,
3709 const miopenTensorDescriptor_t wDesc);
3710
3711//---
3712
3713// Activation forward create ops ---
3721MIOPEN_EXPORT miopenStatus_t
3722 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3723 miopenFusionOpDescriptor_t* activFwdOp,
3724 miopenActivationMode_t mode);
3725
3726// Activation backward create ops ---
3734MIOPEN_EXPORT miopenStatus_t
3735 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3736 miopenFusionOpDescriptor_t* activBwdOp,
3737 miopenActivationMode_t mode);
3738
3739// Bias create ops ---
3747MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3748 miopenFusionOpDescriptor_t* biasOp,
3749 const miopenTensorDescriptor_t bDesc);
3750
3751// Batch normalization create ops ---
3760MIOPEN_EXPORT miopenStatus_t
3761 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,
3762 miopenFusionOpDescriptor_t* bnOp,
3763 const miopenBatchNormMode_t bn_mode,
3764 const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);
3765
3775MIOPEN_EXPORT miopenStatus_t
3776 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,
3777 miopenFusionOpDescriptor_t* bnFwdOp,
3778 const miopenBatchNormMode_t bn_mode,
3779 bool runningMeanVariance);
3780
3788MIOPEN_EXPORT miopenStatus_t
3789 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
3790 miopenFusionOpDescriptor_t* bnBwdOp,
3791 const miopenBatchNormMode_t bn_mode);
3792
3793//---
3799MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);
3800
3806MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);
3807
3808// Convolution set arguments ---
3818MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,
3819 const miopenFusionOpDescriptor_t convOp,
3820 const void* alpha,
3821 const void* beta,
3822 const void* w);
3823// Activation set arguments ---
3835MIOPEN_EXPORT miopenStatus_t
3836 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,
3837 const miopenFusionOpDescriptor_t activFwdOp,
3838 const void* alpha,
3839 const void* beta,
3840 double activAlpha,
3841 double activBeta,
3842 double activGamma);
3843
3857MIOPEN_EXPORT miopenStatus_t
3858 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,
3859 const miopenFusionOpDescriptor_t activBwdOp,
3860 const void* alpha,
3861 const void* beta,
3862 const void* y,
3863 const void* reserved,
3864 double activAlpha,
3865 double activBeta,
3866 double activGamma);
3867
3868// Batch Normalization set arguments ---
3882MIOPEN_EXPORT miopenStatus_t
3883 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,
3884 const miopenFusionOpDescriptor_t bnOp,
3885 const void* alpha,
3886 const void* beta,
3887 const void* bnScale,
3888 const void* bnBias,
3889 const void* estimatedMean,
3890 const void* estimatedVariance,
3891 double epsilon);
3892
3909MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,
3910 const miopenFusionOpDescriptor_t bnOp,
3911 const void* alpha,
3912 const void* beta,
3913 const void* bnScale,
3914 const void* bnBias,
3915 void* savedMean,
3916 void* savedInvVariance,
3917 void* runningMean,
3918 void* runningVariance,
3919 double expAvgFactor,
3920 double epsilon);
3921
3937MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,
3938 const miopenFusionOpDescriptor_t bnOp,
3939 const void* alpha,
3940 const void* beta,
3941 const void* x,
3942 const void* bnScale,
3943 const void* bnBias,
3944 void* resultBnScaleDiff,
3945 void* resultBnBiasDiff,
3946 const void* savedMean,
3947 const void* savedInvVariance);
3948
3949// Bias forward set arguments ---
3959MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,
3960 const miopenFusionOpDescriptor_t biasOp,
3961 const void* alpha,
3962 const void* beta,
3963 const void* bias);
3964
3979MIOPEN_EXPORT miopenStatus_t
3980 miopenExecuteFusionPlan(const miopenHandle_t handle,
3981 const miopenFusionPlanDescriptor_t fusePlanDesc,
3982 const miopenTensorDescriptor_t inputDesc,
3983 const void* input,
3984 const miopenTensorDescriptor_t outputDesc,
3985 void* output,
3986 miopenOperatorArgs_t args);
3987
4002MIOPEN_EXPORT miopenStatus_t
4003 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,
4004 const miopenFusionPlanDescriptor_t fusePlanDesc,
4005 const miopenTensorDescriptor_t inputDesc,
4006 const void* input,
4007 const miopenTensorDescriptor_t outputDesc,
4008 void* output,
4009 miopenOperatorArgs_t args,
4010 void* workspace,
4011 size_t workspaceSize);
4012
4035
4036MIOPEN_EXPORT miopenStatus_t
4037 miopenConvolutionBiasActivationForward(miopenHandle_t handle,
4038 const void* alpha1,
4039 const miopenTensorDescriptor_t xDesc,
4040 const void* x,
4041 const miopenTensorDescriptor_t wDesc,
4042 const void* w,
4043 const miopenConvolutionDescriptor_t convDesc,
4044 miopenConvFwdAlgorithm_t algo,
4045 void* workspace,
4046 size_t workspaceSizeInBytes,
4047 const void* alpha2,
4048 const miopenTensorDescriptor_t zDesc,
4049 const void* z,
4050 const miopenTensorDescriptor_t biasDesc,
4051 const void* bias,
4052 const miopenActivationDescriptor_t activationDesc,
4053 const miopenTensorDescriptor_t yDesc,
4054 void* y);
4056// CLOSEOUT FUSION DOXYGEN GROUP
4057
4062
4066 typedef enum
4067{
4068 miopenRNNRELU = 0,
4069 miopenRNNTANH = 1,
4070 miopenLSTM = 2,
4071 miopenGRU = 3,
4072} miopenRNNMode_t;
4073
4077 typedef enum
4078{
4079 miopenRNNlinear = 0,
4080 miopenRNNskip = 1,
4081} miopenRNNInputMode_t;
4082
4086 typedef enum
4087{
4088 miopenRNNdefault = 0,
4090 miopenRNNfundamental = 1,
4092 miopenRNNroundedDynamic = 2,
4094} miopenRNNAlgo_t;
4095
4099 typedef enum
4100{
4101 miopenRNNunidirection = 0,
4102 miopenRNNbidirection = 1,
4103} miopenRNNDirectionMode_t;
4104
4108 typedef enum
4109{
4110 miopenRNNNoBias = 0,
4111 miopenRNNwithBias = 1,
4112} miopenRNNBiasMode_t;
4113
4117 typedef enum
4118{
4119 miopenRNNAlgoGEMM = 0,
4120} miopenRNNGEMMalgoMode_t;
4121
4125 typedef enum
4126{
4127 miopenRNNIONotPadded = 0,
4128 miopenRNNIOWithPadding = 1,
4129} miopenRNNPaddingMode_t;
4130
4134 typedef enum
4135{
4136 miopenRNNTraining = 0,
4137 miopenRNNInference = 1,
4138} miopenRNNFWDMode_t;
4139
4143 typedef enum
4144{
4145 miopenRNNDataUnknownLayout = 0,
4146 miopenRNNDataSeqMajorNotPadded = 1,
4147 miopenRNNDataSeqMajorPadded = 2,
4148 miopenRNNDataBatchMajorPadded = 3,
4149} miopenRNNBaseLayout_t;
4150
4157MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);
4158
4171MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
4172 miopenRNNMode_t* rnnMode,
4173 miopenRNNAlgo_t* algoMode,
4174 miopenRNNInputMode_t* inputMode,
4175 miopenRNNDirectionMode_t* dirMode,
4176 miopenRNNBiasMode_t* biasMode,
4177 int* hiddenSize,
4178 int* layer);
4179
4196MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
4197 int* hiddenSize,
4198 int* layer,
4199 miopenDropoutDescriptor_t* dropoutDesc,
4200 miopenRNNInputMode_t* inputMode,
4201 miopenRNNDirectionMode_t* dirMode,
4202 miopenRNNMode_t* rnnMode,
4203 miopenRNNBiasMode_t* biasMode,
4204 miopenRNNAlgo_t* algoMode,
4205 miopenDataType_t* dataType);
4206
4212MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);
4213
4229MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,
4230 const int hsize,
4231 const int nlayers,
4232 miopenRNNInputMode_t inMode,
4233 miopenRNNDirectionMode_t direction,
4234 miopenRNNMode_t rnnMode,
4235 miopenRNNBiasMode_t biasMode,
4236 miopenRNNAlgo_t algo,
4237 miopenDataType_t dataType);
4238
4257MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,
4258 const int hsize,
4259 const int nlayers,
4260 miopenDropoutDescriptor_t dropoutDesc,
4261 miopenRNNInputMode_t inMode,
4262 miopenRNNDirectionMode_t direction,
4263 miopenRNNMode_t rnnMode,
4264 miopenRNNBiasMode_t biasMode,
4265 miopenRNNAlgo_t algo,
4266 miopenDataType_t dataType);
4267
4282MIOPEN_EXPORT miopenStatus_t
4283 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
4284 miopenDataType_t dataType,
4285 miopenRNNBaseLayout_t layout,
4286 int maxSequenceLen,
4287 int batchSize,
4288 int vectorSize,
4289 const int* sequenceLenArray,
4290 void* paddingMarker);
4291
4309
4310MIOPEN_EXPORT miopenStatus_t
4311 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
4312 miopenDataType_t* dataType,
4313 miopenRNNBaseLayout_t* layout,
4314 int* maxSequenceLen,
4315 int* batchSize,
4316 int* vectorSize,
4317 int sequenceLenArrayLimit,
4318 int* sequenceLenArray,
4319 void* paddingMarker);
4320
4337MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,
4338 const miopenRNNDescriptor_t rnnDesc,
4339 const int sequenceLen,
4340 const miopenTensorDescriptor_t* xDesc,
4341 size_t* numBytes);
4342
4359MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,
4360 miopenRNNDescriptor_t rnnDesc,
4361 const int sequenceLen,
4362 const miopenTensorDescriptor_t* xDesc,
4363 size_t* numBytes);
4364
4381MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,
4382 miopenRNNDescriptor_t rnnDesc,
4383 miopenSeqTensorDescriptor_t xDesc,
4384 miopenRNNFWDMode_t fwdMode,
4385 size_t* workSpaceSize,
4386 size_t* reserveSpaceSize);
4387
4400MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,
4401 miopenRNNDescriptor_t rnnDesc,
4402 miopenTensorDescriptor_t xDesc,
4403 size_t* numBytes,
4404 miopenDataType_t dtype);
4405
4418MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,
4419 miopenRNNDescriptor_t rnnDesc,
4420 miopenTensorDescriptor_t xDesc,
4421 miopenTensorDescriptor_t wDesc,
4422 miopenDataType_t dtype);
4423
4441MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,
4442 miopenRNNDescriptor_t rnnDesc,
4443 const int seqLen,
4444 miopenTensorDescriptor_t* xDesc,
4445 size_t* numBytes);
4446
4459MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,
4460 miopenRNNDescriptor_t rnnDesc,
4461 const int seqLen,
4462 miopenTensorDescriptor_t* xDesc,
4463 size_t* numBytes);
4464
4505MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,
4506 miopenRNNDescriptor_t rnnDesc,
4507 const int layer,
4508 miopenTensorDescriptor_t xDesc,
4509 const int paramID,
4510 size_t* numBytes);
4511
4549MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,
4550 miopenRNNDescriptor_t rnnDesc,
4551 const int layer,
4552 const int biasID,
4553 size_t* numBytes);
4554
4613MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,
4614 miopenRNNDescriptor_t rnnDesc,
4615 const int layer,
4616 miopenTensorDescriptor_t xDesc,
4617 miopenTensorDescriptor_t wDesc,
4618 const void* w,
4619 const int paramID,
4620 miopenTensorDescriptor_t paramDesc,
4621 void* layerParam);
4622
4680MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,
4681 miopenRNNDescriptor_t rnnDesc,
4682 const int layer,
4683 miopenTensorDescriptor_t xDesc,
4684 miopenTensorDescriptor_t wDesc,
4685 const void* w,
4686 const int biasID,
4687 miopenTensorDescriptor_t biasDesc,
4688 void* layerBias);
4689
4744MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,
4745 const int layer,
4746 miopenTensorDescriptor_t xDesc,
4747 const int paramID,
4748 miopenTensorDescriptor_t paramDesc,
4749 size_t* layerParamOffset);
4750
4801MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,
4802 const int layer,
4803 miopenTensorDescriptor_t xDesc,
4804 const int biasID,
4805 miopenTensorDescriptor_t biasDesc,
4806 size_t* layerBiasOffset);
4807
4860MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,
4861 miopenRNNDescriptor_t rnnDesc,
4862 const int layer,
4863 miopenTensorDescriptor_t xDesc,
4864 miopenTensorDescriptor_t wDesc,
4865 void* w,
4866 const int paramID,
4867 miopenTensorDescriptor_t paramDesc,
4868 const void* layerParam);
4869
4920MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,
4921 miopenRNNDescriptor_t rnnDesc,
4922 const int layer,
4923 miopenTensorDescriptor_t xDesc,
4924 miopenTensorDescriptor_t wDesc,
4925 void* w,
4926 const int biasID,
4927 miopenTensorDescriptor_t biasDesc,
4928 const void* layerBias);
4929
4941MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
4942 miopenRNNPaddingMode_t paddingMode);
4943
4950
4951MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
4952 miopenRNNPaddingMode_t* paddingMode);
4953
5004MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,
5005 const miopenRNNDescriptor_t rnnDesc,
5006 miopenRNNFWDMode_t fwdMode,
5007 const miopenSeqTensorDescriptor_t xDesc,
5008 const void* x,
5009 const miopenTensorDescriptor_t hDesc,
5010 const void* hx,
5011 void* hy,
5012 const miopenTensorDescriptor_t cDesc,
5013 const void* cx,
5014 void* cy,
5015 const miopenSeqTensorDescriptor_t yDesc,
5016 void* y,
5017 const void* w,
5018 size_t weightSpaceSize,
5019 void* workSpace,
5020 size_t workSpaceNumBytes,
5021 void* reserveSpace,
5022 size_t reserveSpaceNumBytes);
5023
5073MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,
5074 const miopenRNNDescriptor_t rnnDesc,
5075 const miopenSeqTensorDescriptor_t yDesc,
5076 const void* y,
5077 const void* dy,
5078 const miopenTensorDescriptor_t hDesc,
5079 const void* hx,
5080 const void* dhy,
5081 void* dhx,
5082 const miopenTensorDescriptor_t cDesc,
5083 const void* cx,
5084 const void* dcy,
5085 void* dcx,
5086 const miopenSeqTensorDescriptor_t xDesc,
5087 void* dx,
5088 const void* w,
5089 size_t weightSpaceSize,
5090 void* workSpace,
5091 size_t workSpaceNumBytes,
5092 void* reserveSpace,
5093 size_t reserveSpaceNumBytes);
5094
5128MIOPEN_EXPORT miopenStatus_t
5129 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,
5130 const miopenRNNDescriptor_t rnnDesc,
5131 const miopenSeqTensorDescriptor_t xDesc,
5132 const void* x,
5133 const miopenTensorDescriptor_t hDesc,
5134 const void* hx,
5135 const miopenSeqTensorDescriptor_t yDesc,
5136 const void* y,
5137 void* dw,
5138 size_t weightSpaceSize,
5139 void* workSpace,
5140 size_t workSpaceNumBytes,
5141 const void* reserveSpace,
5142 size_t reserveSpaceNumBytes);
5143
5201MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,
5202 const miopenRNNDescriptor_t rnnDesc,
5203 const int sequenceLen,
5204 const miopenTensorDescriptor_t* xDesc,
5205 const void* x,
5206 const miopenTensorDescriptor_t hxDesc,
5207 const void* hx,
5208 const miopenTensorDescriptor_t cxDesc,
5209 const void* cx,
5210 const miopenTensorDescriptor_t wDesc,
5211 const void* w,
5212 const miopenTensorDescriptor_t* yDesc,
5213 void* y,
5214 const miopenTensorDescriptor_t hyDesc,
5215 void* hy,
5216 const miopenTensorDescriptor_t cyDesc,
5217 void* cy,
5218 void* workSpace,
5219 size_t workSpaceNumBytes,
5220 void* reserveSpace,
5221 size_t reserveSpaceNumBytes);
5222
5295MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,
5296 const miopenRNNDescriptor_t rnnDesc,
5297 const int sequenceLen,
5298 const miopenTensorDescriptor_t* yDesc,
5299 const void* y,
5300 const miopenTensorDescriptor_t* dyDesc,
5301 const void* dy,
5302 const miopenTensorDescriptor_t dhyDesc,
5303 const void* dhy,
5304 const miopenTensorDescriptor_t dcyDesc,
5305 const void* dcy,
5306 const miopenTensorDescriptor_t wDesc,
5307 const void* w,
5308 const miopenTensorDescriptor_t hxDesc,
5309 const void* hx,
5310 const miopenTensorDescriptor_t cxDesc,
5311 const void* cx,
5312 const miopenTensorDescriptor_t* dxDesc,
5313 void* dx,
5314 const miopenTensorDescriptor_t dhxDesc,
5315 void* dhx,
5316 const miopenTensorDescriptor_t dcxDesc,
5317 void* dcx,
5318 void* workSpace,
5319 size_t workSpaceNumBytes,
5320 void* reserveSpace,
5321 size_t reserveSpaceNumBytes);
5322
5359MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,
5360 const miopenRNNDescriptor_t rnnDesc,
5361 const int sequenceLen,
5362 const miopenTensorDescriptor_t* xDesc,
5363 const void* x,
5364 const miopenTensorDescriptor_t hxDesc,
5365 const void* hx,
5366 const miopenTensorDescriptor_t* yDesc,
5367 const void* y,
5368 const miopenTensorDescriptor_t dwDesc,
5369 void* dw,
5370 void* workSpace,
5371 size_t workSpaceNumBytes,
5372 const void* reserveSpace,
5373 size_t reserveSpaceNumBytes);
5374
5430MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,
5431 miopenRNNDescriptor_t rnnDesc,
5432 const int sequenceLen,
5433 const miopenTensorDescriptor_t* xDesc,
5434 const void* x,
5435 const miopenTensorDescriptor_t hxDesc,
5436 const void* hx,
5437 const miopenTensorDescriptor_t cxDesc,
5438 const void* cx,
5439 const miopenTensorDescriptor_t wDesc,
5440 const void* w,
5441 const miopenTensorDescriptor_t* yDesc,
5442 void* y,
5443 const miopenTensorDescriptor_t hyDesc,
5444 void* hy,
5445 const miopenTensorDescriptor_t cyDesc,
5446 void* cy,
5447 void* workSpace,
5448 size_t workSpaceNumBytes);
5449
5451// CLOSEOUT RNN DOXYGEN GROUP
5452
5457
5461 typedef enum
5462{
5463 MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,
5464} miopenCTCLossAlgo_t;
5465
5472MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);
5473
5483MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5484 miopenDataType_t* dataType,
5485 int* blank_label_id,
5486 bool* apply_softmax_layer);
5487
5493MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);
5494
5504MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
5505 miopenDataType_t dataType,
5506 const int blank_label_id,
5507 bool apply_softmax_layer);
5508
5525MIOPEN_EXPORT miopenStatus_t
5526 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,
5527 const miopenTensorDescriptor_t probsDesc,
5528 const miopenTensorDescriptor_t gradientsDesc,
5529 const int* labels,
5530 const int* labelLengths,
5531 const int* inputLengths,
5532 miopenCTCLossAlgo_t algo,
5533 const miopenCTCLossDescriptor_t ctcLossDesc,
5534 size_t* workSpaceSize);
5535
5555MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,
5556 const miopenTensorDescriptor_t probsDesc,
5557 const void* probs,
5558 const int* labels,
5559 const int* labelLengths,
5560 const int* inputLengths,
5561 void* losses,
5562 const miopenTensorDescriptor_t gradientsDesc,
5563 void* gradients,
5564 miopenCTCLossAlgo_t algo,
5565 const miopenCTCLossDescriptor_t ctcLossDesc,
5566 void* workSpace,
5567 size_t workSpaceSize);
5568
5570// CLOSEOUT LossFunction DOXYGEN GROUP
5571
5572// Dropout APIs
5577
5581 typedef enum
5582{
5583 MIOPEN_RNG_PSEUDO_XORWOW = 0,
5584} miopenRNGType_t;
5585
5591MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);
5592
5598MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);
5599
5608MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,
5609 size_t* reserveSpaceSizeInBytes);
5610
5619MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,
5620 size_t* stateSizeInBytes);
5621
5638MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5639 miopenHandle_t handle,
5640 float* dropout,
5641 void** states,
5642 unsigned long long* seed,
5643 bool* use_mask,
5644 bool* state_evo,
5645 miopenRNGType_t* rng_mode);
5646
5669MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5670 miopenHandle_t handle,
5671 float dropout,
5672 void* states,
5673 size_t stateSizeInBytes,
5674 unsigned long long seed,
5675 bool use_mask,
5676 bool state_evo,
5677 miopenRNGType_t rng_mode);
5678
5698MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,
5699 miopenHandle_t handle,
5700 float dropout,
5701 void* states,
5702 size_t stateSizeInBytes,
5703 unsigned long long seed,
5704 bool use_mask,
5705 bool state_evo,
5706 miopenRNGType_t rng_mode);
5707
5725MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,
5726 const miopenDropoutDescriptor_t dropoutDesc,
5727 const miopenTensorDescriptor_t noise_shape,
5728 const miopenTensorDescriptor_t xDesc,
5729 const void* x,
5730 const miopenTensorDescriptor_t yDesc,
5731 void* y,
5732 void* reserveSpace,
5733 size_t reserveSpaceSizeInBytes);
5734
5752MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,
5753 const miopenDropoutDescriptor_t dropoutDesc,
5754 const miopenTensorDescriptor_t noise_shape,
5755 const miopenTensorDescriptor_t dyDesc,
5756 const void* dy,
5757 const miopenTensorDescriptor_t dxDesc,
5758 void* dx,
5759 void* reserveSpace,
5760 size_t reserveSpaceSizeInBytes);
5761
5763// CLOSEOUT DROPOUT DOXYGEN GROUP
5764
5765// TensorReduce APIs
5770
5776MIOPEN_EXPORT miopenStatus_t
5777 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);
5778
5784MIOPEN_EXPORT miopenStatus_t
5785 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);
5786
5799MIOPEN_EXPORT miopenStatus_t
5800 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,
5801 miopenReduceTensorOp_t reduceTensorOp,
5802 miopenDataType_t reduceTensorCompType,
5803 miopenNanPropagation_t reduceTensorNanOpt,
5804 miopenReduceTensorIndices_t reduceTensorIndices,
5805 miopenIndicesType_t reduceTensorIndicesType);
5806
5822MIOPEN_EXPORT miopenStatus_t
5823 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,
5824 miopenReduceTensorOp_t* reduceTensorOp,
5825 miopenDataType_t* reduceTensorCompType,
5826 miopenNanPropagation_t* reduceTensorNanOpt,
5827 miopenReduceTensorIndices_t* reduceTensorIndices,
5828 miopenIndicesType_t* reduceTensorIndicesType);
5829
5839MIOPEN_EXPORT miopenStatus_t
5840 miopenGetReductionIndicesSize(miopenHandle_t handle,
5841 const miopenReduceTensorDescriptor_t reduceTensorDesc,
5842 const miopenTensorDescriptor_t aDesc,
5843 const miopenTensorDescriptor_t cDesc,
5844 size_t* sizeInBytes);
5845
5855MIOPEN_EXPORT miopenStatus_t
5856 miopenGetReductionWorkspaceSize(miopenHandle_t handle,
5857 const miopenReduceTensorDescriptor_t reduceTensorDesc,
5858 const miopenTensorDescriptor_t aDesc,
5859 const miopenTensorDescriptor_t cDesc,
5860 size_t* sizeInBytes);
5861
5885MIOPEN_EXPORT miopenStatus_t
5886 miopenReduceTensor(miopenHandle_t handle,
5887 const miopenReduceTensorDescriptor_t reduceTensorDesc,
5888 void* indices,
5889 size_t indicesSizeInBytes,
5890 void* workspace,
5891 size_t workspaceSizeInBytes,
5892 const void* alpha,
5893 const miopenTensorDescriptor_t aDesc,
5894 const void* A,
5895 const void* beta,
5896 const miopenTensorDescriptor_t cDesc,
5897 void* C);
5898
5900// CLOSEOUT TensorReduce DOXYGEN GROUP
5901
5902// Find 2.0 API
5907
5913 MIOPEN_DECLARE_OBJECT(miopenProblem);
5914
5918 typedef enum
5919{
5920 miopenProblemDirectionForward = 0,
5921 miopenProblemDirectionBackward = 1,
5922 miopenProblemDirectionBackwardWeights = 2,
5923#ifdef MIOPEN_BETA_API
5924 miopenProblemDirectionInference = 4,
5925#endif
5926} miopenProblemDirection_t;
5927
5931 typedef enum
5932{
5933 miopenTensorArgumentIdInvalid = 0,
5934 miopenTensorConvolutionX = 1,
5935 miopenTensorConvolutionW = 2,
5936 miopenTensorConvolutionY = 3,
5937
5938 miopenTensorMhaK = 4,
5939 miopenTensorMhaQ = 5,
5940 miopenTensorMhaV = 6,
5941 miopenTensorMhaDescaleK = 7,
5942 miopenTensorMhaDescaleQ = 8,
5943 miopenTensorMhaDescaleV = 9,
5944 miopenTensorMhaDescaleS = 10,
5945 miopenTensorMhaScaleS = 11,
5946 miopenTensorMhaScaleO = 12,
5947 miopenTensorMhaDropoutProbability = 13,
5948 miopenTensorMhaDropoutSeed = 14,
5949 miopenTensorMhaDropoutOffset = 15,
5950 miopenTensorMhaO = 16,
5951 miopenTensorMhaAmaxO = 17,
5952 miopenTensorMhaAmaxS = 18,
5953 miopenTensorMhaM = 19,
5954 miopenTensorMhaZInv = 20,
5955 miopenTensorMhaDO = 21,
5956 miopenTensorMhaDescaleO = 22,
5957 miopenTensorMhaDescaleDO = 23,
5958 miopenTensorMhaDescaleDS = 24,
5959 miopenTensorMhaScaleDS = 25,
5960 miopenTensorMhaScaleDQ = 26,
5961 miopenTensorMhaScaleDK = 27,
5962 miopenTensorMhaScaleDV = 28,
5963 miopenTensorMhaDQ = 29,
5964 miopenTensorMhaDK = 30,
5965 miopenTensorMhaDV = 31,
5966 miopenTensorMhaAmaxDQ = 32,
5967 miopenTensorMhaAmaxDK = 33,
5968 miopenTensorMhaAmaxDV = 34,
5969 miopenTensorMhaAmaxDS = 35,
5970 miopenTensorMhaBias = 36,
5971
5972#ifdef MIOPEN_BETA_API
5973 miopenTensorActivationX = 37,
5974 miopenTensorActivationY = 38,
5975 miopenTensorActivationDX = 39,
5976 miopenTensorActivationDY = 40,
5977 miopenTensorBiasX = 41,
5978 miopenTensorBiasY = 42,
5979 miopenTensorBias = 43,
5980 miopenTensorSoftmaxX = 44,
5981 miopenTensorSoftmaxY = 45,
5982 miopenTensorSoftmaxDX = 46,
5983 miopenTensorSoftmaxDY = 47,
5984 miopenTensorBatchnormX = 48,
5985 miopenTensorBatchnormY = 49,
5986 miopenTensorBatchnormRunningMean = 50,
5987 miopenTensorBatchnormRunningVariance = 51,
5988 miopenTensorBatchnormSavedMean = 52,
5989 miopenTensorBatchnormSavedVariance = 53,
5990 miopenTensorBatchnormScale = 54,
5991 miopenTensorBatchnormScaleDiff = 55,
5992 miopenTensorBatchnormEstimatedMean = 56,
5993 miopenTensorBatchnormEstimatedVariance = 57,
5994 miopenTensorBatchnormBias = 58,
5995 miopenTensorBatchnormBiasDiff = 59,
5996 miopenTensorBatchnormDX = 60,
5997 miopenTensorBatchnormDY = 61,
5998#endif
5999
6000 miopenTensorArgumentIsScalar = 1U << 31,
6001
6002 miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,
6003#ifdef MIOPEN_BETA_API
6004 miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,
6005 miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,
6006#endif
6007} miopenTensorArgumentId_t;
6008
6012 typedef enum
6013{
6014 miopenFindResultsOrderByTime = 0,
6015 miopenFindResultsOrderByWorkspaceSize = 1,
6016} miopenFindResultsOrder_t;
6017
6025MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,
6026 miopenConvolutionDescriptor_t operatorDesc,
6027 miopenProblemDirection_t direction);
6028
6036
6040 typedef enum
6041{
6042 miopenMhaMaskNone = 0,
6043 miopenMhaMaskCausal = 1,
6044} miopenMhaMask_t;
6045
6046MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,
6047 miopenMhaDescriptor_t operatorDesc,
6048 miopenProblemDirection_t direction);
6049
6055
6056MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);
6057
6066
6067MIOPEN_EXPORT miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale);
6068
6077
6078MIOPEN_EXPORT miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float* scale);
6079
6085
6086MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);
6087
6099MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,
6100 float alpha,
6101 float beta,
6102 miopenSoftmaxAlgorithm_t algorithm,
6103 miopenSoftmaxMode_t mode);
6104
6116MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,
6117 float* alpha,
6118 float* beta,
6119 miopenSoftmaxAlgorithm_t* algorithm,
6120 miopenSoftmaxMode_t* mode);
6121
6127MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);
6128
6136MIOPEN_EXPORT miopenStatus_t
6137 miopenSetProblemTensorDescriptor(miopenProblem_t problem,
6138 miopenTensorArgumentId_t id,
6139 const miopenTensorDescriptor_t descriptor);
6140
6143 MIOPEN_DECLARE_OBJECT(miopenFindOptions);
6144
6150MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);
6151
6157MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);
6158
6165MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value);
6166
6173MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,
6174 miopenFindResultsOrder_t value);
6175
6183MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,
6184 size_t value);
6185
6193MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,
6194 void* buffer,
6195 size_t size);
6196
6205MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,
6206 miopenTensorArgumentId_t id,
6207 void* buffer);
6208
6216MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,
6217 unsigned attach);
6218
6221 MIOPEN_DECLARE_OBJECT(miopenSolution);
6222
6234MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,
6235 miopenProblem_t problem,
6236 miopenFindOptions_t options,
6237 miopenSolution_t* solutions,
6238 size_t* numSolutions,
6239 size_t maxSolutions);
6240
6243 struct miopenTensorArgument_t
6244{
6245 /* @brief Identifier of the tensor argument.
6246 */
6247 miopenTensorArgumentId_t id;
6248 /* @brief Tensor descriptor to override the value stored in the solution.
6249 *
6250 * Some solvers may support overriding input and output tensor descriptors, but right now there
6251 * is no way to tell from the API. Intended for the future use.
6252 */
6253 miopenTensorDescriptor_t* descriptor;
6254 /* @brief Pointer to the device memory buffer to use for the operation or to the host memory if
6255 * the value is scalar.
6256 */
6257 void* buffer;
6258};
6259
6271MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,
6272 miopenSolution_t solution,
6273 size_t nInputs,
6274 const miopenTensorArgument_t* tensors,
6275 void* workspace,
6276 size_t workspaceSize);
6277
6283MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);
6284
6292MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,
6293 const char* data,
6294 size_t size);
6295
6302MIOPEN_EXPORT miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data);
6303
6310MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size);
6311
6318MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,
6319 size_t* workspaceSize);
6320
6327MIOPEN_EXPORT miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time);
6328
6335MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,
6336 uint64_t* solverId);
6337
6344MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,
6345 miopenConvAlgorithm_t* result);
6346
6347#ifdef MIOPEN_BETA_API
6348
6357MIOPEN_EXPORT miopenStatus_t
6358 miopenCreateActivationProblem(miopenProblem_t* problem,
6359 miopenActivationDescriptor_t operatorDesc,
6360 miopenProblemDirection_t direction);
6361
6370MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,
6371 miopenBatchNormMode_t mode,
6372 bool runningMeanVariance,
6373 miopenProblemDirection_t direction);
6374
6394MIOPEN_EXPORT miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2);
6395
6403MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,
6404 miopenProblemDirection_t direction);
6405
6413
6414MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,
6415 miopenSoftmaxDescriptor_t operatorDesc,
6416 miopenProblemDirection_t direction);
6417
6418#endif
6419
6421// CLOSEOUT find2 DOXYGEN GROUP
6422
6423#ifdef MIOPEN_BETA_API
6424
6429 typedef enum
6430{
6431 MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,
6432 MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =
6433 1,
6434} miopenReduceCalculationNanPropagation_t;
6435
6436// ReduceCalculation APIs
6441
6445 typedef enum
6446{
6447 MIOPEN_REDUCE_CALCULATION_PROD =
6448 1,
6449 MIOPEN_REDUCE_CALCULATION_SUM =
6450 2,
6451} miopenReduceCalculationOp_t;
6452
6462MIOPEN_EXPORT miopenStatus_t
6463 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,
6464 const miopenTensorDescriptor_t xDesc,
6465 const int32_t dim,
6466 const miopenReduceCalculationOp_t reduceCalculationOp,
6467 const miopenTensorDescriptor_t reduceDesc,
6468 size_t* sizeInBytes);
6469
6483MIOPEN_EXPORT miopenStatus_t
6484 miopenReduceCalculationForward(miopenHandle_t handle,
6485 miopenReduceCalculationNanPropagation_t nanPropagation,
6486 void* workspace,
6487 size_t workspaceSizeInBytes,
6488 const miopenTensorDescriptor_t xDesc,
6489 const void* x,
6490 const int32_t dim,
6491 const miopenReduceCalculationOp_t reduceCalculationOp,
6492 const miopenTensorDescriptor_t reduceDesc,
6493 void* y);
6494
6496// CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP
6497#endif // MIOPEN_BETA_API
6498
6499#ifdef MIOPEN_BETA_API
6500
6505 typedef enum
6506{
6507 MIOPEN_REDUCE_EXTREME_ARGMIN =
6508 1,
6509 MIOPEN_REDUCE_EXTREME_ARGMAX =
6510 2,
6511 MIOPEN_REDUCE_EXTREME_MIN =
6512 3,
6513 MIOPEN_REDUCE_EXTREME_MAX =
6514 4,
6515} miopenReduceExtremeOp_t;
6516
6517// ReduceExtreme APIs
6522
6537MIOPEN_EXPORT miopenStatus_t
6538 miopenReduceExtremeForward(miopenHandle_t handle,
6539 const miopenTensorDescriptor_t xDesc,
6540 const void* x,
6541 const int32_t dim,
6542 const miopenReduceExtremeOp_t reduceExtremeOp,
6543 const miopenTensorDescriptor_t yDesc,
6544 void* y,
6545 const miopenTensorDescriptor_t indiceDesc,
6546 void* indice);
6547
6549// CLOSEOUT REDUCEEXTREME DOXYGEN GROUP
6550#endif // MIOPEN_BETA_API
6551
6552#ifdef MIOPEN_BETA_API
6553// GroupNorm APIs
6578MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,
6579 miopenNormMode_t mode,
6580 const miopenTensorDescriptor_t xDesc,
6581 const void* x,
6582 const miopenTensorDescriptor_t weightDesc,
6583 const void* weight,
6584 const miopenTensorDescriptor_t biasDesc,
6585 const void* bias,
6586 const uint64_t num_groups,
6587 const float epsilon,
6588 const miopenTensorDescriptor_t yDesc,
6589 void* y,
6590 const miopenTensorDescriptor_t meanDesc,
6591 void* mean,
6592 const miopenTensorDescriptor_t rstdDesc,
6593 void* rstd);
6594
6596// CLOSEOUT groupnorm DOXYGEN GROUP
6597#endif // MIOPEN_BETA_API
6598
6599#ifdef MIOPEN_BETA_API
6600// LayerNorm APIs
6627MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,
6628 miopenNormMode_t mode,
6629 const miopenTensorDescriptor_t xDesc,
6630 const void* x,
6631 const miopenTensorDescriptor_t x2Desc,
6632 const void* x2,
6633 const miopenTensorDescriptor_t weightDesc,
6634 const void* weight,
6635 const miopenTensorDescriptor_t biasDesc,
6636 const void* bias,
6637 const float epsilon,
6638 const int32_t normalized_dim,
6639 const miopenTensorDescriptor_t yDesc,
6640 void* y,
6641 const miopenTensorDescriptor_t meanDesc,
6642 void* mean,
6643 const miopenTensorDescriptor_t rstdDesc,
6644 void* rstd);
6645
6647// CLOSEOUT LAYERNORM DOXYGEN GROUP
6648#endif // MIOPEN_BETA_API
6649
6650#ifdef MIOPEN_BETA_API
6651// LayerNorm APIs
6671MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,
6672 miopenNormMode_t mode,
6673 const miopenTensorDescriptor_t xDesc,
6674 const void* x,
6675 const miopenTensorDescriptor_t weightDesc,
6676 const void* weight,
6677 const float epsilon,
6678 const miopenTensorDescriptor_t yDesc,
6679 void* y,
6680 const miopenTensorDescriptor_t rstdDesc,
6681 void* rstd);
6682
6697MIOPEN_EXPORT miopenStatus_t
6698 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,
6699 miopenNormMode_t mode,
6700 const miopenTensorDescriptor_t dyDesc,
6701 const miopenTensorDescriptor_t xDesc,
6702 const miopenTensorDescriptor_t weightDesc,
6703 const miopenTensorDescriptor_t rstdDesc,
6704 const miopenTensorDescriptor_t dxDesc,
6705 const miopenTensorDescriptor_t dwDesc,
6706 size_t* sizeInBytes);
6707
6728MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,
6729 miopenNormMode_t mode,
6730 void* workspace,
6731 size_t workspaceSizeInBytes,
6732 const miopenTensorDescriptor_t dyDesc,
6733 const void* dy,
6734 const miopenTensorDescriptor_t xDesc,
6735 const void* x,
6736 const miopenTensorDescriptor_t weightDesc,
6737 const void* weight,
6738 const miopenTensorDescriptor_t rstdDesc,
6739 const void* rstd,
6740 const miopenTensorDescriptor_t dxDesc,
6741 void* dx,
6742 const miopenTensorDescriptor_t dwDesc,
6743 void* dw);
6745// CLOSEOUT LAYERNORM DOXYGEN GROUP
6746#endif // MIOPEN_BETA_API
6747
6748#ifdef MIOPEN_BETA_API
6749// Graph API
6754
6761 typedef enum
6762{
6763 MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,
6764 MIOPEN_BACKEND_ENGINE_DESCRIPTOR,
6765 MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,
6766 MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,
6767 MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,
6768 MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,
6769 MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,
6770 MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,
6771 MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,
6772 MIOPEN_BACKEND_MATMUL_DESCRIPTOR,
6773 MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,
6774 MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,
6775 MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,
6776 MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
6777 MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,
6778 MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,
6779 MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,
6780 MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,
6781 MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,
6782 MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,
6783 MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,
6784 MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,
6785 MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,
6786 MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,
6787 MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,
6788 MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,
6789 MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,
6790 MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,
6791 MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,
6792 MIOPEN_BACKEND_RNG_DESCRIPTOR,
6793 MIOPEN_BACKEND_TENSOR_DESCRIPTOR,
6794 MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,
6795} miopenBackendDescriptorType_t;
6796
6804 typedef enum
6805{
6806 MIOPEN_ATTR_POINTWISE_MODE = 0,
6807 MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,
6808 MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,
6809 MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,
6810 MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,
6811 MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,
6812 MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,
6813 MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,
6814 MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,
6815 MIOPEN_ATTR_POINTWISE_AXIS = 9,
6816
6817 MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,
6818 MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,
6819 MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,
6820 MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,
6821 MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,
6822 MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,
6823 MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,
6824
6825 MIOPEN_ATTR_ENGINEHEUR_MODE = 200,
6826 MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,
6827 MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,
6828 MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,
6829
6830 MIOPEN_ATTR_ENGINECFG_ENGINE = 300,
6831 MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,
6832 MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,
6833
6834 MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,
6835 MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,
6836 MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,
6837 MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,
6838 MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,
6839 MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,
6840
6841 MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,
6842 MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,
6843 MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,
6844 MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,
6845
6846 MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,
6847 MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,
6848
6849 MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,
6850 MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,
6851 MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,
6852 MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,
6853 MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,
6854 MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,
6855 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,
6856 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,
6857 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,
6858 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,
6859 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,
6860 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,
6861 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,
6862 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,
6863 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,
6864 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,
6865 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,
6866 MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,
6867 MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,
6868 MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,
6869 MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,
6870 MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,
6871 MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,
6872 MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,
6873 MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,
6874 MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,
6875 MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,
6876
6877 MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,
6878 MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,
6879 MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,
6880 MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,
6881 MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,
6882
6883 MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,
6884 MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,
6885 MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,
6886 MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,
6887 MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,
6888 MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,
6889 MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,
6890 MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,
6891 MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,
6892 MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,
6893 MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,
6894 MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,
6895 MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,
6896 MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,
6897 MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,
6898 MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,
6899 MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,
6900
6901 MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,
6902 MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,
6903 MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,
6904
6905 MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,
6906 MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,
6907 MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,
6908 MIOPEN_ATTR_TENSOR_STRIDES = 903,
6909 MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,
6910 MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,
6911 MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,
6912 MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,
6913 MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,
6914 MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,
6915 MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,
6916
6917 MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,
6918 MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,
6919 MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,
6920 MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,
6921
6922 MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,
6923 MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,
6924
6925 MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,
6926 MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,
6927 MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,
6928 MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,
6929
6930 MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,
6931 MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,
6932 MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,
6933 MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,
6934 MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,
6935 MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,
6936 MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,
6937
6938 MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,
6939 MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,
6940
6941 MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,
6942 MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,
6943 MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,
6944 MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,
6945 MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,
6946 MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,
6947 MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,
6948 MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,
6949
6950 MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,
6951 MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,
6952
6953 MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,
6954 MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,
6955 MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,
6956
6957 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,
6958 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,
6959 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,
6960 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,
6961 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,
6962 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,
6963 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,
6964 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,
6965 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,
6966 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,
6967 MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,
6968
6969 MIOPEN_ATTR_RESAMPLE_MODE = 1700,
6970 MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,
6971 MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,
6972 MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,
6973 MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,
6974 MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,
6975 MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,
6976 MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,
6977 MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,
6978
6979 MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,
6980 MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,
6981 MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,
6982 MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,
6983 MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,
6984 MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,
6985
6986 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,
6987 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,
6988 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,
6989 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,
6990 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,
6991 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,
6992 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,
6993 MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,
6994
6995 MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,
6996 MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,
6997 MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,
6998 MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,
6999
7000 MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,
7001 MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,
7002 MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,
7003 MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,
7004 MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,
7005
7006 MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,
7007 MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,
7008 MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,
7009 MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,
7010 MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,
7011 MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,
7012 MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,
7013 MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,
7014 MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,
7015 MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,
7016 MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,
7017 MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,
7018 MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,
7019 MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,
7020 MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,
7021
7022 MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,
7023 MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,
7024 MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,
7025 MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,
7026 MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,
7027 MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,
7028 MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,
7029 MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,
7030 MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,
7031 MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,
7032 MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,
7033
7034 MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,
7035 MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,
7036
7037 MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,
7038 MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,
7039 MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,
7040 MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,
7041 MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,
7042 MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,
7043
7044 MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,
7045 MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,
7046 MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,
7047 MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,
7048
7049} miopenBackendAttributeName_t;
7050
7058 typedef enum
7059{
7060 MIOPEN_TYPE_HANDLE = 0,
7061 MIOPEN_TYPE_DATA_TYPE,
7062 MIOPEN_TYPE_BOOLEAN,
7063 MIOPEN_TYPE_INT64,
7064 MIOPEN_TYPE_FLOAT,
7065 MIOPEN_TYPE_DOUBLE,
7066 MIOPEN_TYPE_VOID_PTR,
7067 MIOPEN_TYPE_CONVOLUTION_MODE,
7068 MIOPEN_TYPE_HEUR_MODE,
7069 MIOPEN_TYPE_KNOB_TYPE,
7070 MIOPEN_TYPE_NAN_PROPOGATION,
7071 MIOPEN_TYPE_NUMERICAL_NOTE,
7072 MIOPEN_TYPE_LAYOUT_TYPE,
7073 MIOPEN_TYPE_ATTRIB_NAME,
7074 MIOPEN_TYPE_POINTWISE_MODE,
7075 MIOPEN_TYPE_BACKEND_DESCRIPTOR,
7076 MIOPEN_TYPE_GENSTATS_MODE,
7077 MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,
7078 MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,
7079 MIOPEN_TYPE_BEHAVIOR_NOTE,
7080 MIOPEN_TYPE_TENSOR_REORDERING_MODE,
7081 MIOPEN_TYPE_RESAMPLE_MODE,
7082 MIOPEN_TYPE_PADDING_MODE,
7083 MIOPEN_TYPE_INT32,
7084 MIOPEN_TYPE_CHAR,
7085 MIOPEN_TYPE_SIGNAL_MODE,
7086 MIOPEN_TYPE_FRACTION,
7087 MIOPEN_TYPE_NORM_MODE,
7088 MIOPEN_TYPE_NORM_FWD_PHASE,
7089 MIOPEN_TYPE_RNG_DISTRIBUTION
7090} miopenBackendAttributeType_t;
7091
7097 typedef enum
7098{
7100 MIOPEN_POINTWISE_ADD,
7101
7104 MIOPEN_POINTWISE_ADD_SQUARE,
7105
7107 MIOPEN_POINTWISE_DIV,
7108
7110 MIOPEN_POINTWISE_MAX,
7111
7113 MIOPEN_POINTWISE_MIN,
7114
7117 MIOPEN_POINTWISE_MOD,
7118
7120 MIOPEN_POINTWISE_MUL,
7121
7123 MIOPEN_POINTWISE_POW,
7124
7126 MIOPEN_POINTWISE_SUB,
7127
7129 MIOPEN_POINTWISE_ABS,
7130
7132 MIOPEN_POINTWISE_CEIL,
7133
7135 MIOPEN_POINTWISE_COS,
7136
7138 MIOPEN_POINTWISE_EXP,
7139
7141 MIOPEN_POINTWISE_FLOOR,
7142
7144 MIOPEN_POINTWISE_LOG,
7145
7147 MIOPEN_POINTWISE_NEG,
7148
7150 MIOPEN_POINTWISE_RSQRT,
7151
7153 MIOPEN_POINTWISE_SIN,
7154
7156 MIOPEN_POINTWISE_SQRT,
7157
7159 MIOPEN_POINTWISE_TAN,
7160
7162 MIOPEN_POINTWISE_ERF,
7163
7167 MIOPEN_POINTWISE_IDENTITY,
7168
7170 MIOPEN_POINTWISE_RELU_FWD,
7171
7173 MIOPEN_POINTWISE_TANH_FWD,
7174
7176 MIOPEN_POINTWISE_SIGMOID_FWD,
7177
7179 MIOPEN_POINTWISE_ELU_FWD,
7180
7183 MIOPEN_POINTWISE_GELU_FWD,
7184
7186 MIOPEN_POINTWISE_SOFTPLUS_FWD,
7187
7189 MIOPEN_POINTWISE_SWISH_FWD,
7190
7194 MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,
7195
7198 MIOPEN_POINTWISE_RELU_BWD,
7199
7201 MIOPEN_POINTWISE_TANH_BWD,
7202
7204 MIOPEN_POINTWISE_SIGMOID_BWD,
7205
7208 MIOPEN_POINTWISE_ELU_BWD,
7209
7212 MIOPEN_POINTWISE_GELU_BWD,
7213
7215 MIOPEN_POINTWISE_SOFTPLUS_BWD,
7216
7218 MIOPEN_POINTWISE_SWISH_BWD,
7219
7225 MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,
7226
7228 MIOPEN_POINTWISE_CMP_EQ,
7229
7231 MIOPEN_POINTWISE_CMP_NEQ,
7232
7234 MIOPEN_POINTWISE_CMP_GT,
7235
7238 MIOPEN_POINTWISE_CMP_GE,
7239
7241 MIOPEN_POINTWISE_CMP_LT,
7242
7245 MIOPEN_POINTWISE_CMP_LE,
7246
7248 MIOPEN_POINTWISE_LOGICAL_AND,
7249
7251 MIOPEN_POINTWISE_LOGICAL_OR,
7252
7254 MIOPEN_POINTWISE_LOGICAL_NOT,
7255
7257 MIOPEN_POINTWISE_GEN_INDEX,
7258
7261 MIOPEN_POINTWISE_BINARY_SELECT,
7262
7265 MIOPEN_POINTWISE_RECIPROCAL
7266} miopenPointwiseMode_t;
7267
7273 typedef enum
7274{
7275 MIOPEN_RNG_DISTRIBUTION_BERNOULLI,
7276 MIOPEN_RNG_DISTRIBUTION_UNIFORM,
7277 MIOPEN_RNG_DISTRIBUTION_NORMAL,
7278} miopenRngDistribution_t;
7279
7280 typedef enum
7281{
7282 /* IDENTITY alpha = 1.0 and beta = 0.0 */
7283 /* SCALE alpha = 4.2 and beta = 0.0 */
7284 /* BILINEAR alpha = 3.2 and beta = 1.1 */
7285 /* ERROR_STATE alpha = 0.0 and beta = 3.1 */
7286
7287 DEFAULT = 0, /* alpha = 1.0 and beta = 0.0.*/
7288 SCALE = 1, /* alpha with some value and beta 0.0*/
7289 BILINEAR = 2, /* both alpha and beta with some value*/
7290 ERROR_STATE = 3, /* alpha 0.0 and beta with some value, this should not occur.
7291 But used to check for errors.*/
7292} miopenAlphaBetaCase_t;
7293
7297 typedef enum
7298{
7299 MIOPEN_HEUR_MODE_INSTANT = 0,
7300 MIOPEN_HEUR_MODE_B = 1,
7301 MIOPEN_HEUR_MODE_FALLBACK = 2,
7302 MIOPEN_HEUR_MODE_A = 3,
7303 MIOPEN_HEUR_MODES_COUNT = 4,
7304} miopenBackendHeurMode_t;
7305
7318 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)
7319
7320
7333MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(
7334 miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);
7335
7365MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,
7366 miopenBackendAttributeName_t attributeName,
7367 miopenBackendAttributeType_t attributeType,
7368 int64_t elementCount,
7369 void* arrayOfElements);
7370
7387MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);
7388
7423MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,
7424 miopenBackendAttributeName_t attributeName,
7425 miopenBackendAttributeType_t attributeType,
7426 int64_t requestedElementCount,
7427 int64_t* elementCount,
7428 void* arrayOfElements);
7429
7449MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,
7450 miopenBackendDescriptor_t executionPlan,
7451 miopenBackendDescriptor_t variantPack);
7452
7469MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);
7470
7488MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,
7489 miopenBackendDescriptorType_t descriptorType,
7490 size_t sizeInBytes);
7491
7493// CLOSEOUT BackendAPI DOXYGEN GROUP
7494#endif // MIOPEN_BETA_API
7495
7496#ifdef MIOPEN_BETA_API
7497// FusedAdam APIs
7640MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,
7641 const miopenTensorDescriptor_t paramDesc,
7642 void* param,
7643 const miopenTensorDescriptor_t gradDesc,
7644 const void* grad,
7645 const miopenTensorDescriptor_t expAvgDesc,
7646 void* expAvg,
7647 const miopenTensorDescriptor_t expAvgSqDesc,
7648 void* expAvgSq,
7649 const miopenTensorDescriptor_t maxExpAvgSqDesc,
7650 void* maxExpAvgSq,
7651 const miopenTensorDescriptor_t stateStepDesc,
7652 void* stateStep,
7653 const unsigned int state_step,
7654 const float lr,
7655 const float beta1,
7656 const float beta2,
7657 const float weight_decay,
7658 const float eps,
7659 const bool amsgrad,
7660 const bool maximize,
7661 const bool adamw,
7662 const miopenTensorDescriptor_t gradScaleDesc,
7663 const void* gradScale,
7664 const miopenTensorDescriptor_t foundInfDesc,
7665 const void* foundInf);
7666
7807MIOPEN_EXPORT miopenStatus_t
7808 miopenFusedAdamWithOutput(miopenHandle_t handle,
7809 const miopenTensorDescriptor_t paramInDesc,
7810 void* paramIn,
7811 const miopenTensorDescriptor_t paramOutDesc,
7812 void* paramOut,
7813 const miopenTensorDescriptor_t paramOutFloat16Desc,
7814 void* paramOutFloat16,
7815 const miopenTensorDescriptor_t gradInDesc,
7816 const void* gradIn,
7817 const miopenTensorDescriptor_t expAvgInDesc,
7818 void* expAvgIn,
7819 const miopenTensorDescriptor_t expAvgOutDesc,
7820 void* expAvgOut,
7821 const miopenTensorDescriptor_t expAvgSqInDesc,
7822 void* expAvgSqIn,
7823 const miopenTensorDescriptor_t expAvgSqOutDesc,
7824 void* expAvgSqOut,
7825 const miopenTensorDescriptor_t maxExpAvgSqInDesc,
7826 void* maxExpAvgSqIn,
7827 const miopenTensorDescriptor_t maxExpAvgSqOutDesc,
7828 void* maxExpAvgSqOut,
7829 const miopenTensorDescriptor_t stateStepInDesc,
7830 void* stateStepIn,
7831 const miopenTensorDescriptor_t stateStepOutDesc,
7832 void* stateStepOut,
7833 const unsigned int state_step,
7834 const float lr,
7835 const float beta1,
7836 const float beta2,
7837 const float weight_decay,
7838 const float eps,
7839 const bool amsgrad,
7840 const bool maximize,
7841 const bool adamw,
7842 const miopenTensorDescriptor_t gradScaleDesc,
7843 const void* gradScale,
7844 const miopenTensorDescriptor_t foundInfDesc,
7845 const void* foundInf);
7846
7848// CLOSEOUT SGD DOXYGEN GROUP
7849#endif // MIOPEN_BETA_API
7850
7851#ifdef MIOPEN_BETA_API
7852// TransformersAdamW APIs
7943MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,
7944 const miopenTensorDescriptor_t paramDesc,
7945 void* param,
7946 const miopenTensorDescriptor_t gradDesc,
7947 const void* grad,
7948 const miopenTensorDescriptor_t expAvgDesc,
7949 void* expAvg,
7950 const miopenTensorDescriptor_t expAvgSqDesc,
7951 void* expAvgSq,
7952 const miopenTensorDescriptor_t stateStepDesc,
7953 void* stateStep,
7954 const unsigned int state_step,
7955 const float lr,
7956 const float beta1,
7957 const float beta2,
7958 const float weight_decay,
7959 const float eps,
7960 const bool correct_bias,
7961 const miopenTensorDescriptor_t gradScaleDesc,
7962 const void* gradScale,
7963 const miopenTensorDescriptor_t foundInfDesc,
7964 const void* foundInf);
7965
8092MIOPEN_EXPORT miopenStatus_t
8093 miopenTransformersAdamWWithOutput(miopenHandle_t handle,
8094 const miopenTensorDescriptor_t paramInDesc,
8095 void* paramIn,
8096 const miopenTensorDescriptor_t paramOutDesc,
8097 void* paramOut,
8098 const miopenTensorDescriptor_t paramOutFloat16Desc,
8099 void* paramOutFloat16,
8100 const miopenTensorDescriptor_t gradInDesc,
8101 const void* gradIn,
8102 const miopenTensorDescriptor_t expAvgInDesc,
8103 void* expAvgIn,
8104 const miopenTensorDescriptor_t expAvgOutDesc,
8105 void* expAvgOut,
8106 const miopenTensorDescriptor_t expAvgSqInDesc,
8107 void* expAvgSqIn,
8108 const miopenTensorDescriptor_t expAvgSqOutDesc,
8109 void* expAvgSqOut,
8110 const miopenTensorDescriptor_t stateStepInDesc,
8111 void* stateStepIn,
8112 const miopenTensorDescriptor_t stateStepOutDesc,
8113 void* stateStepOut,
8114 const unsigned int state_step,
8115 const float lr,
8116 const float beta1,
8117 const float beta2,
8118 const float weight_decay,
8119 const float eps,
8120 const float step_size,
8121 const bool correct_bias,
8122 const miopenTensorDescriptor_t gradScaleDesc,
8123 const void* gradScale,
8124 const miopenTensorDescriptor_t foundInfDesc,
8125 const void* foundInf);
8126
8128// CLOSEOUT SGD DOXYGEN GROUP
8129#endif // MIOPEN_BETA_API
8130
8131#ifdef MIOPEN_BETA_API
8132// GetItem APIs
8145MIOPEN_EXPORT miopenStatus_t
8146 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,
8147 uint32_t indexCount,
8148 const miopenTensorDescriptor_t* indexDescs,
8149 size_t* sizeInBytes);
8150
8175MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,
8176 void* workspace,
8177 size_t workspaceSizeInBytes,
8178 const miopenTensorDescriptor_t dyDesc,
8179 const void* dy,
8180 uint32_t indexCount,
8181 const miopenTensorDescriptor_t* indexDescs,
8182 const void* const* indexs,
8183 const miopenTensorDescriptor_t dxDesc,
8184 void* dx,
8185 const miopenTensorDescriptor_t errorDesc,
8186 void* error,
8187 uint32_t dimCount,
8188 const int32_t* dims,
8189 uint32_t sliceCount,
8190 const int32_t* slices,
8191 uint32_t offset);
8192
8194// CLOSEOUT GETITEM DOXYGEN GROUP
8195#endif // MIOPEN_BETA_API
8196
8197#ifdef MIOPEN_BETA_API
8198// RotaryPositionalEmbeddings APIs
8216MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,
8217 const miopenTensorDescriptor_t xDesc,
8218 const void* x,
8219 const miopenTensorDescriptor_t cosDesc,
8220 const void* cos,
8221 const miopenTensorDescriptor_t sinDesc,
8222 const void* sin,
8223 const miopenTensorDescriptor_t yDesc,
8224 void* y);
8225
8239MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,
8240 const miopenTensorDescriptor_t dyDesc,
8241 const void* dy,
8242 const miopenTensorDescriptor_t cosDesc,
8243 const void* cos,
8244 const miopenTensorDescriptor_t sinDesc,
8245 const void* sin,
8246 const miopenTensorDescriptor_t dxDesc,
8247 void* dx);
8249// CLOSEOUT ROPE DOXYGEN GROUP
8250// kthvalue APIs
8255
8271MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,
8272 miopenTensorDescriptor_t inputDesc,
8273 const void* input,
8274 miopenTensorDescriptor_t outputDesc,
8275 void* output,
8276 miopenTensorDescriptor_t indicesDesc,
8277 size_t* indices,
8278 size_t k,
8279 int32_t dim = -1,
8280 bool keepDim = false);
8281
8283// CLOSEOUT kthvalue DOXYGEN GROUP
8284#endif // MIOPEN_BETA_API
8285
8286#ifdef MIOPEN_BETA_API
8291
8300MIOPEN_EXPORT miopenStatus_t
8301 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,
8302 miopenTensorDescriptor_t inputDesc,
8303 miopenTensorDescriptor_t weightDesc,
8304 size_t* sizeInBytes);
8305
8322MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,
8323 void* workspace,
8324 size_t workspaceSizeInBytes,
8325 miopenTensorDescriptor_t inputDesc,
8326 const void* input,
8327 miopenTensorDescriptor_t weightDesc,
8328 const void* weight,
8329 miopenTensorDescriptor_t doutputDesc,
8330 const void* doutput,
8331 miopenTensorDescriptor_t dinputDesc,
8332 void* dinput,
8333 miopenTensorDescriptor_t dweightDesc,
8334 void* dweight);
8335
8337// CLOSEOUT RELU DOXYGEN GROUP
8338#endif // MIOPEN_BETA_API
8339
8340#ifdef MIOPEN_BETA_API
8341
8346 typedef enum
8347{
8348 MIOPEN_LOSS_REDUCTION_NONE = 0,
8349 MIOPEN_LOSS_REDUCTION_SUM = 1,
8350 MIOPEN_LOSS_REDUCTION_MEAN = 2,
8352} miopenLossReductionMode_t;
8353
8354// SoftMarginLoss APIs
8359
8372MIOPEN_EXPORT miopenStatus_t
8373 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8374 miopenTensorDescriptor_t inputDesc,
8375 miopenTensorDescriptor_t targetDesc,
8376 miopenTensorDescriptor_t outputDesc,
8377 miopenLossReductionMode_t reduction,
8378 size_t* sizeInBytes);
8379
8396MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,
8397 miopenTensorDescriptor_t inputDesc,
8398 const void* input,
8399 miopenTensorDescriptor_t targetDesc,
8400 const void* target,
8401 miopenTensorDescriptor_t outputDesc,
8402 void* output,
8403 miopenLossReductionMode_t reduction,
8404 void* workspace = nullptr,
8405 size_t workspaceSizeInBytes = 0);
8406
8421MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,
8422 miopenTensorDescriptor_t inputDesc,
8423 const void* input,
8424 miopenTensorDescriptor_t targetDesc,
8425 const void* target,
8426 miopenTensorDescriptor_t doutputDesc,
8427 const void* doutput,
8428 miopenTensorDescriptor_t dinputDesc,
8429 void* dinput,
8430 miopenLossReductionMode_t reduction);
8431
8433// CLOSEOUT LossFunction DOXYGEN GROUP
8434#endif
8435
8436#ifdef MIOPEN_BETA_API
8437// MultiMarginLoss APIs
8442
8461MIOPEN_EXPORT miopenStatus_t
8462 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,
8463 miopenTensorDescriptor_t inputDesc,
8464 miopenTensorDescriptor_t targetDesc,
8465 miopenTensorDescriptor_t weightDesc,
8466 miopenTensorDescriptor_t outputDesc,
8467 long p,
8468 float margin,
8469 miopenLossReductionMode_t reduction,
8470 size_t* sizeInBytes);
8471
8499MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,
8500 miopenTensorDescriptor_t inputDesc,
8501 const void* input,
8502 miopenTensorDescriptor_t targetDesc,
8503 const void* target,
8504 miopenTensorDescriptor_t weightDesc,
8505 const void* weight,
8506 miopenTensorDescriptor_t outputDesc,
8507 void* output,
8508 long p,
8509 float margin,
8510 miopenLossReductionMode_t reduction,
8511 void* workspace,
8512 size_t workspaceSizeInBytes);
8513
8515// CLOSEOUT LossFunction DOXYGEN GROUP
8516#endif // MIOPEN_BETA_API
8517
8529 typedef enum
8530{
8531 miopenTuningPolicyNone = 1,
8532 miopenTuningPolicyDbUpdate = 2,
8533 miopenTuningPolicySearch = 3,
8534 miopenTuningPolicySearchDbUpdate = 4,
8535 miopenTuningPolicyDbClean = 5,
8536} miopenTuningPolicy_t;
8537
8546MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,
8547 miopenTuningPolicy_t newValue);
8548
8556MIOPEN_EXPORT miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle,
8557 miopenTuningPolicy_t* value);
8558
8559#ifdef __cplusplus
8560}
8561#endif
8562
8563#ifdef __clang__
8564#pragma clang diagnostic pop
8565#endif
8566
8567#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:3604
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:3606
miopenVerticalFusion
@ miopenVerticalFusion
Definition miopen.h:3605
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:7298
miopenPointwiseMode_t
miopenPointwiseMode_t
Intended poinwise math operation for a pointwise operation descriptor.
Definition miopen.h:7098
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:6805
miopenRngDistribution_t
miopenRngDistribution_t
Distribution for random number generation.
Definition miopen.h:7274
miopenBackendDescriptorType_t
miopenBackendDescriptorType_t
Descriptor type.
Definition miopen.h:6762
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:7281
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:7059
MIOPEN_HEUR_MODE_INSTANT
@ MIOPEN_HEUR_MODE_INSTANT
Definition miopen.h:7299
MIOPEN_HEUR_MODE_A
@ MIOPEN_HEUR_MODE_A
Definition miopen.h:7302
MIOPEN_HEUR_MODE_B
@ MIOPEN_HEUR_MODE_B
Definition miopen.h:7300
MIOPEN_HEUR_MODES_COUNT
@ MIOPEN_HEUR_MODES_COUNT
Definition miopen.h:7303
MIOPEN_HEUR_MODE_FALLBACK
@ MIOPEN_HEUR_MODE_FALLBACK
Definition miopen.h:7301
MIOPEN_POINTWISE_SOFTPLUS_FWD
@ MIOPEN_POINTWISE_SOFTPLUS_FWD
Definition miopen.h:7186
MIOPEN_POINTWISE_ELU_FWD
@ MIOPEN_POINTWISE_ELU_FWD
Definition miopen.h:7179
MIOPEN_POINTWISE_RELU_FWD
@ MIOPEN_POINTWISE_RELU_FWD
Definition miopen.h:7170
MIOPEN_POINTWISE_DIV
@ MIOPEN_POINTWISE_DIV
Definition miopen.h:7107
MIOPEN_POINTWISE_SIGMOID_BWD
@ MIOPEN_POINTWISE_SIGMOID_BWD
Definition miopen.h:7204
MIOPEN_POINTWISE_POW
@ MIOPEN_POINTWISE_POW
Definition miopen.h:7123
MIOPEN_POINTWISE_MOD
@ MIOPEN_POINTWISE_MOD
Definition miopen.h:7117
MIOPEN_POINTWISE_SQRT
@ MIOPEN_POINTWISE_SQRT
Definition miopen.h:7156
MIOPEN_POINTWISE_BINARY_SELECT
@ MIOPEN_POINTWISE_BINARY_SELECT
Definition miopen.h:7261
MIOPEN_POINTWISE_GELU_BWD
@ MIOPEN_POINTWISE_GELU_BWD
Definition miopen.h:7212
MIOPEN_POINTWISE_MIN
@ MIOPEN_POINTWISE_MIN
Definition miopen.h:7113
MIOPEN_POINTWISE_CMP_NEQ
@ MIOPEN_POINTWISE_CMP_NEQ
Definition miopen.h:7231
MIOPEN_POINTWISE_FLOOR
@ MIOPEN_POINTWISE_FLOOR
Definition miopen.h:7141
MIOPEN_POINTWISE_RSQRT
@ MIOPEN_POINTWISE_RSQRT
Definition miopen.h:7150
MIOPEN_POINTWISE_CMP_EQ
@ MIOPEN_POINTWISE_CMP_EQ
Definition miopen.h:7228
MIOPEN_POINTWISE_CMP_GE
@ MIOPEN_POINTWISE_CMP_GE
Definition miopen.h:7238
MIOPEN_POINTWISE_ADD_SQUARE
@ MIOPEN_POINTWISE_ADD_SQUARE
Definition miopen.h:7104
MIOPEN_POINTWISE_ERF
@ MIOPEN_POINTWISE_ERF
Definition miopen.h:7162
MIOPEN_POINTWISE_SWISH_FWD
@ MIOPEN_POINTWISE_SWISH_FWD
Definition miopen.h:7189
MIOPEN_POINTWISE_LOG
@ MIOPEN_POINTWISE_LOG
Definition miopen.h:7144
MIOPEN_POINTWISE_SUB
@ MIOPEN_POINTWISE_SUB
Definition miopen.h:7126
MIOPEN_POINTWISE_NEG
@ MIOPEN_POINTWISE_NEG
Definition miopen.h:7147
MIOPEN_POINTWISE_LOGICAL_AND
@ MIOPEN_POINTWISE_LOGICAL_AND
Definition miopen.h:7248
MIOPEN_POINTWISE_SWISH_BWD
@ MIOPEN_POINTWISE_SWISH_BWD
Definition miopen.h:7218
MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD
Definition miopen.h:7194
MIOPEN_POINTWISE_SIN
@ MIOPEN_POINTWISE_SIN
Definition miopen.h:7153
MIOPEN_POINTWISE_RECIPROCAL
@ MIOPEN_POINTWISE_RECIPROCAL
Definition miopen.h:7265
MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD
Definition miopen.h:7225
MIOPEN_POINTWISE_GELU_FWD
@ MIOPEN_POINTWISE_GELU_FWD
Definition miopen.h:7183
MIOPEN_POINTWISE_ABS
@ MIOPEN_POINTWISE_ABS
Definition miopen.h:7129
MIOPEN_POINTWISE_CMP_LT
@ MIOPEN_POINTWISE_CMP_LT
Definition miopen.h:7241
MIOPEN_POINTWISE_EXP
@ MIOPEN_POINTWISE_EXP
Definition miopen.h:7138
MIOPEN_POINTWISE_GEN_INDEX
@ MIOPEN_POINTWISE_GEN_INDEX
Definition miopen.h:7257
MIOPEN_POINTWISE_CEIL
@ MIOPEN_POINTWISE_CEIL
Definition miopen.h:7132
MIOPEN_POINTWISE_LOGICAL_NOT
@ MIOPEN_POINTWISE_LOGICAL_NOT
Definition miopen.h:7254
MIOPEN_POINTWISE_SIGMOID_FWD
@ MIOPEN_POINTWISE_SIGMOID_FWD
Definition miopen.h:7176
MIOPEN_POINTWISE_SOFTPLUS_BWD
@ MIOPEN_POINTWISE_SOFTPLUS_BWD
Definition miopen.h:7215
MIOPEN_POINTWISE_LOGICAL_OR
@ MIOPEN_POINTWISE_LOGICAL_OR
Definition miopen.h:7251
MIOPEN_POINTWISE_TAN
@ MIOPEN_POINTWISE_TAN
Definition miopen.h:7159
MIOPEN_POINTWISE_ELU_BWD
@ MIOPEN_POINTWISE_ELU_BWD
Definition miopen.h:7208
MIOPEN_POINTWISE_IDENTITY
@ MIOPEN_POINTWISE_IDENTITY
Definition miopen.h:7167
MIOPEN_POINTWISE_CMP_LE
@ MIOPEN_POINTWISE_CMP_LE
Definition miopen.h:7245
MIOPEN_POINTWISE_COS
@ MIOPEN_POINTWISE_COS
Definition miopen.h:7135
MIOPEN_POINTWISE_TANH_BWD
@ MIOPEN_POINTWISE_TANH_BWD
Definition miopen.h:7201
MIOPEN_POINTWISE_MUL
@ MIOPEN_POINTWISE_MUL
Definition miopen.h:7120
MIOPEN_POINTWISE_TANH_FWD
@ MIOPEN_POINTWISE_TANH_FWD
Definition miopen.h:7173
MIOPEN_POINTWISE_RELU_BWD
@ MIOPEN_POINTWISE_RELU_BWD
Definition miopen.h:7198
MIOPEN_POINTWISE_ADD
@ MIOPEN_POINTWISE_ADD
Definition miopen.h:7100
MIOPEN_POINTWISE_MAX
@ MIOPEN_POINTWISE_MAX
Definition miopen.h:7110
MIOPEN_POINTWISE_CMP_GT
@ MIOPEN_POINTWISE_CMP_GT
Definition miopen.h:7234
MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE
Definition miopen.h:7022
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W
Definition miopen.h:6852
MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION
Definition miopen.h:6976
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC
Definition miopen.h:6979
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W
Definition miopen.h:6858
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA
Definition miopen.h:6849
MIOPEN_ATTR_OPERATION_SIGNAL_MODE
@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE
Definition miopen.h:7000
MIOPEN_ATTR_OPERATION_RNG_DESC
@ MIOPEN_ATTR_OPERATION_RNG_DESC
Definition miopen.h:7046
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA
Definition miopen.h:6850
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC
Definition miopen.h:6963
MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC
Definition miopen.h:7025
MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC
Definition miopen.h:7013
MIOPEN_ATTR_OPERATIONGRAPH_OPS
@ MIOPEN_ATTR_OPERATIONGRAPH_OPS
Definition miopen.h:6902
MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE
Definition miopen.h:6926
MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS
Definition miopen.h:6821
MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC
Definition miopen.h:7004
MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC
Definition miopen.h:7029
MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS
Definition miopen.h:7032
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC
Definition miopen.h:6993
MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS
Definition miopen.h:6822
MIOPEN_ATTR_REDUCTION_OPERATOR
@ MIOPEN_ATTR_REDUCTION_OPERATOR
Definition miopen.h:6950
MIOPEN_ATTR_OPERATION_MATMUL_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_DESC
Definition miopen.h:6944
MIOPEN_ATTR_CONVOLUTION_DILATIONS
@ MIOPEN_ATTR_CONVOLUTION_DILATIONS
Definition miopen.h:6819
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC
Definition miopen.h:6987
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1
Definition miopen.h:6871
MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS
Definition miopen.h:6971
MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS
Definition miopen.h:6837
MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC
Definition miopen.h:7009
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC
Definition miopen.h:6891
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC
Definition miopen.h:6959
MIOPEN_ATTR_KNOB_INFO_TYPE
@ MIOPEN_ATTR_KNOB_INFO_TYPE
Definition miopen.h:6925
MIOPEN_ATTR_LAYOUT_INFO_TYPES
@ MIOPEN_ATTR_LAYOUT_INFO_TYPES
Definition miopen.h:6923
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC
Definition miopen.h:6885
MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE
Definition miopen.h:6901
MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC
Definition miopen.h:7026
MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM
Definition miopen.h:7041
MIOPEN_ATTR_POINTWISE_MATH_PREC
@ MIOPEN_ATTR_POINTWISE_MATH_PREC
Definition miopen.h:6807
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC
Definition miopen.h:6947
MIOPEN_ATTR_OPERATION_GENSTATS_MODE
@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE
Definition miopen.h:6877
MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE
Definition miopen.h:6847
MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES
Definition miopen.h:6919
MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC
Definition miopen.h:6954
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA
Definition miopen.h:6862
MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE
Definition miopen.h:6920
MIOPEN_ATTR_TENSOR_IS_BY_VALUE
@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE
Definition miopen.h:6913
MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE
Definition miopen.h:7006
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC
Definition miopen.h:6851
MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE
Definition miopen.h:6883
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC
Definition miopen.h:7016
MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC
Definition miopen.h:7034
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC
Definition miopen.h:6992
MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC
Definition miopen.h:6868
MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS
Definition miopen.h:6917
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC
Definition miopen.h:6962
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA
Definition miopen.h:6982
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC
Definition miopen.h:6887
MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE
Definition miopen.h:7002
MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC
Definition miopen.h:7001
MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC
Definition miopen.h:6875
MIOPEN_ATTR_ENGINEHEUR_RESULTS
@ MIOPEN_ATTR_ENGINEHEUR_RESULTS
Definition miopen.h:6827
MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT
Definition miopen.h:6905
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X
Definition miopen.h:6865
MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC
Definition miopen.h:6897
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS
Definition miopen.h:6967
MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC
Definition miopen.h:6878
MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC
Definition miopen.h:7015
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC
Definition miopen.h:6895
MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE
Definition miopen.h:6834
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC
Definition miopen.h:6961
MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC
Definition miopen.h:6998
MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC
Definition miopen.h:7028
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA
Definition miopen.h:6856
MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE
Definition miopen.h:6836
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX
Definition miopen.h:6859
MIOPEN_ATTR_TENSOR_VECTOR_COUNT
@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT
Definition miopen.h:6909
MIOPEN_ATTR_OPERATION_MATMUL_CDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC
Definition miopen.h:6943
MIOPEN_ATTR_REDUCTION_COMP_TYPE
@ MIOPEN_ATTR_REDUCTION_COMP_TYPE
Definition miopen.h:6951
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA
Definition miopen.h:6990
MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION
Definition miopen.h:6910
MIOPEN_ATTR_TENSOR_DIMENSIONS
@ MIOPEN_ATTR_TENSOR_DIMENSIONS
Definition miopen.h:6907
MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC
Definition miopen.h:6880
MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX
Definition miopen.h:6997
MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2
Definition miopen.h:6872
MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE
Definition miopen.h:6933
MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE
Definition miopen.h:6935
MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION
Definition miopen.h:6839
MIOPEN_ATTR_RESAMPLE_STRIDES
@ MIOPEN_ATTR_RESAMPLE_STRIDES
Definition miopen.h:6974
MIOPEN_ATTR_POINTWISE_ELU_ALPHA
@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA
Definition miopen.h:6812
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC
Definition miopen.h:7018
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC
Definition miopen.h:6988
MIOPEN_ATTR_OPERATION_RNG_SEED
@ MIOPEN_ATTR_OPERATION_RNG_SEED
Definition miopen.h:7045
MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC
Definition miopen.h:7023
MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC
Definition miopen.h:6873
MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS
Definition miopen.h:6996
MIOPEN_ATTR_RESAMPLE_MODE
@ MIOPEN_ATTR_RESAMPLE_MODE
Definition miopen.h:6969
MIOPEN_ATTR_RNG_DISTRIBUTION
@ MIOPEN_ATTR_RNG_DISTRIBUTION
Definition miopen.h:7037
MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC
Definition miopen.h:7024
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC
Definition miopen.h:6946
MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE
Definition miopen.h:7007
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE
Definition miopen.h:6811
MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC
Definition miopen.h:7035
MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS
Definition miopen.h:6918
MIOPEN_ATTR_POINTWISE_AXIS
@ MIOPEN_ATTR_POINTWISE_AXIS
Definition miopen.h:6815
MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC
Definition miopen.h:7019
MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP
Definition miopen.h:6809
MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH
Definition miopen.h:6930
MIOPEN_ATTR_OPERATION_MATMUL_BDESC
@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC
Definition miopen.h:6942
MIOPEN_ATTR_TENSOR_DATA_TYPE
@ MIOPEN_ATTR_TENSOR_DATA_TYPE
Definition miopen.h:6906
MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC
Definition miopen.h:7003
MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE
Definition miopen.h:6927
MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC
Definition miopen.h:7012
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC
Definition miopen.h:6984
MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS
Definition miopen.h:6973
MIOPEN_ATTR_MATMUL_COMP_TYPE
@ MIOPEN_ATTR_MATMUL_COMP_TYPE
Definition miopen.h:6938
MIOPEN_ATTR_TENSOR_UNIQUE_ID
@ MIOPEN_ATTR_TENSOR_UNIQUE_ID
Definition miopen.h:6911
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC
Definition miopen.h:6965
MIOPEN_ATTR_OPERATION_CONCAT_AXIS
@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS
Definition miopen.h:6995
MIOPEN_ATTR_OPERATION_RNG_YDESC
@ MIOPEN_ATTR_OPERATION_RNG_YDESC
Definition miopen.h:7044
MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX
Definition miopen.h:6931
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC
Definition miopen.h:6857
MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH
Definition miopen.h:6826
MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC
Definition miopen.h:6915
MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA
Definition miopen.h:6813
MIOPEN_ATTR_TENSOR_IS_VIRTUAL
@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL
Definition miopen.h:6912
MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES
Definition miopen.h:6832
MIOPEN_ATTR_MATMUL_PADDING_VALUE
@ MIOPEN_ATTR_MATMUL_PADDING_VALUE
Definition miopen.h:6939
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC
Definition miopen.h:6899
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC
Definition miopen.h:6894
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X
Definition miopen.h:6853
MIOPEN_ATTR_KNOB_INFO_STRIDE
@ MIOPEN_ATTR_KNOB_INFO_STRIDE
Definition miopen.h:6928
MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS
Definition miopen.h:6975
MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC
Definition miopen.h:6870
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC
Definition miopen.h:6980
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC
Definition miopen.h:6960
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY
Definition miopen.h:6860
MIOPEN_ATTR_CONVOLUTION_CONV_MODE
@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE
Definition miopen.h:6818
MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC
Definition miopen.h:6953
MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS
Definition miopen.h:6838
MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC
Definition miopen.h:6884
MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET
Definition miopen.h:6936
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC
Definition miopen.h:6896
MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE
Definition miopen.h:6846
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC
Definition miopen.h:6986
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC
Definition miopen.h:6889
MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC
Definition miopen.h:6874
MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC
Definition miopen.h:7014
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC
Definition miopen.h:6966
MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC
Definition miopen.h:7047
MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y
Definition miopen.h:6854
MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC
Definition miopen.h:6890
MIOPEN_ATTR_ENGINE_LAYOUT_INFO
@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO
Definition miopen.h:6934
MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID
Definition miopen.h:6841
MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE
Definition miopen.h:6817
MIOPEN_ATTR_RESAMPLE_COMP_TYPE
@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE
Definition miopen.h:6970
MIOPEN_ATTR_ENGINECFG_ENGINE
@ MIOPEN_ATTR_ENGINECFG_ENGINE
Definition miopen.h:6830
MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS
Definition miopen.h:6972
MIOPEN_ATTR_RESAMPLE_PADDING_MODE
@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE
Definition miopen.h:6977
MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS
Definition miopen.h:6823
MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC
Definition miopen.h:7017
MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC
Definition miopen.h:6879
MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC
Definition miopen.h:7010
MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC
Definition miopen.h:6886
MIOPEN_ATTR_ENGINE_KNOB_INFO
@ MIOPEN_ATTR_ENGINE_KNOB_INFO
Definition miopen.h:6932
MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT
Definition miopen.h:6945
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW
Definition miopen.h:6864
MIOPEN_ATTR_TENSOR_REORDERING_MODE
@ MIOPEN_ATTR_TENSOR_REORDERING_MODE
Definition miopen.h:6914
MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE
Definition miopen.h:6842
MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC
Definition miopen.h:6948
MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR
Definition miopen.h:6867
MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION
Definition miopen.h:7039
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS
Definition miopen.h:6843
MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID
Definition miopen.h:6922
MIOPEN_ATTR_ENGINEHEUR_MODE
@ MIOPEN_ATTR_ENGINEHEUR_MODE
Definition miopen.h:6825
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA
Definition miopen.h:6989
MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC
Definition miopen.h:6991
MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC
Definition miopen.h:6898
MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC
Definition miopen.h:6869
MIOPEN_ATTR_POINTWISE_MODE
@ MIOPEN_ATTR_POINTWISE_MODE
Definition miopen.h:6806
MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO
Definition miopen.h:6831
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY
Definition miopen.h:6866
MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC
Definition miopen.h:7031
MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION
Definition miopen.h:6808
MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES
Definition miopen.h:6844
MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP
Definition miopen.h:6810
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC
Definition miopen.h:6964
MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY
Definition miopen.h:7042
MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET
Definition miopen.h:6828
MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC
Definition miopen.h:6888
MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC
Definition miopen.h:6892
MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN
Definition miopen.h:7038
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC
Definition miopen.h:6957
MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC
Definition miopen.h:6958
MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS
Definition miopen.h:7020
MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC
Definition miopen.h:7011
MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC
Definition miopen.h:6881
MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG
Definition miopen.h:6835
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA
Definition miopen.h:6983
MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC
Definition miopen.h:7030
MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC
Definition miopen.h:7027
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA
Definition miopen.h:6855
MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM
Definition miopen.h:7040
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC
Definition miopen.h:6863
MIOPEN_ATTR_TENSOR_STRIDES
@ MIOPEN_ATTR_TENSOR_STRIDES
Definition miopen.h:6908
MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES
Definition miopen.h:6820
MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA
Definition miopen.h:6861
MIOPEN_ATTR_POINTWISE_SWISH_BETA
@ MIOPEN_ATTR_POINTWISE_SWISH_BETA
Definition miopen.h:6814
MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC
Definition miopen.h:6981
MIOPEN_ATTR_OPERATION_REDUCTION_DESC
@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC
Definition miopen.h:6955
MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC
Definition miopen.h:7008
MIOPEN_ATTR_OPERATION_MATMUL_ADESC
@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC
Definition miopen.h:6941
MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT
Definition miopen.h:6903
MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC
Definition miopen.h:6893
MIOPEN_RNG_DISTRIBUTION_BERNOULLI
@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI
Definition miopen.h:7275
MIOPEN_RNG_DISTRIBUTION_UNIFORM
@ MIOPEN_RNG_DISTRIBUTION_UNIFORM
Definition miopen.h:7276
MIOPEN_RNG_DISTRIBUTION_NORMAL
@ MIOPEN_RNG_DISTRIBUTION_NORMAL
Definition miopen.h:7277
MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR
Definition miopen.h:6773
MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR
Definition miopen.h:6791
MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR
Definition miopen.h:6765
MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR
Definition miopen.h:6789
MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR
Definition miopen.h:6784
MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR
Definition miopen.h:6763
MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR
Definition miopen.h:6786
MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR
Definition miopen.h:6770
MIOPEN_BACKEND_RNG_DESCRIPTOR
@ MIOPEN_BACKEND_RNG_DESCRIPTOR
Definition miopen.h:6792
MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR
Definition miopen.h:6781
MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR
Definition miopen.h:6780
MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR
Definition miopen.h:6766
MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR
Definition miopen.h:6785
MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR
Definition miopen.h:6771
MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR
Definition miopen.h:6782
MIOPEN_BACKEND_TENSOR_DESCRIPTOR
@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR
Definition miopen.h:6793
MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR
Definition miopen.h:6783
MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR
Definition miopen.h:6788
MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
Definition miopen.h:6776
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
Definition miopen.h:6775
MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR
Definition miopen.h:6768
MIOPEN_BACKEND_ENGINE_DESCRIPTOR
@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR
Definition miopen.h:6764
MIOPEN_BACKEND_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR
Definition miopen.h:6772
MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR
Definition miopen.h:6777
MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR
Definition miopen.h:6794
MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR
Definition miopen.h:6790
MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
Definition miopen.h:6774
MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR
Definition miopen.h:6778
MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR
Definition miopen.h:6779
MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR
Definition miopen.h:6787
MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR
Definition miopen.h:6767
MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR
Definition miopen.h:6769
SCALE
@ SCALE
Definition miopen.h:7288
BILINEAR
@ BILINEAR
Definition miopen.h:7289
DEFAULT
@ DEFAULT
Definition miopen.h:7287
ERROR_STATE
@ ERROR_STATE
Definition miopen.h:7290
MIOPEN_TYPE_RNG_DISTRIBUTION
@ MIOPEN_TYPE_RNG_DISTRIBUTION
Definition miopen.h:7089
MIOPEN_TYPE_FLOAT
@ MIOPEN_TYPE_FLOAT
Definition miopen.h:7064
MIOPEN_TYPE_NUMERICAL_NOTE
@ MIOPEN_TYPE_NUMERICAL_NOTE
Definition miopen.h:7071
MIOPEN_TYPE_RESAMPLE_MODE
@ MIOPEN_TYPE_RESAMPLE_MODE
Definition miopen.h:7081
MIOPEN_TYPE_INT32
@ MIOPEN_TYPE_INT32
Definition miopen.h:7083
MIOPEN_TYPE_POINTWISE_MODE
@ MIOPEN_TYPE_POINTWISE_MODE
Definition miopen.h:7074
MIOPEN_TYPE_HANDLE
@ MIOPEN_TYPE_HANDLE
Definition miopen.h:7060
MIOPEN_TYPE_HEUR_MODE
@ MIOPEN_TYPE_HEUR_MODE
Definition miopen.h:7068
MIOPEN_TYPE_CONVOLUTION_MODE
@ MIOPEN_TYPE_CONVOLUTION_MODE
Definition miopen.h:7067
MIOPEN_TYPE_TENSOR_REORDERING_MODE
@ MIOPEN_TYPE_TENSOR_REORDERING_MODE
Definition miopen.h:7080
MIOPEN_TYPE_BOOLEAN
@ MIOPEN_TYPE_BOOLEAN
Definition miopen.h:7062
MIOPEN_TYPE_NORM_MODE
@ MIOPEN_TYPE_NORM_MODE
Definition miopen.h:7087
MIOPEN_TYPE_FRACTION
@ MIOPEN_TYPE_FRACTION
Definition miopen.h:7086
MIOPEN_TYPE_BACKEND_DESCRIPTOR
@ MIOPEN_TYPE_BACKEND_DESCRIPTOR
Definition miopen.h:7075
MIOPEN_TYPE_ATTRIB_NAME
@ MIOPEN_TYPE_ATTRIB_NAME
Definition miopen.h:7073
MIOPEN_TYPE_BEHAVIOR_NOTE
@ MIOPEN_TYPE_BEHAVIOR_NOTE
Definition miopen.h:7079
MIOPEN_TYPE_DATA_TYPE
@ MIOPEN_TYPE_DATA_TYPE
Definition miopen.h:7061
MIOPEN_TYPE_NAN_PROPOGATION
@ MIOPEN_TYPE_NAN_PROPOGATION
Definition miopen.h:7070
MIOPEN_TYPE_DOUBLE
@ MIOPEN_TYPE_DOUBLE
Definition miopen.h:7065
MIOPEN_TYPE_SIGNAL_MODE
@ MIOPEN_TYPE_SIGNAL_MODE
Definition miopen.h:7085
MIOPEN_TYPE_CHAR
@ MIOPEN_TYPE_CHAR
Definition miopen.h:7084
MIOPEN_TYPE_PADDING_MODE
@ MIOPEN_TYPE_PADDING_MODE
Definition miopen.h:7082
MIOPEN_TYPE_INT64
@ MIOPEN_TYPE_INT64
Definition miopen.h:7063
MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE
Definition miopen.h:7078
MIOPEN_TYPE_LAYOUT_TYPE
@ MIOPEN_TYPE_LAYOUT_TYPE
Definition miopen.h:7072
MIOPEN_TYPE_GENSTATS_MODE
@ MIOPEN_TYPE_GENSTATS_MODE
Definition miopen.h:7076
MIOPEN_TYPE_VOID_PTR
@ MIOPEN_TYPE_VOID_PTR
Definition miopen.h:7066
MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE
Definition miopen.h:7077
MIOPEN_TYPE_KNOB_TYPE
@ MIOPEN_TYPE_KNOB_TYPE
Definition miopen.h:7069
MIOPEN_TYPE_NORM_FWD_PHASE
@ MIOPEN_TYPE_NORM_FWD_PHASE
Definition miopen.h:7088
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:8347
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:5462
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:5463
miopenRNNMode_t
miopenRNNMode_t
Definition miopen.h:4067
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:4078
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:4100
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:4109
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:4144
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:4087
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:4135
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:4118
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:4126
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:4069
miopenLSTM
@ miopenLSTM
Definition miopen.h:4070
miopenGRU
@ miopenGRU
Definition miopen.h:4071
miopenRNNRELU
@ miopenRNNRELU
Definition miopen.h:4068
miopenRNNlinear
@ miopenRNNlinear
Definition miopen.h:4079
miopenRNNskip
@ miopenRNNskip
Definition miopen.h:4080
miopenRNNbidirection
@ miopenRNNbidirection
Definition miopen.h:4102
miopenRNNunidirection
@ miopenRNNunidirection
Definition miopen.h:4101
miopenRNNwithBias
@ miopenRNNwithBias
Definition miopen.h:4111
miopenRNNNoBias
@ miopenRNNNoBias
Definition miopen.h:4110
miopenRNNDataSeqMajorPadded
@ miopenRNNDataSeqMajorPadded
Definition miopen.h:4147
miopenRNNDataSeqMajorNotPadded
@ miopenRNNDataSeqMajorNotPadded
Definition miopen.h:4146
miopenRNNDataBatchMajorPadded
@ miopenRNNDataBatchMajorPadded
Definition miopen.h:4148
miopenRNNDataUnknownLayout
@ miopenRNNDataUnknownLayout
Definition miopen.h:4145
miopenRNNroundedDynamic
@ miopenRNNroundedDynamic
Definition miopen.h:4092
miopenRNNfundamental
@ miopenRNNfundamental
Definition miopen.h:4090
miopenRNNdefault
@ miopenRNNdefault
Definition miopen.h:4088
miopenRNNTraining
@ miopenRNNTraining
Definition miopen.h:4136
miopenRNNInference
@ miopenRNNInference
Definition miopen.h:4137
miopenRNNAlgoGEMM
@ miopenRNNAlgoGEMM
Definition miopen.h:4119
miopenRNNIOWithPadding
@ miopenRNNIOWithPadding
Definition miopen.h:4128
miopenRNNIONotPadded
@ miopenRNNIONotPadded
Definition miopen.h:4127
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:6506
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:1265
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:1228
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:1251
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:1240
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:1267
miopenConvolutionAlgoWinograd
@ miopenConvolutionAlgoWinograd
Definition miopen.h:1269
miopenConvolutionAlgoFFT
@ miopenConvolutionAlgoFFT
Definition miopen.h:1268
miopenConvolutionAlgoImplicitGEMM
@ miopenConvolutionAlgoImplicitGEMM
Definition miopen.h:1270
miopenConvolutionAlgoGEMM
@ miopenConvolutionAlgoGEMM
Definition miopen.h:1266
miopenConvolutionFwdAlgoFFT
@ miopenConvolutionFwdAlgoFFT
Definition miopen.h:1231
miopenConvolutionFwdAlgoImplicitGEMM
@ miopenConvolutionFwdAlgoImplicitGEMM
Definition miopen.h:1233
miopenConvolutionFwdAlgoGEMM
@ miopenConvolutionFwdAlgoGEMM
Definition miopen.h:1229
miopenConvolutionFwdAlgoWinograd
@ miopenConvolutionFwdAlgoWinograd
Definition miopen.h:1232
miopenConvolutionFwdAlgoDirect
@ miopenConvolutionFwdAlgoDirect
Definition miopen.h:1230
miopenTransposeBwdDataAlgoGEMM
@ miopenTransposeBwdDataAlgoGEMM
Definition miopen.h:1256
miopenConvolutionBwdDataAlgoDirect
@ miopenConvolutionBwdDataAlgoDirect
Definition miopen.h:1253
miopenConvolutionBwdDataAlgoGEMM
@ miopenConvolutionBwdDataAlgoGEMM
Definition miopen.h:1252
miopenConvolutionBwdDataAlgoFFT
@ miopenConvolutionBwdDataAlgoFFT
Definition miopen.h:1254
miopenConvolutionBwdDataAlgoWinograd
@ miopenConvolutionBwdDataAlgoWinograd
Definition miopen.h:1255
miopenConvolutionBwdDataAlgoImplicitGEMM
@ miopenConvolutionBwdDataAlgoImplicitGEMM
Definition miopen.h:1258
miopenConvolutionBwdWeightsAlgoGEMM
@ miopenConvolutionBwdWeightsAlgoGEMM
Definition miopen.h:1241
miopenConvolutionBwdWeightsAlgoWinograd
@ miopenConvolutionBwdWeightsAlgoWinograd
Definition miopen.h:1243
miopenConvolutionBwdWeightsAlgoDirect
@ miopenConvolutionBwdWeightsAlgoDirect
Definition miopen.h:1242
miopenConvolutionBwdWeightsAlgoImplicitGEMM
@ miopenConvolutionBwdWeightsAlgoImplicitGEMM
Definition miopen.h:1244
miopenDestroyDropoutDescriptor
miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)
Destroys the dropout descriptor object.
miopenRNGType_t
miopenRNGType_t
Definition miopen.h:5582
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:5583
miopenFindResultsOrder_t
miopenFindResultsOrder_t
Definition miopen.h:6013
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:6041
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:5932
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:5919
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:6015
miopenFindResultsOrderByTime
@ miopenFindResultsOrderByTime
Definition miopen.h:6014
miopenMhaMaskCausal
@ miopenMhaMaskCausal
Definition miopen.h:6043
miopenMhaMaskNone
@ miopenMhaMaskNone
Definition miopen.h:6042
miopenTensorMhaDescaleS
@ miopenTensorMhaDescaleS
Definition miopen.h:5944
miopenTensorMhaO
@ miopenTensorMhaO
Definition miopen.h:5950
miopenTensorMhaAmaxDV
@ miopenTensorMhaAmaxDV
Definition miopen.h:5968
miopenTensorBatchnormScaleDiff
@ miopenTensorBatchnormScaleDiff
Definition miopen.h:5991
miopenTensorMhaMask
@ miopenTensorMhaMask
Definition miopen.h:6002
miopenTensorMhaDescaleDS
@ miopenTensorMhaDescaleDS
Definition miopen.h:5958
miopenTensorMhaDropoutSeed
@ miopenTensorMhaDropoutSeed
Definition miopen.h:5948
miopenTensorBatchnormSavedMean
@ miopenTensorBatchnormSavedMean
Definition miopen.h:5988
miopenTensorActivationDY
@ miopenTensorActivationDY
Definition miopen.h:5976
miopenTensorBatchnormDX
@ miopenTensorBatchnormDX
Definition miopen.h:5996
miopenTensorMhaDescaleV
@ miopenTensorMhaDescaleV
Definition miopen.h:5943
miopenTensorMhaK
@ miopenTensorMhaK
Definition miopen.h:5938
miopenTensorConvolutionX
@ miopenTensorConvolutionX
Definition miopen.h:5934
miopenTensorMhaAmaxDK
@ miopenTensorMhaAmaxDK
Definition miopen.h:5967
miopenTensorMhaScaleDS
@ miopenTensorMhaScaleDS
Definition miopen.h:5959
miopenTensorBatchnormBias
@ miopenTensorBatchnormBias
Definition miopen.h:5994
miopenTensorMhaM
@ miopenTensorMhaM
Definition miopen.h:5953
miopenTensorBatchnormRunningMean
@ miopenTensorBatchnormRunningMean
Definition miopen.h:5986
miopenTensorMhaDropoutProbability
@ miopenTensorMhaDropoutProbability
Definition miopen.h:5947
miopenTensorSoftmaxY
@ miopenTensorSoftmaxY
Definition miopen.h:5981
miopenTensorSoftmaxDY
@ miopenTensorSoftmaxDY
Definition miopen.h:5983
miopenTensorMhaDescaleO
@ miopenTensorMhaDescaleO
Definition miopen.h:5956
miopenTensorMhaScaleO
@ miopenTensorMhaScaleO
Definition miopen.h:5946
miopenScalarBatchnormExpAvgFactor
@ miopenScalarBatchnormExpAvgFactor
Definition miopen.h:6004
miopenTensorBatchnormScale
@ miopenTensorBatchnormScale
Definition miopen.h:5990
miopenTensorBatchnormRunningVariance
@ miopenTensorBatchnormRunningVariance
Definition miopen.h:5987
miopenTensorActivationDX
@ miopenTensorActivationDX
Definition miopen.h:5975
miopenTensorMhaScaleDK
@ miopenTensorMhaScaleDK
Definition miopen.h:5961
miopenTensorMhaV
@ miopenTensorMhaV
Definition miopen.h:5940
miopenTensorMhaAmaxS
@ miopenTensorMhaAmaxS
Definition miopen.h:5952
miopenTensorBatchnormBiasDiff
@ miopenTensorBatchnormBiasDiff
Definition miopen.h:5995
miopenTensorBatchnormSavedVariance
@ miopenTensorBatchnormSavedVariance
Definition miopen.h:5989
miopenTensorActivationX
@ miopenTensorActivationX
Definition miopen.h:5973
miopenTensorMhaScaleDV
@ miopenTensorMhaScaleDV
Definition miopen.h:5962
miopenTensorMhaAmaxO
@ miopenTensorMhaAmaxO
Definition miopen.h:5951
miopenScalarBatchnormEpsilon
@ miopenScalarBatchnormEpsilon
Definition miopen.h:6005
miopenTensorMhaScaleDQ
@ miopenTensorMhaScaleDQ
Definition miopen.h:5960
miopenTensorSoftmaxDX
@ miopenTensorSoftmaxDX
Definition miopen.h:5982
miopenTensorMhaAmaxDS
@ miopenTensorMhaAmaxDS
Definition miopen.h:5969
miopenTensorMhaDV
@ miopenTensorMhaDV
Definition miopen.h:5965
miopenTensorMhaQ
@ miopenTensorMhaQ
Definition miopen.h:5939
miopenTensorMhaAmaxDQ
@ miopenTensorMhaAmaxDQ
Definition miopen.h:5966
miopenTensorConvolutionY
@ miopenTensorConvolutionY
Definition miopen.h:5936
miopenTensorBatchnormEstimatedMean
@ miopenTensorBatchnormEstimatedMean
Definition miopen.h:5992
miopenTensorBatchnormDY
@ miopenTensorBatchnormDY
Definition miopen.h:5997
miopenTensorMhaZInv
@ miopenTensorMhaZInv
Definition miopen.h:5954
miopenTensorMhaDescaleQ
@ miopenTensorMhaDescaleQ
Definition miopen.h:5942
miopenTensorMhaBias
@ miopenTensorMhaBias
Definition miopen.h:5970
miopenTensorBatchnormEstimatedVariance
@ miopenTensorBatchnormEstimatedVariance
Definition miopen.h:5993
miopenTensorArgumentIsScalar
@ miopenTensorArgumentIsScalar
Definition miopen.h:6000
miopenTensorArgumentIdInvalid
@ miopenTensorArgumentIdInvalid
Definition miopen.h:5933
miopenTensorMhaDO
@ miopenTensorMhaDO
Definition miopen.h:5955
miopenTensorMhaDescaleDO
@ miopenTensorMhaDescaleDO
Definition miopen.h:5957
miopenTensorConvolutionW
@ miopenTensorConvolutionW
Definition miopen.h:5935
miopenTensorMhaDescaleK
@ miopenTensorMhaDescaleK
Definition miopen.h:5941
miopenTensorMhaDropoutOffset
@ miopenTensorMhaDropoutOffset
Definition miopen.h:5949
miopenTensorBiasY
@ miopenTensorBiasY
Definition miopen.h:5978
miopenTensorMhaDQ
@ miopenTensorMhaDQ
Definition miopen.h:5963
miopenTensorSoftmaxX
@ miopenTensorSoftmaxX
Definition miopen.h:5980
miopenTensorBatchnormY
@ miopenTensorBatchnormY
Definition miopen.h:5985
miopenTensorMhaScaleS
@ miopenTensorMhaScaleS
Definition miopen.h:5945
miopenTensorBias
@ miopenTensorBias
Definition miopen.h:5979
miopenTensorActivationY
@ miopenTensorActivationY
Definition miopen.h:5974
miopenTensorBatchnormX
@ miopenTensorBatchnormX
Definition miopen.h:5984
miopenTensorBiasX
@ miopenTensorBiasX
Definition miopen.h:5977
miopenTensorMhaDK
@ miopenTensorMhaDK
Definition miopen.h:5964
miopenProblemDirectionBackwardWeights
@ miopenProblemDirectionBackwardWeights
Definition miopen.h:5922
miopenProblemDirectionInference
@ miopenProblemDirectionInference
Definition miopen.h:5924
miopenProblemDirectionForward
@ miopenProblemDirectionForward
Definition miopen.h:5920
miopenProblemDirectionBackward
@ miopenProblemDirectionBackward
Definition miopen.h:5921
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.
miopenGetErrorString
const char * miopenGetErrorString(miopenStatus_t error)
Get character string for an error code.
miopenCreateWithStream
miopenStatus_t miopenCreateWithStream(miopenHandle_t *handle, miopenAcceleratorQueue_t stream)
Create a MIOpen handle with an accelerator stream.
miopenDestroy
miopenStatus_t miopenDestroy(miopenHandle_t handle)
Destroys the MIOpen handle.
miopenTuningPolicy_t
miopenTuningPolicy_t
Definition miopen.h:8530
miopenGetTuningPolicy
miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t *value)
Get tuning policy from a handle.
miopenDeallocatorFunction
void(* miopenDeallocatorFunction)(void *context, void *memory)
Custom deallocator function.
Definition miopen.h:158
miopenAllocatorFunction
void *(* miopenAllocatorFunction)(void *context, size_t sizeBytes)
Custom allocator function.
Definition miopen.h:148
miopenGetStream
miopenStatus_t miopenGetStream(miopenHandle_t handle, miopenAcceleratorQueue_t *streamID)
Get the previously created accelerator command queue.
miopenEnableProfiling
miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable)
Enable profiling to retrieve kernel time.
miopenGetVersion
miopenStatus_t miopenGetVersion(size_t *major, size_t *minor, size_t *patch)
Method to return version of MIOpen.
miopenSetTuningPolicy
miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t newValue)
Update tuning policy for a specific handle. API alternative for MIOPEN_FIND_ENFORCE environment varia...
miopenStatus_t
miopenStatus_t
Definition miopen.h:109
miopenSetAllocator
miopenStatus_t miopenSetAllocator(miopenHandle_t handle, miopenAllocatorFunction allocator, miopenDeallocatorFunction deallocator, void *allocatorContext)
Set allocator for previously created miopenHandle.
miopenF8RoundingMode_t
miopenF8RoundingMode_t
Definition miopen.h:125
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.
miopenLayerNormBackward
miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle, miopenNormMode_t mode, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t meanDesc, const void *mean, const miopenTensorDescriptor_t rstdDesc, const void *rstd, const int32_t normalized_dim, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t dwDesc, void *dw, const miopenTensorDescriptor_t dbDesc, void *db)
Execute a layernorm backward layer.
miopenT5LayerNormForward
miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const float epsilon, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t rstdDesc, void *rstd)
Execute a T5layernorm forward layer.
miopenNormMode_t
miopenNormMode_t
Definition miopen.h:485
miopenGetLayerNormBackwardWorkspaceSize
miopenStatus_t miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenTensorDescriptor_t weightDesc, const miopenTensorDescriptor_t meanDesc, const miopenTensorDescriptor_t rstdDesc, const int32_t normalized_dim, const miopenTensorDescriptor_t dxDesc, const miopenTensorDescriptor_t dwDesc, const miopenTensorDescriptor_t dbDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the layernorm backward call.
miopenGetT5LayerNormBackwardWorkspaceSize
miopenStatus_t miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenTensorDescriptor_t weightDesc, const miopenTensorDescriptor_t rstdDesc, const miopenTensorDescriptor_t dxDesc, const miopenTensorDescriptor_t dwDesc, size_t *sizeInBytes)
Helper function to query the minimum workspace size required by the T5layernorm backward call.
miopenAddLayerNormForward
miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t x2Desc, const void *x2, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const float epsilon, const int32_t normalized_dim, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)
Execute a add and layernorm forward layer.
miopenSet2dPoolingDescriptor
miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc, miopenPoolingMode_t mode, int windowHeight, int windowWidth, int pad_h, int pad_w, int stride_h, int stride_w)
Sets a 2-D pooling layer descriptor details.
miopenSetPoolingWorkSpaceIndexMode
miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index)
Set workspace index mode for pooling layer. The default mode is miopenPoolingWorkSpaceIndexMask.
miopenGetPoolingForwardOutputDim
miopenStatus_t miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t tensorDesc, int *n, int *c, int *h, int *w)
Gets the shape of the output tensor for 2-D pooling.
miopenPoolingGetWorkSpaceSize
miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)
Get the amount of GPU memory required for pooling.
miopenSetNdPoolingDescriptor
miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc, const miopenPoolingMode_t mode, int nbDims, const int *windowDimA, const int *padA, const int *stridesA)
Set details of a N-D pooling layer descriptor.
miopenPoolingForward
miopenStatus_t miopenPoolingForward(miopenHandle_t handle, const miopenPoolingDescriptor_t poolDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, bool do_backward, void *workSpace, size_t workSpaceSize)
Execute a forward pooling layer.
miopenPoolingMode_t
miopenPoolingMode_t
Definition miopen.h: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:6446
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:6447
MIOPEN_REDUCE_CALCULATION_SUM
@ MIOPEN_REDUCE_CALCULATION_SUM
Definition miopen.h:6449
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:6430
MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN
Definition miopen.h:6432
MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN
Definition miopen.h:6431
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:8350
MIOPEN_LOSS_REDUCTION_SUM
@ MIOPEN_LOSS_REDUCTION_SUM
Definition miopen.h:8349
MIOPEN_LOSS_REDUCTION_NONE
@ MIOPEN_LOSS_REDUCTION_NONE
Definition miopen.h:8348
miopenTuningPolicyDbClean
@ miopenTuningPolicyDbClean
Definition miopen.h:8535
miopenTuningPolicyDbUpdate
@ miopenTuningPolicyDbUpdate
Definition miopen.h:8532
miopenTuningPolicyNone
@ miopenTuningPolicyNone
Definition miopen.h:8531
miopenTuningPolicySearch
@ miopenTuningPolicySearch
Definition miopen.h:8533
miopenTuningPolicySearchDbUpdate
@ miopenTuningPolicySearchDbUpdate
Definition miopen.h:8534
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:6509
MIOPEN_REDUCE_EXTREME_MIN
@ MIOPEN_REDUCE_EXTREME_MIN
Definition miopen.h:6511
MIOPEN_REDUCE_EXTREME_MAX
@ MIOPEN_REDUCE_EXTREME_MAX
Definition miopen.h:6513
MIOPEN_REDUCE_EXTREME_ARGMIN
@ MIOPEN_REDUCE_EXTREME_ARGMIN
Definition miopen.h:6507
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:670
miopenConvolutionFindModeTrustVerifyFull
@ miopenConvolutionFindModeTrustVerifyFull
Definition miopen.h:669
miopenConvolutionFindModeTrustVerify
@ miopenConvolutionFindModeTrustVerify
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:1280
miopenConvAlgoPerf_t::fwd_algo
miopenConvFwdAlgorithm_t fwd_algo
Definition miopen.h:1283
miopenConvAlgoPerf_t::bwd_data_algo
miopenConvBwdDataAlgorithm_t bwd_data_algo
Definition miopen.h:1287
miopenConvAlgoPerf_t::memory
size_t memory
Definition miopen.h:1291
miopenConvAlgoPerf_t::bwd_weights_algo
miopenConvBwdWeightsAlgorithm_t bwd_weights_algo
Definition miopen.h:1284
miopenConvAlgoPerf_t::time
float time
Definition miopen.h:1290
miopenConvSolution_t
Performance struct for forward, backward filter, or backward data algorithms in immediate mode.
Definition miopen.h:1304
miopenConvSolution_t::algorithm
miopenConvAlgorithm_t algorithm
Definition miopen.h:1311
miopenConvSolution_t::solution_id
uint64_t solution_id
Definition miopen.h:1310
miopenConvSolution_t::workspace_size
size_t workspace_size
Definition miopen.h:1308
miopenConvSolution_t::time
float time
Definition miopen.h:1305
miopenTensorArgument_t
Values of a tensor or scalar argument for the miopenRunSolution function.
Definition miopen.h:6244
miopenTensorArgument_t::id
miopenTensorArgumentId_t id
Definition miopen.h:6247
miopenTensorArgument_t::buffer
void * buffer
Definition miopen.h:6257
miopenTensorArgument_t::descriptor
miopenTensorDescriptor_t * descriptor
Definition miopen.h:6253