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

• include
• miopen

miopen.h

Go to the documentation of this file.

1 /*******************************************************************************

2  *

3  * MIT License

4  *

5  * Copyright (c) 2023 Advanced Micro Devices, Inc.

6  *

7  * Permission is hereby granted, free of charge, to any person obtaining a copy

8  * of this software and associated documentation files (the "Software"), to deal

9  * in the Software without restriction, including without limitation the rights

10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

11  * copies of the Software, and to permit persons to whom the Software is

12  * furnished to do so, subject to the following conditions:

13  *

14  * The above copyright notice and this permission notice shall be included in all

15  * copies or substantial portions of the Software.

16  *

17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

23  * SOFTWARE.

24  *

25  *******************************************************************************/

26 #ifndef MIOPEN_GUARD_MIOPEN_H_

27 #define MIOPEN_GUARD_MIOPEN_H_

28 

29 #ifdef __clang__

30 #pragma clang diagnostic push

31 #pragma clang diagnostic ignored "-Wextern-c-compat"

32 #endif

33 

34 #include <stddef.h>

35 #include <stdbool.h>

36 #include <miopen/config.h>

37 #include <miopen/export.h>

38 

39 #if MIOPEN_BACKEND_OPENCL

40 #define CL_TARGET_OPENCL_VERSION 120

41 #if defined(__APPLE__) || defined(__MACOSX)

42 #include <OpenCL/cl.h>

43 #else

44 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS

45 #include <CL/cl.h>

46 #endif

47 

48 #elif MIOPEN_BACKEND_HIP

49 #include <hip/hip_runtime_api.h>

50 #endif

51 

52 /*

53  * @defgroup convolutions

54  * @defgroup pooling

55  * @defgroup handle

56  * @defgroup layernorm

57  * @defgroup LRN

58  * @defgroup batchnorm

59  * @defgroup activation

60  * @defgroup tensor

61  * @defgroup softmax

62  * @defgroup RNN

63  * @defgroup fusion

64  * @defgroup LossFunction

65  * @defgroup TensorReduce

66  * @defgroup find2

67  * @defgroup ReduceExtreme

68  * @defgroup groupnorm

69  * @defgroup cat

70  * @defgroup SGD

71  * @defgroup getitem

72  * @defgroup ReduceCalculation

73  * @defgroup RotaryPositionalEmbeddings

74  * @defgroup ReLU

75  *

76  */

77 

79 #define MIOPEN_DECLARE_OBJECT(name) \

80  struct name \

81  { \

82  }; \

83  typedef struct name* name##_t;

84 

85 #ifdef __cplusplus

86 extern "C" {

87 #endif

88 

89 #if MIOPEN_BACKEND_OPENCL

90 typedef cl_command_queue miopenAcceleratorQueue_t;

91 #elif MIOPEN_BACKEND_HIP

92 typedef hipStream_t miopenAcceleratorQueue_t;

93 #endif

94 

98 MIOPEN_DECLARE_OBJECT(miopenHandle);

99 

108 typedef enum

109 {

110  miopenStatusSuccess = 0,

111  miopenStatusNotInitialized = 1,

112  miopenStatusInvalidValue = 2,

113  miopenStatusBadParm = 3,

114  miopenStatusAllocFailed = 4,

115  miopenStatusInternalError = 5,

116  miopenStatusNotImplemented = 6,

117  miopenStatusUnknownError = 7,

118  miopenStatusUnsupportedOp = 8,

119  miopenStatusGpuOperationsSkipped = 9,

120  miopenStatusVersionMismatch = 10,

121 } miopenStatus_t;

122 

123 typedef enum

124 {

125  // TODO:(LYM) temporary use Pedantic as default until TF32 is fully supported

126  miopenMathDefault = 0,

127  miopenMathPedantic =

128  1,

129 } miopenMathType_t;

130 

131 #ifdef MIOPEN_BETA_API

132 typedef enum

133 {

134  miopenF8RoundingModeStandard = 0,

135  miopenF8RoundingModeStochastic = 1,

136 } miopenF8RoundingMode_t;

137 #endif

138 

146 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);

147 

156 typedef void* (*miopenAllocatorFunction)(void* context, size_t sizeBytes);

157 

166 typedef void (*miopenDeallocatorFunction)(void* context, void* memory);

167 

181 MIOPEN_EXPORT miopenStatus_t miopenGetVersion(size_t* major, size_t* minor, size_t* patch);

182 

191 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);

192 

204 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,

205  miopenAcceleratorQueue_t stream);

206 

213 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);

214 

222 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,

223  miopenAcceleratorQueue_t streamID);

224 

232 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,

233  miopenAcceleratorQueue_t* streamID);

234 

251 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,

252  miopenAllocatorFunction allocator,

253  miopenDeallocatorFunction deallocator,

254  void* allocatorContext);

255 

267 MIOPEN_EXPORT miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float* time);

268 

276 MIOPEN_EXPORT miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable);

278 // CLOSEOUT HANDLE DOXYGEN GROUP

279 

287 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);

288 

296 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);

297 

304 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);

305 

313 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);

314 

322 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);

323 

331 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);

332 

339 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);

340 

344 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);

345 

349 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);

350 

354 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);

355 

359 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);

360 

364 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);

365 

369 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);

370 

375 typedef enum

376 {

377  miopenHalf = 0,

378  miopenFloat = 1,

379  miopenInt32 = 2,

380  miopenInt8 = 3,

381  // miopenInt8x4 = 4, /*!< Pack of 4x Int8 in NCHW_VECT_C format (Support discontinued) */

382  miopenBFloat16 = 5,

384  miopenDouble = 6,

385  miopenFloat8_fnuz = 7,

386  miopenBFloat8_fnuz = 8,

387  miopenInt64 = 9,

388 } miopenDataType_t;

389 

395 typedef enum

396 {

397  miopenTensorNCHW = 0,

398  miopenTensorNHWC = 1,

399  miopenTensorCHWN = 2,

400  miopenTensorNCHWc4 = 3,

401  miopenTensorNCHWc8 = 4,

402  miopenTensorCHWNc4 = 5,

403  miopenTensorCHWNc8 = 6,

404  miopenTensorNCDHW = 7,

405  miopenTensorNDHWC = 8,

406 } miopenTensorLayout_t;

407 

412 typedef enum

413 {

414  miopenIndexUint8 = 0,

415  miopenIndexUint16 = 1,

416  miopenIndexUint32 = 2,

417  miopenIndexUint64 = 3,

418 } miopenIndexType_t;

419 

424 typedef enum

425 {

426  miopenTensorOpAdd = 0,

427  miopenTensorOpMul = 1,

428  miopenTensorOpMin = 2,

429  miopenTensorOpMax = 3,

430 } miopenTensorOp_t;

431 

436 typedef enum

437 {

438  miopenConvolution = 0,

439  miopenTranspose = 1,

440  miopenGroupConv = 2,

441  miopenDepthwise = 3,

442 } miopenConvolutionMode_t;

443 

448 typedef enum

449 {

450  miopenPaddingDefault = 0,

451  miopenPaddingSame = 1,

452  miopenPaddingValid = 2,

453 } miopenPaddingMode_t;

454 

459 typedef enum

460 {

461  miopenPoolingMax = 0,

462  miopenPoolingAverage = 1,

463  miopenPoolingAverageInclusive = 2,

464 } miopenPoolingMode_t;

465 

472 typedef enum

473 {

474  miopenPoolingWorkspaceIndexMask = 0,

475  miopenPoolingWorkspaceIndexImage = 1,

476 } miopenPoolingWorkspaceIndexMode_t;

477 

482 typedef enum

483 {

484  miopenLRNWithinChannel = 0,

485  miopenLRNCrossChannel = 1,

486 } miopenLRNMode_t;

487 #ifdef MIOPEN_BETA_API

492 typedef enum

493 {

494  MIOPEN_ELEMENTWISE_AFFINE = 0,

495  MIOPEN_WEIGHT_BIAS =

496  1,

497  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =

498  2,

499  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,

501  MIOPEN_ELEMENTWISE_AFFINE_T5 =

502  4,

503  MIOPEN_WEIGHT_BIAS_T5 = 5,

505 } miopenNormMode_t;

506 #endif

511 typedef enum

512 {

513  miopenBNPerActivation = 0,

514  miopenBNSpatial = 1,

515 } miopenBatchNormMode_t;

516 

521 typedef enum

522 {

523  miopenActivationPASTHRU = 0,

524  miopenActivationLOGISTIC = 1,

525  miopenActivationTANH = 2,

526  miopenActivationRELU = 3,

527  miopenActivationSOFTRELU = 4,

528  miopenActivationABS = 5,

529  miopenActivationPOWER = 6,

530  miopenActivationCLIPPEDRELU =

531  7,

532  miopenActivationLEAKYRELU =

533  8,

534  miopenActivationELU =

535  9,

537  miopenActivationCLAMP = 10,

538 } miopenActivationMode_t;

539 

544 typedef enum

545 {

546  MIOPEN_SOFTMAX_FAST = 0,

547  MIOPEN_SOFTMAX_ACCURATE = 1,

548  MIOPEN_SOFTMAX_LOG = 2,

549 } miopenSoftmaxAlgorithm_t;

550 

555 typedef enum

556 {

557  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,

558  MIOPEN_SOFTMAX_MODE_CHANNEL =

559  1,

560 } miopenSoftmaxMode_t;

561 

569 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1

570 

575 typedef enum

576 {

577  MIOPEN_REDUCE_TENSOR_ADD = 0,

578  MIOPEN_REDUCE_TENSOR_MUL =

579  1,

580  MIOPEN_REDUCE_TENSOR_MIN =

581  2,

582  MIOPEN_REDUCE_TENSOR_MAX =

583  3,

584  MIOPEN_REDUCE_TENSOR_AMAX =

585  4,

586  MIOPEN_REDUCE_TENSOR_AVG =

587  5,

588  MIOPEN_REDUCE_TENSOR_NORM1 =

589  6,

590  MIOPEN_REDUCE_TENSOR_NORM2 = 7,

592  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =

593  // 8, /*!< the operation is same as MUL, but does not have the zero values considered */

594 } miopenReduceTensorOp_t;

595 

600 typedef enum

601 {

602  MIOPEN_NOT_PROPAGATE_NAN = 0,

603  MIOPEN_PROPAGATE_NAN = 1,

604 } miopenNanPropagation_t;

605 

610 typedef enum

611 {

612  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,

613  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,

614 } miopenReduceTensorIndices_t;

615 

620 typedef enum

621 {

622  MIOPEN_32BIT_INDICES = 0,

623  MIOPEN_64BIT_INDICES = 1,

624  MIOPEN_16BIT_INDICES = 2,

625  MIOPEN_8BIT_INDICES = 3,

626 } miopenIndicesType_t;

627 

632 typedef enum

633 {

634  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =

635  0,

638  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =

639  1,

641 #ifdef MIOPEN_BETA_API

642  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =

643  2,

647 #else

648 // miopenReserved1 = 2,

649 #endif

650  // TODO:(LYM) temporarily use Pedantic as default until TF32 is fully supported

651  MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE =

652  3,

653 } miopenConvolutionAttrib_t;

654 

661 typedef enum

662 {

663  miopenConvolutionFindModeNormal =

664  1,

665  miopenConvolutionFindModeFast =

666  2,

669  miopenConvolutionFindModeHybrid =

670  3,

673  // miopenConvolutionFindModeReserved_4 = 4, /*!< Reserved - do not use */

674  miopenConvolutionFindModeDynamicHybrid =

675  5,

679  miopenConvolutionFindModeTrustVerify = 6,

680  miopenConvolutionFindModeTrustVerifyFull = 7,

681  miopenConvolutionFindModeDefault =

682  miopenConvolutionFindModeDynamicHybrid

683 } miopenConvolutionFindMode_t;

684 

696 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);

697 

710 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(

711  miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w);

712 

723 MIOPEN_EXPORT miopenStatus_t

724 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,

725  miopenDataType_t dataType,

726  miopenTensorLayout_t tensorLayout,

727  const int* lens,

728  int num_lens);

748 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,

749  miopenDataType_t dataType,

750  int n,

751  int c,

752  int h,

753  int w,

754  int nStride,

755  int cStride,

756  int hStride,

757  int wStride);

758 

775 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

776  miopenDataType_t* dataType,

777  int* n,

778  int* c,

779  int* h,

780  int* w,

781  int* nStride,

782  int* cStride,

783  int* hStride,

784  int* wStride);

785 

796 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

797  miopenDataType_t dataType,

798  int nbDims,

799  const int* dimsA,

800  const int* stridesA);

801 

802 #ifdef MIOPEN_BETA_API

805 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,

806  miopenDataType_t dataType,

807  int nbDims,

808  const size_t* dimsA,

809  const size_t* stridesA);

810 #endif

811 

812 #ifdef MIOPEN_BETA_API

822 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,

823  miopenDataType_t cast_type);

824 #endif

825 

834 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,

835  int* size);

836 

845 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

846  miopenDataType_t* dataType,

847  int* dimsA,

848  int* stridesA);

849 

855 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);

856 

863 MIOPEN_EXPORT miopenStatus_t

864 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);

865 

871 MIOPEN_EXPORT miopenStatus_t

872 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);

873 

893 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,

894  miopenTensorOp_t tensorOp,

895  const void* alpha1,

896  const miopenTensorDescriptor_t aDesc,

897  const void* A,

898  const void* alpha2,

899  const miopenTensorDescriptor_t bDesc,

900  const void* B,

901  const void* beta,

902  const miopenTensorDescriptor_t cDesc,

903  void* C);

904 

915 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,

916  const miopenTensorDescriptor_t yDesc,

917  void* y,

918  const void* alpha);

919 

930 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,

931  const miopenTensorDescriptor_t yDesc,

932  void* y,

933  const void* alpha);

934 

941 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,

942  size_t* numBytes);

943 

961 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,

962  const void* alpha,

963  const miopenTensorDescriptor_t xDesc,

964  const void* x,

965  const void* beta,

966  const miopenTensorDescriptor_t yDesc,

967  void* y);

968 

970 // CLOSEOUT TENSOR DOXYGEN GROUP

971 

982 MIOPEN_EXPORT miopenStatus_t

983 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);

984 

1000 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

1001  miopenConvolutionMode_t c_mode,

1002  int pad_h,

1003  int pad_w,

1004  int stride_h,

1005  int stride_w,

1006  int dilation_h,

1007  int dilation_w);

1008 

1019 MIOPEN_EXPORT miopenStatus_t

1020 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1021  int spatialDim,

1022  const int* padA,

1023  const int* strideA,

1024  const int* dilationA,

1025  miopenConvolutionMode_t c_mode);

1026 

1033 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,

1034  int* spatialDim);

1035 

1051 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

1052  miopenConvolutionMode_t* c_mode,

1053  int* pad_h,

1054  int* pad_w,

1055  int* stride_h,

1056  int* stride_w,

1057  int* dilation_h,

1058  int* dilation_w);

1059 

1071 MIOPEN_EXPORT miopenStatus_t

1072 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1073  int requestedSpatialDim,

1074  int* spatialDim,

1075  int* padA,

1076  int* strideA,

1077  int* dilationA,

1078  miopenConvolutionMode_t* c_mode);

1079 

1086 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1087  int* groupCount);

1088 

1102 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1103  int groupCount);

1104 

1117 MIOPEN_EXPORT miopenStatus_t

1118 miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w);

1119 

1132 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(

1133  miopenConvolutionDescriptor_t convDesc, int spatialDim, const int* adjA);

1134 

1152 MIOPEN_EXPORT miopenStatus_t

1153 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1154  const miopenTensorDescriptor_t inputTensorDesc,

1155  const miopenTensorDescriptor_t filterDesc,

1156  int* n,

1157  int* c,

1158  int* h,

1159  int* w);

1160 

1174 MIOPEN_EXPORT miopenStatus_t

1175 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1176  const miopenTensorDescriptor_t inputTensorDesc,

1177  const miopenTensorDescriptor_t filterDesc,

1178  int* nDim,

1179  int* outputTensorDimA);

1180 

1186 MIOPEN_EXPORT miopenStatus_t

1187 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);

1188 

1195 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1196  const miopenConvolutionAttrib_t attr,

1197  int value);

1198 

1205 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1206  const miopenConvolutionAttrib_t attr,

1207  int* value);

1208 

1222 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,

1223  miopenConvolutionFindMode_t findMode);

1224 

1231 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(

1232  const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);

1233 

1238 typedef enum

1239 {

1240  miopenConvolutionFwdAlgoGEMM = 0,

1241  miopenConvolutionFwdAlgoDirect = 1,

1242  miopenConvolutionFwdAlgoFFT = 2,

1243  miopenConvolutionFwdAlgoWinograd = 3,

1244  miopenConvolutionFwdAlgoImplicitGEMM = 5,

1245 } miopenConvFwdAlgorithm_t;

1246 

1250 typedef enum

1251 {

1252  miopenConvolutionBwdWeightsAlgoGEMM = 0,

1253  miopenConvolutionBwdWeightsAlgoDirect = 1,

1254  miopenConvolutionBwdWeightsAlgoWinograd = 3,

1255  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,

1256 } miopenConvBwdWeightsAlgorithm_t;

1257 

1261 typedef enum

1262 {

1263  miopenConvolutionBwdDataAlgoGEMM = 0,

1264  miopenConvolutionBwdDataAlgoDirect = 1,

1265  miopenConvolutionBwdDataAlgoFFT = 2,

1266  miopenConvolutionBwdDataAlgoWinograd = 3,

1267  miopenTransposeBwdDataAlgoGEMM =

1268  4,

1269  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,

1270 } miopenConvBwdDataAlgorithm_t;

1271 

1275 typedef enum

1276 {

1277  miopenConvolutionAlgoGEMM = 0,

1278  miopenConvolutionAlgoDirect = 1,

1279  miopenConvolutionAlgoFFT = 2,

1280  miopenConvolutionAlgoWinograd = 3,

1281  miopenConvolutionAlgoImplicitGEMM = 5,

1282 } miopenConvAlgorithm_t;

1283 

1290 typedef struct

1291 {

1292  union

1293  {

1294  miopenConvFwdAlgorithm_t fwd_algo;

1295  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;

1297  miopenConvBwdDataAlgorithm_t

1298  bwd_data_algo;

1299  };

1300 

1301  float time;

1302  size_t memory;

1304 } miopenConvAlgoPerf_t;

1305 

1314 typedef struct

1315 {

1316  float time;

1319  size_t workspace_size;

1321  uint64_t solution_id;

1322  miopenConvAlgorithm_t algorithm;

1324 } miopenConvSolution_t;

1325 

1341 MIOPEN_EXPORT miopenStatus_t

1342 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,

1343  const miopenTensorDescriptor_t wDesc,

1344  const miopenTensorDescriptor_t xDesc,

1345  const miopenConvolutionDescriptor_t convDesc,

1346  const miopenTensorDescriptor_t yDesc,

1347  size_t* solutionCount);

1348 

1372 MIOPEN_EXPORT miopenStatus_t

1373 miopenConvolutionForwardGetSolution(miopenHandle_t handle,

1374  const miopenTensorDescriptor_t wDesc,

1375  const miopenTensorDescriptor_t xDesc,

1376  const miopenConvolutionDescriptor_t convDesc,

1377  const miopenTensorDescriptor_t yDesc,

1378  const size_t maxSolutionCount,

1379  size_t* solutionCount,

1380  miopenConvSolution_t* solutions);

1381 

1399 MIOPEN_EXPORT miopenStatus_t

1400 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,

1401  const miopenTensorDescriptor_t wDesc,

1402  const miopenTensorDescriptor_t xDesc,

1403  const miopenConvolutionDescriptor_t convDesc,

1404  const miopenTensorDescriptor_t yDesc,

1405  const uint64_t solution_id,

1406  size_t* workSpaceSize);

1407 

1425 MIOPEN_EXPORT miopenStatus_t

1426 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,

1427  const miopenTensorDescriptor_t wDesc,

1428  const miopenTensorDescriptor_t xDesc,

1429  const miopenConvolutionDescriptor_t convDesc,

1430  const miopenTensorDescriptor_t yDesc,

1431  const uint64_t solution_id);

1432 

1450 MIOPEN_EXPORT miopenStatus_t

1451 miopenConvolutionForwardImmediate(miopenHandle_t handle,

1452  const miopenTensorDescriptor_t wDesc,

1453  const void* w,

1454  const miopenTensorDescriptor_t xDesc,

1455  const void* x,

1456  const miopenConvolutionDescriptor_t convDesc,

1457  const miopenTensorDescriptor_t yDesc,

1458  void* y,

1459  void* workSpace,

1460  size_t workSpaceSize,

1461  const uint64_t solution_id);

1462 

1480 MIOPEN_EXPORT miopenStatus_t

1481 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,

1482  const miopenTensorDescriptor_t dyDesc,

1483  const miopenTensorDescriptor_t wDesc,

1484  const miopenConvolutionDescriptor_t convDesc,

1485  const miopenTensorDescriptor_t dxDesc,

1486  size_t* solutionCount);

1487 

1512 MIOPEN_EXPORT miopenStatus_t

1513 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,

1514  const miopenTensorDescriptor_t dyDesc,

1515  const miopenTensorDescriptor_t wDesc,

1516  const miopenConvolutionDescriptor_t convDesc,

1517  const miopenTensorDescriptor_t dxDesc,

1518  const size_t maxSolutionCount,

1519  size_t* solutionCount,

1520  miopenConvSolution_t* solutions);

1521 

1539 MIOPEN_EXPORT miopenStatus_t

1540 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,

1541  const miopenTensorDescriptor_t dyDesc,

1542  const miopenTensorDescriptor_t wDesc,

1543  const miopenConvolutionDescriptor_t convDesc,

1544  const miopenTensorDescriptor_t dxDesc,

1545  const uint64_t solution_id,

1546  size_t* workSpaceSize);

1547 

1566 MIOPEN_EXPORT miopenStatus_t

1567 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,

1568  const miopenTensorDescriptor_t dyDesc,

1569  const miopenTensorDescriptor_t wDesc,

1570  const miopenConvolutionDescriptor_t convDesc,

1571  const miopenTensorDescriptor_t dxDesc,

1572  const uint64_t solution_id);

1573 

1591 MIOPEN_EXPORT miopenStatus_t

1592 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,

1593  const miopenTensorDescriptor_t dyDesc,

1594  const void* dy,

1595  const miopenTensorDescriptor_t wDesc,

1596  const void* w,

1597  const miopenConvolutionDescriptor_t convDesc,

1598  const miopenTensorDescriptor_t dxDesc,

1599  void* dx,

1600  void* workSpace,

1601  size_t workSpaceSize,

1602  const uint64_t solution_id);

1603 

1621 MIOPEN_EXPORT miopenStatus_t

1622 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,

1623  const miopenTensorDescriptor_t dyDesc,

1624  const miopenTensorDescriptor_t xDesc,

1625  const miopenConvolutionDescriptor_t convDesc,

1626  const miopenTensorDescriptor_t dwDesc,

1627  size_t* solutionCount);

1628 

1652 MIOPEN_EXPORT miopenStatus_t

1653 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,

1654  const miopenTensorDescriptor_t dyDesc,

1655  const miopenTensorDescriptor_t xDesc,

1656  const miopenConvolutionDescriptor_t convDesc,

1657  const miopenTensorDescriptor_t dwDesc,

1658  const size_t maxSolutionCount,

1659  size_t* solutionCount,

1660  miopenConvSolution_t* solutions);

1661 

1679 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(

1680  miopenHandle_t handle,

1681  const miopenTensorDescriptor_t dyDesc,

1682  const miopenTensorDescriptor_t xDesc,

1683  const miopenConvolutionDescriptor_t convDesc,

1684  const miopenTensorDescriptor_t dwDesc,

1685  const uint64_t solution_id,

1686  size_t* workSpaceSize);

1687 

1705 MIOPEN_EXPORT miopenStatus_t

1706 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,

1707  const miopenTensorDescriptor_t dyDesc,

1708  const miopenTensorDescriptor_t xDesc,

1709  const miopenConvolutionDescriptor_t convDesc,

1710  const miopenTensorDescriptor_t dwDesc,

1711  const uint64_t solution_id);

1712 

1731 MIOPEN_EXPORT miopenStatus_t

1732 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,

1733  const miopenTensorDescriptor_t dyDesc,

1734  const void* dy,

1735  const miopenTensorDescriptor_t xDesc,

1736  const void* x,

1737  const miopenConvolutionDescriptor_t convDesc,

1738  const miopenTensorDescriptor_t dwDesc,

1739  void* dw,

1740  void* workSpace,

1741  size_t workSpaceSize,

1742  const uint64_t solution_id);

1743 

1770 MIOPEN_EXPORT miopenStatus_t

1771 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,

1772  const miopenTensorDescriptor_t wDesc,

1773  const miopenTensorDescriptor_t xDesc,

1774  const miopenConvolutionDescriptor_t convDesc,

1775  const miopenTensorDescriptor_t yDesc,

1776  size_t* workSpaceSize);

1777 

1821 MIOPEN_EXPORT miopenStatus_t

1822 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,

1823  const miopenTensorDescriptor_t xDesc,

1824  const void* x,

1825  const miopenTensorDescriptor_t wDesc,

1826  const void* w,

1827  const miopenConvolutionDescriptor_t convDesc,

1828  const miopenTensorDescriptor_t yDesc,

1829  void* y,

1830  const int requestAlgoCount,

1831  int* returnedAlgoCount,

1832  miopenConvAlgoPerf_t* perfResults,

1833  void* workSpace,

1834  size_t workSpaceSize,

1835  bool exhaustiveSearch);

1836 

1871 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,

1872  const void* alpha,

1873  const miopenTensorDescriptor_t xDesc,

1874  const void* x,

1875  const miopenTensorDescriptor_t wDesc,

1876  const void* w,

1877  const miopenConvolutionDescriptor_t convDesc,

1878  miopenConvFwdAlgorithm_t algo,

1879  const void* beta,

1880  const miopenTensorDescriptor_t yDesc,

1881  void* y,

1882  void* workSpace,

1883  size_t workSpaceSize);

1884 

1900 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,

1901  const void* alpha,

1902  const miopenTensorDescriptor_t bDesc,

1903  const void* b,

1904  const void* beta,

1905  const miopenTensorDescriptor_t yDesc,

1906  void* y);

1907 

1935 MIOPEN_EXPORT miopenStatus_t

1936 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,

1937  const miopenTensorDescriptor_t dyDesc,

1938  const miopenTensorDescriptor_t wDesc,

1939  const miopenConvolutionDescriptor_t convDesc,

1940  const miopenTensorDescriptor_t dxDesc,

1941  size_t* workSpaceSize);

1942 

1986 MIOPEN_EXPORT miopenStatus_t

1987 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,

1988  const miopenTensorDescriptor_t dyDesc,

1989  const void* dy,

1990  const miopenTensorDescriptor_t wDesc,

1991  const void* w,

1992  const miopenConvolutionDescriptor_t convDesc,

1993  const miopenTensorDescriptor_t dxDesc,

1994  void* dx,

1995  const int requestAlgoCount,

1996  int* returnedAlgoCount,

1997  miopenConvAlgoPerf_t* perfResults,

1998  void* workSpace,

1999  size_t workSpaceSize,

2000  bool exhaustiveSearch);

2001 

2035 MIOPEN_EXPORT miopenStatus_t

2036 miopenConvolutionBackwardData(miopenHandle_t handle,

2037  const void* alpha,

2038  const miopenTensorDescriptor_t dyDesc,

2039  const void* dy,

2040  const miopenTensorDescriptor_t wDesc,

2041  const void* w,

2042  const miopenConvolutionDescriptor_t convDesc,

2043  miopenConvBwdDataAlgorithm_t algo,

2044  const void* beta,

2045  const miopenTensorDescriptor_t dxDesc,

2046  void* dx,

2047  void* workSpace,

2048  size_t workSpaceSize);

2049 

2077 MIOPEN_EXPORT miopenStatus_t

2078 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,

2079  const miopenTensorDescriptor_t dyDesc,

2080  const miopenTensorDescriptor_t xDesc,

2081  const miopenConvolutionDescriptor_t convDesc,

2082  const miopenTensorDescriptor_t dwDesc,

2083  size_t* workSpaceSize);

2084 

2128 MIOPEN_EXPORT miopenStatus_t

2129 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,

2130  const miopenTensorDescriptor_t dyDesc,

2131  const void* dy,

2132  const miopenTensorDescriptor_t xDesc,

2133  const void* x,

2134  const miopenConvolutionDescriptor_t convDesc,

2135  const miopenTensorDescriptor_t dwDesc,

2136  void* dw,

2137  const int requestAlgoCount,

2138  int* returnedAlgoCount,

2139  miopenConvAlgoPerf_t* perfResults,

2140  void* workSpace,

2141  size_t workSpaceSize,

2142  bool exhaustiveSearch);

2143 

2177 MIOPEN_EXPORT miopenStatus_t

2178 miopenConvolutionBackwardWeights(miopenHandle_t handle,

2179  const void* alpha,

2180  const miopenTensorDescriptor_t dyDesc,

2181  const void* dy,

2182  const miopenTensorDescriptor_t xDesc,

2183  const void* x,

2184  const miopenConvolutionDescriptor_t convDesc,

2185  miopenConvBwdWeightsAlgorithm_t algo,

2186  const void* beta,

2187  const miopenTensorDescriptor_t dwDesc,

2188  void* dw,

2189  void* workSpace,

2190  size_t workSpaceSize);

2191 

2207 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,

2208  const void* alpha,

2209  const miopenTensorDescriptor_t dyDesc,

2210  const void* dy,

2211  const void* beta,

2212  const miopenTensorDescriptor_t dbDesc,

2213  void* db);

2214 

2216 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP

2217 

2218 // Pooling APIs

2229 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);

2230 

2239 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2240  miopenIndexType_t index_type);

2241 

2249 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2250  miopenIndexType_t* index_type);

2251 

2259 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(

2260  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);

2261 

2268 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(

2269  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);

2270 

2285 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2286  miopenPoolingMode_t mode,

2287  int windowHeight,

2288  int windowWidth,

2289  int pad_h,

2290  int pad_w,

2291  int stride_h,

2292  int stride_w);

2293 

2308 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2309  miopenPoolingMode_t* mode,

2310  int* windowHeight,

2311  int* windowWidth,

2312  int* pad_h,

2313  int* pad_w,

2314  int* stride_h,

2315  int* stride_w);

2316 

2331 MIOPEN_EXPORT miopenStatus_t

2332 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2333  const miopenTensorDescriptor_t tensorDesc,

2334  int* n,

2335  int* c,

2336  int* h,

2337  int* w);

2338 

2354 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2355  const miopenPoolingMode_t mode,

2356  int nbDims,

2357  const int* windowDimA,

2358  const int* padA,

2359  const int* stridesA);

2360 

2377 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2378  int nbDimsRequested,

2379  miopenPoolingMode_t* mode,

2380  int* nbDims,

2381  int* windowDimA,

2382  int* padA,

2383  int* stridesA);

2384 

2397 MIOPEN_EXPORT miopenStatus_t

2398 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2399  const miopenTensorDescriptor_t tensorDesc,

2400  int dims,

2401  int* tensorDimArr);

2402 

2415 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2416  size_t* workSpaceSize);

2417 

2430 MIOPEN_EXPORT miopenStatus_t

2431 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,

2432  const miopenTensorDescriptor_t yDesc,

2433  size_t* workSpaceSize);

2434 

2455 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,

2456  const miopenPoolingDescriptor_t poolDesc,

2457  const void* alpha,

2458  const miopenTensorDescriptor_t xDesc,

2459  const void* x,

2460  const void* beta,

2461  const miopenTensorDescriptor_t yDesc,

2462  void* y,

2463  bool do_backward,

2464  void* workSpace,

2465  size_t workSpaceSize);

2466 

2487 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,

2488  const miopenPoolingDescriptor_t poolDesc,

2489  const void* alpha,

2490  const miopenTensorDescriptor_t yDesc,

2491  const void* y,

2492  const miopenTensorDescriptor_t dyDesc,

2493  const void* dy,

2494  const miopenTensorDescriptor_t xDesc,

2495  const void* x,

2496  const void* beta,

2497  const miopenTensorDescriptor_t dxDesc,

2498  void* dx,

2499  void* workSpace);

2500 

2506 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);

2507 

2509 // CLOSEOUT POOLING DOXYGEN GROUP

2510 

2511 // LRN APIs

2521 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);

2522 

2536 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2537  miopenLRNMode_t mode,

2538  unsigned int lrnN,

2539  double lrnAlpha,

2540  double lrnBeta,

2541  double lrnK);

2542 

2555 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2556  miopenLRNMode_t* mode,

2557  unsigned int* lrnN,

2558  double* lrnAlpha,

2559  double* lrnBeta,

2560  double* lrnK);

2561 

2571 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2572  size_t* workSpaceSize);

2573 

2592 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,

2593  const miopenLRNDescriptor_t lrnDesc,

2594  const void* alpha,

2595  const miopenTensorDescriptor_t xDesc,

2596  const void* x,

2597  const void* beta,

2598  const miopenTensorDescriptor_t yDesc,

2599  void* y,

2600  bool do_backward,

2601  void* workSpace);

2602 

2620 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,

2621  const miopenLRNDescriptor_t lrnDesc,

2622  const void* alpha,

2623  const miopenTensorDescriptor_t yDesc,

2624  const void* y,

2625  const miopenTensorDescriptor_t dyDesc,

2626  const void* dy,

2627  const miopenTensorDescriptor_t xDesc,

2628  const void* x,

2629  const void* beta,

2630  const miopenTensorDescriptor_t dxDesc,

2631  void* dx,

2632  const void* workSpace);

2633 

2639 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);

2640 

2642 // CLOSEOUT LRN DOXYGEN GROUP

2643 

2644 #ifdef MIOPEN_BETA_API

2645 // LayerNorm APIs

2670 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,

2671  miopenNormMode_t mode,

2672  const miopenTensorDescriptor_t xDesc,

2673  const void* x,

2674  const miopenTensorDescriptor_t weightDesc,

2675  const void* weight,

2676  const miopenTensorDescriptor_t biasDesc,

2677  const void* bias,

2678  const float epsilon,

2679  const int32_t normalized_dim,

2680  const miopenTensorDescriptor_t yDesc,

2681  void* y,

2682  const miopenTensorDescriptor_t meanDesc,

2683  void* mean,

2684  const miopenTensorDescriptor_t rstdDesc,

2685  void* rstd);

2686 

2704 MIOPEN_EXPORT miopenStatus_t

2705 miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle,

2706  miopenNormMode_t mode,

2707  const miopenTensorDescriptor_t dyDesc,

2708  const miopenTensorDescriptor_t xDesc,

2709  const miopenTensorDescriptor_t weightDesc,

2710  const miopenTensorDescriptor_t meanDesc,

2711  const miopenTensorDescriptor_t rstdDesc,

2712  const int32_t normalized_dim,

2713  const miopenTensorDescriptor_t dxDesc,

2714  const miopenTensorDescriptor_t dwDesc,

2715  const miopenTensorDescriptor_t dbDesc,

2716  size_t* sizeInBytes);

2717 

2743 MIOPEN_EXPORT miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle,

2744  miopenNormMode_t mode,

2745  void* workspace,

2746  size_t workspaceSizeInBytes,

2747  const miopenTensorDescriptor_t dyDesc,

2748  const void* dy,

2749  const miopenTensorDescriptor_t xDesc,

2750  const void* x,

2751  const miopenTensorDescriptor_t weightDesc,

2752  const void* weight,

2753  const miopenTensorDescriptor_t meanDesc,

2754  const void* mean,

2755  const miopenTensorDescriptor_t rstdDesc,

2756  const void* rstd,

2757  const int32_t normalized_dim,

2758  const miopenTensorDescriptor_t dxDesc,

2759  void* dx,

2760  const miopenTensorDescriptor_t dwDesc,

2761  void* dw,

2762  const miopenTensorDescriptor_t dbDesc,

2763  void* db);

2764 

2766 // CLOSEOUT LAYERNORM DOXYGEN GROUP

2767 #endif

2768 

2769 #ifdef MIOPEN_BETA_API

2770 // Cat APIs

2786 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,

2787  const int32_t xCount,

2788  const miopenTensorDescriptor_t* xDescs,

2789  const void* const* xs,

2790  const miopenTensorDescriptor_t yDesc,

2791  void* y,

2792  const int32_t dim);

2793 

2795 // CLOSEOUT CAT DOXYGEN GROUP

2796 #endif

2797 

2798 // Batch-Normalization APIs

2820 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,

2821  const miopenTensorDescriptor_t xDesc,

2822  miopenBatchNormMode_t bn_mode);

2823 

2862 MIOPEN_EXPORT miopenStatus_t

2863 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,

2864  miopenBatchNormMode_t bn_mode,

2865  void* alpha,

2866  void* beta,

2867  const miopenTensorDescriptor_t xDesc,

2868  const void* x,

2869  const miopenTensorDescriptor_t yDesc,

2870  void* y,

2871  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

2872  void* bnScale,

2873  void* bnBias,

2874  double expAvgFactor,

2875  void* resultRunningMean,

2876  void* resultRunningVariance,

2877  double epsilon,

2878  void* resultSaveMean,

2879  void* resultSaveInvVariance);

2920 MIOPEN_EXPORT miopenStatus_t

2921 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,

2922  miopenBatchNormMode_t bn_mode,

2923  void* alpha,

2924  void* beta,

2925  const miopenTensorDescriptor_t xDesc,

2926  const void* x,

2927  const miopenTensorDescriptor_t yDesc,

2928  void* y,

2929  const miopenTensorDescriptor_t scaleDesc,

2930  const miopenTensorDescriptor_t biasVarDesc,

2931  const miopenTensorDescriptor_t savedMeanDesc,

2932  const miopenTensorDescriptor_t savedVarDesc,

2933  void* bnScale,

2934  void* bnBias,

2935  double expAvgFactor,

2936  void* resultRunningMean,

2937  void* resultRunningVariance,

2938  double epsilon,

2939  void* resultSaveMean,

2940  void* resultSaveInvVariance);

2982 MIOPEN_EXPORT miopenStatus_t

2983 miopenBatchNormForwardTrainingActivation(miopenHandle_t handle,

2984  miopenBatchNormMode_t bn_mode,

2985  void* alpha,

2986  void* beta,

2987  const miopenTensorDescriptor_t xDesc,

2988  const void* x,

2989  const miopenTensorDescriptor_t yDesc,

2990  void* y,

2991  const miopenTensorDescriptor_t scaleDesc,

2992  const miopenTensorDescriptor_t biasVarDesc,

2993  const miopenTensorDescriptor_t savedMeanDesc,

2994  const miopenTensorDescriptor_t savedVarDesc,

2995  void* bnScale,

2996  void* bnBias,

2997  double expAvgFactor,

2998  void* resultRunningMean,

2999  void* resultRunningVariance,

3000  double epsilon,

3001  void* resultSaveMean,

3002  void* resultSaveInvVariance,

3003  const miopenActivationDescriptor_t activDesc);

3004 

3034 MIOPEN_EXPORT miopenStatus_t

3035 miopenBatchNormalizationForwardInference(miopenHandle_t handle,

3036  miopenBatchNormMode_t bn_mode,

3037  void* alpha,

3038  void* beta,

3039  const miopenTensorDescriptor_t xDesc,

3040  const void* x,

3041  const miopenTensorDescriptor_t yDesc,

3042  void* y,

3043  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

3044  void* bnScale,

3045  void* bnBias,

3046  void* estimatedMean,

3047  void* estimatedVariance,

3048  double epsilon);

3049 

3081 MIOPEN_EXPORT miopenStatus_t

3082 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,

3083  miopenBatchNormMode_t bn_mode,

3084  void* alpha,

3085  void* beta,

3086  const miopenTensorDescriptor_t xDesc,

3087  const void* x,

3088  const miopenTensorDescriptor_t yDesc,

3089  void* y,

3090  const miopenTensorDescriptor_t scaleDesc,

3091  const miopenTensorDescriptor_t biasDesc,

3092  const miopenTensorDescriptor_t estMeanDesc,

3093  const miopenTensorDescriptor_t estVarianceDesc,

3094  void* bnScale,

3095  void* bnBias,

3096  void* estimatedMean,

3097  void* estimatedVariance,

3098  double epsilon);

3099 

3132 MIOPEN_EXPORT miopenStatus_t

3133 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,

3134  miopenBatchNormMode_t bn_mode,

3135  void* alpha,

3136  void* beta,

3137  const miopenTensorDescriptor_t xDesc,

3138  const void* x,

3139  const miopenTensorDescriptor_t yDesc,

3140  void* y,

3141  const miopenTensorDescriptor_t scaleDesc,

3142  const miopenTensorDescriptor_t biasDesc,

3143  const miopenTensorDescriptor_t estMeanDesc,

3144  const miopenTensorDescriptor_t estVarianceDesc,

3145  void* bnScale,

3146  void* bnBias,

3147  void* estimatedMean,

3148  void* estimatedVariance,

3149  double epsilon,

3150  const miopenActivationDescriptor_t activDesc);

3151 

3186 MIOPEN_EXPORT miopenStatus_t

3187 miopenBatchNormalizationBackward(miopenHandle_t handle,

3188  miopenBatchNormMode_t bn_mode,

3189  const void* alphaDataDiff,

3190  const void* betaDataDiff,

3191  const void* alphaParamDiff,

3192  const void* betaParamDiff,

3193  const miopenTensorDescriptor_t xDesc,

3194  const void* x,

3195  const miopenTensorDescriptor_t dyDesc,

3196  const void* dy,

3197  const miopenTensorDescriptor_t dxDesc,

3198  void* dx,

3199  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,

3200  const void* bnScale,

3201  void* resultBnScaleDiff,

3202  void* resultBnBiasDiff,

3203  double epsilon,

3204  const void* savedMean,

3205  const void* savedInvVariance);

3206 

3245 MIOPEN_EXPORT miopenStatus_t

3246 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,

3247  miopenBatchNormMode_t bn_mode,

3248  const void* alphaDataDiff,

3249  const void* betaDataDiff,

3250  const void* alphaParamDiff,

3251  const void* betaParamDiff,

3252  const miopenTensorDescriptor_t xDesc,

3253  const void* x,

3254  const miopenTensorDescriptor_t dyDesc,

3255  const void* dy,

3256  const miopenTensorDescriptor_t dxDesc,

3257  void* dx,

3258  const miopenTensorDescriptor_t scaleDesc,

3259  const miopenTensorDescriptor_t biasDesc,

3260  const miopenTensorDescriptor_t savedMeanDesc,

3261  const miopenTensorDescriptor_t savedVarDesc,

3262  const void* bnScale,

3263  void* resultBnScaleDiff,

3264  void* resultBnBiasDiff,

3265  double epsilon,

3266  const void* savedMean,

3267  const void* savedInvVariance);

3268 

3309 MIOPEN_EXPORT miopenStatus_t

3310 miopenBatchNormBackwardActivation(miopenHandle_t handle,

3311  miopenBatchNormMode_t bn_mode,

3312  const void* alphaDataDiff,

3313  const void* betaDataDiff,

3314  const void* alphaParamDiff,

3315  const void* betaParamDiff,

3316  const miopenTensorDescriptor_t xDesc,

3317  const void* x,

3318  const miopenTensorDescriptor_t dyDesc,

3319  const void* dy,

3320  const miopenTensorDescriptor_t dxDesc,

3321  void* dx,

3322  const miopenTensorDescriptor_t scaleDesc,

3323  const miopenTensorDescriptor_t biasDesc,

3324  const miopenTensorDescriptor_t savedMeanDesc,

3325  const miopenTensorDescriptor_t savedVarianceDesc,

3326  const void* bnScale,

3327  const void* bnBias,

3328  void* resultBnScaleDiff,

3329  void* resultBnBiasDiff,

3330  double epsilon,

3331  const void* savedMean,

3332  const void* savedInvVariance,

3333  const miopenActivationDescriptor_t activDesc);

3335 // CLOSEOUT BATCHNORM DOXYGEN GROUP

3336 

3337 // Activation APIs

3347 MIOPEN_EXPORT miopenStatus_t

3348 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);

3349 

3361 MIOPEN_EXPORT miopenStatus_t

3362 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3363  miopenActivationMode_t mode,

3364  double activAlpha,

3365  double activBeta,

3366  double activGamma);

3367 

3379 MIOPEN_EXPORT miopenStatus_t

3380 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3381  miopenActivationMode_t* mode,

3382  double* activAlpha,

3383  double* activBeta,

3384  double* activGamma);

3385 

3398 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,

3399  const miopenActivationDescriptor_t activDesc,

3400  const void* alpha,

3401  const miopenTensorDescriptor_t xDesc,

3402  const void* x,

3403  const void* beta,

3404  const miopenTensorDescriptor_t yDesc,

3405  void* y);

3406 

3423 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,

3424  const miopenActivationDescriptor_t activDesc,

3425  const void* alpha,

3426  const miopenTensorDescriptor_t yDesc,

3427  const void* y,

3428  const miopenTensorDescriptor_t dyDesc,

3429  const void* dy,

3430  const miopenTensorDescriptor_t xDesc,

3431  const void* x,

3432  const void* beta,

3433  const miopenTensorDescriptor_t dxDesc,

3434  void* dx);

3435 

3441 MIOPEN_EXPORT miopenStatus_t

3442 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);

3443 

3445 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3446 

3447 #ifdef MIOPEN_BETA_API

3463 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,

3464  const miopenTensorDescriptor_t inputDesc,

3465  const void* input,

3466  const miopenTensorDescriptor_t outputDesc,

3467  void* output,

3468  const uint32_t dim);

3469 

3482 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,

3483  const miopenTensorDescriptor_t inputDesc,

3484  const void* input,

3485  const miopenTensorDescriptor_t outputGradDesc,

3486  const void* outputGrad,

3487  const miopenTensorDescriptor_t inputGradDesc,

3488  void* inputGrad,

3489  const uint32_t dim);

3490 

3492 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3493 #endif // MIOPEN_BETA_API

3494 

3495 // Softmax APIs

3513 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,

3514  const void* alpha,

3515  const miopenTensorDescriptor_t xDesc,

3516  const void* x,

3517  const void* beta,

3518  const miopenTensorDescriptor_t yDesc,

3519  void* y);

3520 

3536 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,

3537  const void* alpha,

3538  const miopenTensorDescriptor_t yDesc,

3539  const void* y,

3540  const miopenTensorDescriptor_t dyDesc,

3541  const void* dy,

3542  const void* beta,

3543  const miopenTensorDescriptor_t dxDesc,

3544  void* dx);

3545 

3559 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,

3560  const void* alpha,

3561  const miopenTensorDescriptor_t xDesc,

3562  const void* x,

3563  const void* beta,

3564  const miopenTensorDescriptor_t yDesc,

3565  void* y,

3566  miopenSoftmaxAlgorithm_t algorithm,

3567  miopenSoftmaxMode_t mode);

3568 

3584 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,

3585  const void* alpha,

3586  const miopenTensorDescriptor_t yDesc,

3587  const void* y,

3588  const miopenTensorDescriptor_t dyDesc,

3589  const void* dy,

3590  const void* beta,

3591  const miopenTensorDescriptor_t dxDesc,

3592  void* dx,

3593  miopenSoftmaxAlgorithm_t algorithm,

3594  miopenSoftmaxMode_t mode);

3595 

3597 // CLOSEOUT SOFTMAX DOXYGEN GROUP

3598 

3602 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);

3603 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);

3604 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);

3605 

3614 typedef enum

3615 {

3616  miopenVerticalFusion = 0,

3617  miopenHorizontalFusion = 1,

3618 } miopenFusionDirection_t;

3619 

3627 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,

3628  const miopenFusionDirection_t fuseDirection,

3629  const miopenTensorDescriptor_t inputDesc);

3630 

3636 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);

3637 

3644 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,

3645  miopenFusionPlanDescriptor_t fusePlanDesc);

3646 

3657 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,

3658  const int op_idx,

3659  miopenFusionOpDescriptor_t* op);

3660 

3668 MIOPEN_EXPORT miopenStatus_t

3669 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,

3670  miopenFusionPlanDescriptor_t fusePlanDesc,

3671  size_t* workSpaceSize,

3672  miopenConvFwdAlgorithm_t algo);

3673 

3691 MIOPEN_EXPORT miopenStatus_t

3692 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,

3693  const int requestAlgoCount,

3694  int* returnedAlgoCount,

3695  miopenConvFwdAlgorithm_t* returnedAlgos);

3696 

3706 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(

3707  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);

3708 

3717 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3718  miopenFusionOpDescriptor_t* convOp,

3719  miopenConvolutionDescriptor_t convDesc,

3720  const miopenTensorDescriptor_t wDesc);

3721 

3722 //---

3723 

3724 // Activation forward create ops ---

3732 MIOPEN_EXPORT miopenStatus_t

3733 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3734  miopenFusionOpDescriptor_t* activFwdOp,

3735  miopenActivationMode_t mode);

3736 

3737 // Activation backward create ops ---

3745 MIOPEN_EXPORT miopenStatus_t

3746 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3747  miopenFusionOpDescriptor_t* activBwdOp,

3748  miopenActivationMode_t mode);

3749 

3750 // Bias create ops ---

3758 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3759  miopenFusionOpDescriptor_t* biasOp,

3760  const miopenTensorDescriptor_t bDesc);

3761 

3762 // Batch normalization create ops ---

3771 MIOPEN_EXPORT miopenStatus_t

3772 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,

3773  miopenFusionOpDescriptor_t* bnOp,

3774  const miopenBatchNormMode_t bn_mode,

3775  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);

3776 

3786 MIOPEN_EXPORT miopenStatus_t

3787 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3788  miopenFusionOpDescriptor_t* bnFwdOp,

3789  const miopenBatchNormMode_t bn_mode,

3790  bool runningMeanVariance);

3791 

3799 MIOPEN_EXPORT miopenStatus_t

3800 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3801  miopenFusionOpDescriptor_t* bnBwdOp,

3802  const miopenBatchNormMode_t bn_mode);

3803 

3804 //---

3810 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);

3811 

3817 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);

3818 

3819 // Convolution set arguments ---

3829 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,

3830  const miopenFusionOpDescriptor_t convOp,

3831  const void* alpha,

3832  const void* beta,

3833  const void* w);

3834 // Activation set arguments ---

3846 MIOPEN_EXPORT miopenStatus_t

3847 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,

3848  const miopenFusionOpDescriptor_t activFwdOp,

3849  const void* alpha,

3850  const void* beta,

3851  double activAlpha,

3852  double activBeta,

3853  double activGamma);

3854 

3868 MIOPEN_EXPORT miopenStatus_t

3869 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,

3870  const miopenFusionOpDescriptor_t activBwdOp,

3871  const void* alpha,

3872  const void* beta,

3873  const void* y,

3874  const void* reserved,

3875  double activAlpha,

3876  double activBeta,

3877  double activGamma);

3878 

3879 // Batch Normalization set arguments ---

3893 MIOPEN_EXPORT miopenStatus_t

3894 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,

3895  const miopenFusionOpDescriptor_t bnOp,

3896  const void* alpha,

3897  const void* beta,

3898  const void* bnScale,

3899  const void* bnBias,

3900  const void* estimatedMean,

3901  const void* estimatedVariance,

3902  double epsilon);

3903 

3920 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,

3921  const miopenFusionOpDescriptor_t bnOp,

3922  const void* alpha,

3923  const void* beta,

3924  const void* bnScale,

3925  const void* bnBias,

3926  void* savedMean,

3927  void* savedInvVariance,

3928  void* runningMean,

3929  void* runningVariance,

3930  double expAvgFactor,

3931  double epsilon);

3932 

3948 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,

3949  const miopenFusionOpDescriptor_t bnOp,

3950  const void* alpha,

3951  const void* beta,

3952  const void* x,

3953  const void* bnScale,

3954  const void* bnBias,

3955  void* resultBnScaleDiff,

3956  void* resultBnBiasDiff,

3957  const void* savedMean,

3958  const void* savedInvVariance);

3959 

3960 // Bias forward set arguments ---

3970 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,

3971  const miopenFusionOpDescriptor_t biasOp,

3972  const void* alpha,

3973  const void* beta,

3974  const void* bias);

3975 

3990 MIOPEN_EXPORT miopenStatus_t

3991 miopenExecuteFusionPlan(const miopenHandle_t handle,

3992  const miopenFusionPlanDescriptor_t fusePlanDesc,

3993  const miopenTensorDescriptor_t inputDesc,

3994  const void* input,

3995  const miopenTensorDescriptor_t outputDesc,

3996  void* output,

3997  miopenOperatorArgs_t args);

3998 

4013 MIOPEN_EXPORT miopenStatus_t

4014 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,

4015  const miopenFusionPlanDescriptor_t fusePlanDesc,

4016  const miopenTensorDescriptor_t inputDesc,

4017  const void* input,

4018  const miopenTensorDescriptor_t outputDesc,

4019  void* output,

4020  miopenOperatorArgs_t args,

4021  void* workspace,

4022  size_t workspaceSize);

4023 

4047 MIOPEN_EXPORT miopenStatus_t

4048 miopenConvolutionBiasActivationForward(miopenHandle_t handle,

4049  const void* alpha1,

4050  const miopenTensorDescriptor_t xDesc,

4051  const void* x,

4052  const miopenTensorDescriptor_t wDesc,

4053  const void* w,

4054  const miopenConvolutionDescriptor_t convDesc,

4055  miopenConvFwdAlgorithm_t algo,

4056  void* workspace,

4057  size_t workspaceSizeInBytes,

4058  const void* alpha2,

4059  const miopenTensorDescriptor_t zDesc,

4060  const void* z,

4061  const miopenTensorDescriptor_t biasDesc,

4062  const void* bias,

4063  const miopenActivationDescriptor_t activationDesc,

4064  const miopenTensorDescriptor_t yDesc,

4065  void* y);

4067 // CLOSEOUT FUSION DOXYGEN GROUP

4068 

4077 typedef enum

4078 {

4079  miopenRNNRELU = 0,

4080  miopenRNNTANH = 1,

4081  miopenLSTM = 2,

4082  miopenGRU = 3,

4083 } miopenRNNMode_t;

4084 

4088 typedef enum

4089 {

4090  miopenRNNlinear = 0,

4091  miopenRNNskip = 1,

4092 } miopenRNNInputMode_t;

4093 

4097 typedef enum

4098 {

4099  miopenRNNdefault = 0,

4101  miopenRNNfundamental = 1,

4103  miopenRNNroundedDynamic = 2,

4105 } miopenRNNAlgo_t;

4106 

4110 typedef enum

4111 {

4112  miopenRNNunidirection = 0,

4113  miopenRNNbidirection = 1,

4114 } miopenRNNDirectionMode_t;

4115 

4119 typedef enum

4120 {

4121  miopenRNNNoBias = 0,

4122  miopenRNNwithBias = 1,

4123 } miopenRNNBiasMode_t;

4124 

4128 typedef enum

4129 {

4130  miopenRNNAlgoGEMM = 0,

4131 } miopenRNNGEMMalgoMode_t;

4132 

4136 typedef enum

4137 {

4138  miopenRNNIONotPadded = 0,

4139  miopenRNNIOWithPadding = 1,

4140 } miopenRNNPaddingMode_t;

4141 

4145 typedef enum

4146 {

4147  miopenRNNTraining = 0,

4148  miopenRNNInference = 1,

4149 } miopenRNNFWDMode_t;

4150 

4154 typedef enum

4155 {

4156  miopenRNNDataUnknownLayout = 0,

4157  miopenRNNDataSeqMajorNotPadded = 1,

4158  miopenRNNDataSeqMajorPadded = 2,

4159  miopenRNNDataBatchMajorPadded = 3,

4160 } miopenRNNBaseLayout_t;

4161 

4168 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);

4169 

4182 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4183  miopenRNNMode_t* rnnMode,

4184  miopenRNNAlgo_t* algoMode,

4185  miopenRNNInputMode_t* inputMode,

4186  miopenRNNDirectionMode_t* dirMode,

4187  miopenRNNBiasMode_t* biasMode,

4188  int* hiddenSize,

4189  int* layer);

4190 

4207 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4208  int* hiddenSize,

4209  int* layer,

4210  miopenDropoutDescriptor_t* dropoutDesc,

4211  miopenRNNInputMode_t* inputMode,

4212  miopenRNNDirectionMode_t* dirMode,

4213  miopenRNNMode_t* rnnMode,

4214  miopenRNNBiasMode_t* biasMode,

4215  miopenRNNAlgo_t* algoMode,

4216  miopenDataType_t* dataType);

4217 

4223 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);

4224 

4240 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4241  const int hsize,

4242  const int nlayers,

4243  miopenRNNInputMode_t inMode,

4244  miopenRNNDirectionMode_t direction,

4245  miopenRNNMode_t rnnMode,

4246  miopenRNNBiasMode_t biasMode,

4247  miopenRNNAlgo_t algo,

4248  miopenDataType_t dataType);

4249 

4268 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4269  const int hsize,

4270  const int nlayers,

4271  miopenDropoutDescriptor_t dropoutDesc,

4272  miopenRNNInputMode_t inMode,

4273  miopenRNNDirectionMode_t direction,

4274  miopenRNNMode_t rnnMode,

4275  miopenRNNBiasMode_t biasMode,

4276  miopenRNNAlgo_t algo,

4277  miopenDataType_t dataType);

4278 

4293 MIOPEN_EXPORT miopenStatus_t

4294 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4295  miopenDataType_t dataType,

4296  miopenRNNBaseLayout_t layout,

4297  int maxSequenceLen,

4298  int batchSize,

4299  int vectorSize,

4300  const int* sequenceLenArray,

4301  void* paddingMarker);

4302 

4321 MIOPEN_EXPORT miopenStatus_t

4322 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4323  miopenDataType_t* dataType,

4324  miopenRNNBaseLayout_t* layout,

4325  int* maxSequenceLen,

4326  int* batchSize,

4327  int* vectorSize,

4328  int sequenceLenArrayLimit,

4329  int* sequenceLenArray,

4330  void* paddingMarker);

4331 

4348 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,

4349  const miopenRNNDescriptor_t rnnDesc,

4350  const int sequenceLen,

4351  const miopenTensorDescriptor_t* xDesc,

4352  size_t* numBytes);

4353 

4370 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,

4371  miopenRNNDescriptor_t rnnDesc,

4372  const int sequenceLen,

4373  const miopenTensorDescriptor_t* xDesc,

4374  size_t* numBytes);

4375 

4392 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,

4393  miopenRNNDescriptor_t rnnDesc,

4394  miopenSeqTensorDescriptor_t xDesc,

4395  miopenRNNFWDMode_t fwdMode,

4396  size_t* workSpaceSize,

4397  size_t* reserveSpaceSize);

4398 

4411 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,

4412  miopenRNNDescriptor_t rnnDesc,

4413  miopenTensorDescriptor_t xDesc,

4414  size_t* numBytes,

4415  miopenDataType_t dtype);

4416 

4429 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,

4430  miopenRNNDescriptor_t rnnDesc,

4431  miopenTensorDescriptor_t xDesc,

4432  miopenTensorDescriptor_t wDesc,

4433  miopenDataType_t dtype);

4434 

4452 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,

4453  miopenRNNDescriptor_t rnnDesc,

4454  const int seqLen,

4455  miopenTensorDescriptor_t* xDesc,

4456  size_t* numBytes);

4457 

4470 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,

4471  miopenRNNDescriptor_t rnnDesc,

4472  const int seqLen,

4473  miopenTensorDescriptor_t* xDesc,

4474  size_t* numBytes);

4475 

4516 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,

4517  miopenRNNDescriptor_t rnnDesc,

4518  const int layer,

4519  miopenTensorDescriptor_t xDesc,

4520  const int paramID,

4521  size_t* numBytes);

4522 

4560 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,

4561  miopenRNNDescriptor_t rnnDesc,

4562  const int layer,

4563  const int biasID,

4564  size_t* numBytes);

4565 

4624 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,

4625  miopenRNNDescriptor_t rnnDesc,

4626  const int layer,

4627  miopenTensorDescriptor_t xDesc,

4628  miopenTensorDescriptor_t wDesc,

4629  const void* w,

4630  const int paramID,

4631  miopenTensorDescriptor_t paramDesc,

4632  void* layerParam);

4633 

4691 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,

4692  miopenRNNDescriptor_t rnnDesc,

4693  const int layer,

4694  miopenTensorDescriptor_t xDesc,

4695  miopenTensorDescriptor_t wDesc,

4696  const void* w,

4697  const int biasID,

4698  miopenTensorDescriptor_t biasDesc,

4699  void* layerBias);

4700 

4755 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,

4756  const int layer,

4757  miopenTensorDescriptor_t xDesc,

4758  const int paramID,

4759  miopenTensorDescriptor_t paramDesc,

4760  size_t* layerParamOffset);

4761 

4812 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,

4813  const int layer,

4814  miopenTensorDescriptor_t xDesc,

4815  const int biasID,

4816  miopenTensorDescriptor_t biasDesc,

4817  size_t* layerBiasOffset);

4818 

4871 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,

4872  miopenRNNDescriptor_t rnnDesc,

4873  const int layer,

4874  miopenTensorDescriptor_t xDesc,

4875  miopenTensorDescriptor_t wDesc,

4876  void* w,

4877  const int paramID,

4878  miopenTensorDescriptor_t paramDesc,

4879  const void* layerParam);

4880 

4931 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,

4932  miopenRNNDescriptor_t rnnDesc,

4933  const int layer,

4934  miopenTensorDescriptor_t xDesc,

4935  miopenTensorDescriptor_t wDesc,

4936  void* w,

4937  const int biasID,

4938  miopenTensorDescriptor_t biasDesc,

4939  const void* layerBias);

4940 

4952 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

4953  miopenRNNPaddingMode_t paddingMode);

4954 

4962 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

4963  miopenRNNPaddingMode_t* paddingMode);

4964 

5015 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,

5016  const miopenRNNDescriptor_t rnnDesc,

5017  miopenRNNFWDMode_t fwdMode,

5018  const miopenSeqTensorDescriptor_t xDesc,

5019  const void* x,

5020  const miopenTensorDescriptor_t hDesc,

5021  const void* hx,

5022  void* hy,

5023  const miopenTensorDescriptor_t cDesc,

5024  const void* cx,

5025  void* cy,

5026  const miopenSeqTensorDescriptor_t yDesc,

5027  void* y,

5028  const void* w,

5029  size_t weightSpaceSize,

5030  void* workSpace,

5031  size_t workSpaceNumBytes,

5032  void* reserveSpace,

5033  size_t reserveSpaceNumBytes);

5034 

5084 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,

5085  const miopenRNNDescriptor_t rnnDesc,

5086  const miopenSeqTensorDescriptor_t yDesc,

5087  const void* y,

5088  const void* dy,

5089  const miopenTensorDescriptor_t hDesc,

5090  const void* hx,

5091  const void* dhy,

5092  void* dhx,

5093  const miopenTensorDescriptor_t cDesc,

5094  const void* cx,

5095  const void* dcy,

5096  void* dcx,

5097  const miopenSeqTensorDescriptor_t xDesc,

5098  void* dx,

5099  const void* w,

5100  size_t weightSpaceSize,

5101  void* workSpace,

5102  size_t workSpaceNumBytes,

5103  void* reserveSpace,

5104  size_t reserveSpaceNumBytes);

5105 

5139 MIOPEN_EXPORT miopenStatus_t

5140 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,

5141  const miopenRNNDescriptor_t rnnDesc,

5142  const miopenSeqTensorDescriptor_t xDesc,

5143  const void* x,

5144  const miopenTensorDescriptor_t hDesc,

5145  const void* hx,

5146  const miopenSeqTensorDescriptor_t yDesc,

5147  const void* y,

5148  void* dw,

5149  size_t weightSpaceSize,

5150  void* workSpace,

5151  size_t workSpaceNumBytes,

5152  const void* reserveSpace,

5153  size_t reserveSpaceNumBytes);

5154 

5212 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,

5213  const miopenRNNDescriptor_t rnnDesc,

5214  const int sequenceLen,

5215  const miopenTensorDescriptor_t* xDesc,

5216  const void* x,

5217  const miopenTensorDescriptor_t hxDesc,

5218  const void* hx,

5219  const miopenTensorDescriptor_t cxDesc,

5220  const void* cx,

5221  const miopenTensorDescriptor_t wDesc,

5222  const void* w,

5223  const miopenTensorDescriptor_t* yDesc,

5224  void* y,

5225  const miopenTensorDescriptor_t hyDesc,

5226  void* hy,

5227  const miopenTensorDescriptor_t cyDesc,

5228  void* cy,

5229  void* workSpace,

5230  size_t workSpaceNumBytes,

5231  void* reserveSpace,

5232  size_t reserveSpaceNumBytes);

5233 

5306 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,

5307  const miopenRNNDescriptor_t rnnDesc,

5308  const int sequenceLen,

5309  const miopenTensorDescriptor_t* yDesc,

5310  const void* y,

5311  const miopenTensorDescriptor_t* dyDesc,

5312  const void* dy,

5313  const miopenTensorDescriptor_t dhyDesc,

5314  const void* dhy,

5315  const miopenTensorDescriptor_t dcyDesc,

5316  const void* dcy,

5317  const miopenTensorDescriptor_t wDesc,

5318  const void* w,

5319  const miopenTensorDescriptor_t hxDesc,

5320  const void* hx,

5321  const miopenTensorDescriptor_t cxDesc,

5322  const void* cx,

5323  const miopenTensorDescriptor_t* dxDesc,

5324  void* dx,

5325  const miopenTensorDescriptor_t dhxDesc,

5326  void* dhx,

5327  const miopenTensorDescriptor_t dcxDesc,

5328  void* dcx,

5329  void* workSpace,

5330  size_t workSpaceNumBytes,

5331  void* reserveSpace,

5332  size_t reserveSpaceNumBytes);

5333 

5370 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,

5371  const miopenRNNDescriptor_t rnnDesc,

5372  const int sequenceLen,

5373  const miopenTensorDescriptor_t* xDesc,

5374  const void* x,

5375  const miopenTensorDescriptor_t hxDesc,

5376  const void* hx,

5377  const miopenTensorDescriptor_t* yDesc,

5378  const void* y,

5379  const miopenTensorDescriptor_t dwDesc,

5380  void* dw,

5381  void* workSpace,

5382  size_t workSpaceNumBytes,

5383  const void* reserveSpace,

5384  size_t reserveSpaceNumBytes);

5385 

5441 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,

5442  miopenRNNDescriptor_t rnnDesc,

5443  const int sequenceLen,

5444  const miopenTensorDescriptor_t* xDesc,

5445  const void* x,

5446  const miopenTensorDescriptor_t hxDesc,

5447  const void* hx,

5448  const miopenTensorDescriptor_t cxDesc,

5449  const void* cx,

5450  const miopenTensorDescriptor_t wDesc,

5451  const void* w,

5452  const miopenTensorDescriptor_t* yDesc,

5453  void* y,

5454  const miopenTensorDescriptor_t hyDesc,

5455  void* hy,

5456  const miopenTensorDescriptor_t cyDesc,

5457  void* cy,

5458  void* workSpace,

5459  size_t workSpaceNumBytes);

5460 

5462 // CLOSEOUT RNN DOXYGEN GROUP

5463 

5472 typedef enum

5473 {

5474  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,

5475 } miopenCTCLossAlgo_t;

5476 

5483 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);

5484 

5494 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5495  miopenDataType_t* dataType,

5496  int* blank_label_id,

5497  bool* apply_softmax_layer);

5498 

5504 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);

5505 

5515 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5516  miopenDataType_t dataType,

5517  const int blank_label_id,

5518  bool apply_softmax_layer);

5519 

5536 MIOPEN_EXPORT miopenStatus_t

5537 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,

5538  const miopenTensorDescriptor_t probsDesc,

5539  const miopenTensorDescriptor_t gradientsDesc,

5540  const int* labels,

5541  const int* labelLengths,

5542  const int* inputLengths,

5543  miopenCTCLossAlgo_t algo,

5544  const miopenCTCLossDescriptor_t ctcLossDesc,

5545  size_t* workSpaceSize);

5546 

5566 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,

5567  const miopenTensorDescriptor_t probsDesc,

5568  const void* probs,

5569  const int* labels,

5570  const int* labelLengths,

5571  const int* inputLengths,

5572  void* losses,

5573  const miopenTensorDescriptor_t gradientsDesc,

5574  void* gradients,

5575  miopenCTCLossAlgo_t algo,

5576  const miopenCTCLossDescriptor_t ctcLossDesc,

5577  void* workSpace,

5578  size_t workSpaceSize);

5579 

5581 // CLOSEOUT LossFunction DOXYGEN GROUP

5582 

5583 // Dropout APIs

5592 typedef enum

5593 {

5594  MIOPEN_RNG_PSEUDO_XORWOW = 0,

5595 } miopenRNGType_t;

5596 

5602 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);

5603 

5609 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);

5610 

5619 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,

5620  size_t* reserveSpaceSizeInBytes);

5621 

5630 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,

5631  size_t* stateSizeInBytes);

5632 

5649 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5650  miopenHandle_t handle,

5651  float* dropout,

5652  void** states,

5653  unsigned long long* seed,

5654  bool* use_mask,

5655  bool* state_evo,

5656  miopenRNGType_t* rng_mode);

5657 

5680 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5681  miopenHandle_t handle,

5682  float dropout,

5683  void* states,

5684  size_t stateSizeInBytes,

5685  unsigned long long seed,

5686  bool use_mask,

5687  bool state_evo,

5688  miopenRNGType_t rng_mode);

5689 

5709 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5710  miopenHandle_t handle,

5711  float dropout,

5712  void* states,

5713  size_t stateSizeInBytes,

5714  unsigned long long seed,

5715  bool use_mask,

5716  bool state_evo,

5717  miopenRNGType_t rng_mode);

5718 

5736 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,

5737  const miopenDropoutDescriptor_t dropoutDesc,

5738  const miopenTensorDescriptor_t noise_shape,

5739  const miopenTensorDescriptor_t xDesc,

5740  const void* x,

5741  const miopenTensorDescriptor_t yDesc,

5742  void* y,

5743  void* reserveSpace,

5744  size_t reserveSpaceSizeInBytes);

5745 

5763 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,

5764  const miopenDropoutDescriptor_t dropoutDesc,

5765  const miopenTensorDescriptor_t noise_shape,

5766  const miopenTensorDescriptor_t dyDesc,

5767  const void* dy,

5768  const miopenTensorDescriptor_t dxDesc,

5769  void* dx,

5770  void* reserveSpace,

5771  size_t reserveSpaceSizeInBytes);

5772 

5774 // CLOSEOUT DROPOUT DOXYGEN GROUP

5775 

5776 // TensorReduce APIs

5787 MIOPEN_EXPORT miopenStatus_t

5788 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);

5789 

5795 MIOPEN_EXPORT miopenStatus_t

5796 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);

5797 

5810 MIOPEN_EXPORT miopenStatus_t

5811 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,

5812  miopenReduceTensorOp_t reduceTensorOp,

5813  miopenDataType_t reduceTensorCompType,

5814  miopenNanPropagation_t reduceTensorNanOpt,

5815  miopenReduceTensorIndices_t reduceTensorIndices,

5816  miopenIndicesType_t reduceTensorIndicesType);

5817 

5833 MIOPEN_EXPORT miopenStatus_t

5834 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,

5835  miopenReduceTensorOp_t* reduceTensorOp,

5836  miopenDataType_t* reduceTensorCompType,

5837  miopenNanPropagation_t* reduceTensorNanOpt,

5838  miopenReduceTensorIndices_t* reduceTensorIndices,

5839  miopenIndicesType_t* reduceTensorIndicesType);

5840 

5850 MIOPEN_EXPORT miopenStatus_t

5851 miopenGetReductionIndicesSize(miopenHandle_t handle,

5852  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5853  const miopenTensorDescriptor_t aDesc,

5854  const miopenTensorDescriptor_t cDesc,

5855  size_t* sizeInBytes);

5856 

5866 MIOPEN_EXPORT miopenStatus_t

5867 miopenGetReductionWorkspaceSize(miopenHandle_t handle,

5868  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5869  const miopenTensorDescriptor_t aDesc,

5870  const miopenTensorDescriptor_t cDesc,

5871  size_t* sizeInBytes);

5872 

5896 MIOPEN_EXPORT miopenStatus_t

5897 miopenReduceTensor(miopenHandle_t handle,

5898  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5899  void* indices,

5900  size_t indicesSizeInBytes,

5901  void* workspace,

5902  size_t workspaceSizeInBytes,

5903  const void* alpha,

5904  const miopenTensorDescriptor_t aDesc,

5905  const void* A,

5906  const void* beta,

5907  const miopenTensorDescriptor_t cDesc,

5908  void* C);

5909 

5911 // CLOSEOUT TensorReduce DOXYGEN GROUP

5912 

5913 // Find 2.0 API

5924 MIOPEN_DECLARE_OBJECT(miopenProblem);

5925 

5929 typedef enum

5930 {

5931  miopenProblemDirectionForward = 0,

5932  miopenProblemDirectionBackward = 1,

5933  miopenProblemDirectionBackwardWeights = 2,

5934 #ifdef MIOPEN_BETA_API

5935  miopenProblemDirectionInference = 4,

5936 #endif

5937 } miopenProblemDirection_t;

5938 

5942 typedef enum

5943 {

5944  miopenTensorArgumentIdInvalid = 0,

5945  miopenTensorConvolutionX = 1,

5946  miopenTensorConvolutionW = 2,

5947  miopenTensorConvolutionY = 3,

5948 

5949  miopenTensorMhaK = 4,

5950  miopenTensorMhaQ = 5,

5951  miopenTensorMhaV = 6,

5952  miopenTensorMhaDescaleK = 7,

5953  miopenTensorMhaDescaleQ = 8,

5954  miopenTensorMhaDescaleV = 9,

5955  miopenTensorMhaDescaleS = 10,

5956  miopenTensorMhaScaleS = 11,

5957  miopenTensorMhaScaleO = 12,

5958  miopenTensorMhaDropoutProbability = 13,

5959  miopenTensorMhaDropoutSeed = 14,

5960  miopenTensorMhaDropoutOffset = 15,

5961  miopenTensorMhaO = 16,

5962  miopenTensorMhaAmaxO = 17,

5963  miopenTensorMhaAmaxS = 18,

5964  miopenTensorMhaM = 19,

5965  miopenTensorMhaZInv = 20,

5966  miopenTensorMhaDO = 21,

5967  miopenTensorMhaDescaleO = 22,

5968  miopenTensorMhaDescaleDO = 23,

5969  miopenTensorMhaDescaleDS = 24,

5970  miopenTensorMhaScaleDS = 25,

5971  miopenTensorMhaScaleDQ = 26,

5972  miopenTensorMhaScaleDK = 27,

5973  miopenTensorMhaScaleDV = 28,

5974  miopenTensorMhaDQ = 29,

5975  miopenTensorMhaDK = 30,

5976  miopenTensorMhaDV = 31,

5977  miopenTensorMhaAmaxDQ = 32,

5978  miopenTensorMhaAmaxDK = 33,

5979  miopenTensorMhaAmaxDV = 34,

5980  miopenTensorMhaAmaxDS = 35,

5981  miopenTensorMhaBias = 36,

5982 

5983 #ifdef MIOPEN_BETA_API

5984  miopenTensorActivationX = 37,

5985  miopenTensorActivationY = 38,

5986  miopenTensorActivationDX = 39,

5987  miopenTensorActivationDY = 40,

5988  miopenTensorBiasX = 41,

5989  miopenTensorBiasY = 42,

5990  miopenTensorBias = 43,

5991  miopenTensorSoftmaxX = 44,

5992  miopenTensorSoftmaxY = 45,

5993  miopenTensorSoftmaxDX = 46,

5994  miopenTensorSoftmaxDY = 47,

5995  miopenTensorBatchnormX = 48,

5996  miopenTensorBatchnormY = 49,

5997  miopenTensorBatchnormRunningMean = 50,

5998  miopenTensorBatchnormRunningVariance = 51,

5999  miopenTensorBatchnormSavedMean = 52,

6000  miopenTensorBatchnormSavedVariance = 53,

6001  miopenTensorBatchnormScale = 54,

6002  miopenTensorBatchnormScaleDiff = 55,

6003  miopenTensorBatchnormEstimatedMean = 56,

6004  miopenTensorBatchnormEstimatedVariance = 57,

6005  miopenTensorBatchnormBias = 58,

6006  miopenTensorBatchnormBiasDiff = 59,

6007  miopenTensorBatchnormDX = 60,

6008  miopenTensorBatchnormDY = 61,

6009 #endif

6010 

6011  miopenTensorArgumentIsScalar = 1U << 31,

6012 

6013  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,

6014 #ifdef MIOPEN_BETA_API

6015  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,

6016  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,

6017 #endif

6018 } miopenTensorArgumentId_t;

6019 

6023 typedef enum

6024 {

6025  miopenFindResultsOrderByTime = 0,

6026  miopenFindResultsOrderByWorkspaceSize = 1,

6027 } miopenFindResultsOrder_t;

6028 

6036 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,

6037  miopenConvolutionDescriptor_t operatorDesc,

6038  miopenProblemDirection_t direction);

6039 

6051 typedef enum

6052 {

6053  miopenMhaMaskNone = 0,

6054  miopenMhaMaskCausal = 1,

6055 } miopenMhaMask_t;

6056 

6057 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,

6058  miopenMhaDescriptor_t operatorDesc,

6059  miopenProblemDirection_t direction);

6060 

6067 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);

6068 

6078 MIOPEN_EXPORT miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale);

6079 

6089 MIOPEN_EXPORT miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float* scale);

6090 

6097 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);

6098 

6110 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,

6111  float alpha,

6112  float beta,

6113  miopenSoftmaxAlgorithm_t algorithm,

6114  miopenSoftmaxMode_t mode);

6115 

6127 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,

6128  float* alpha,

6129  float* beta,

6130  miopenSoftmaxAlgorithm_t* algorithm,

6131  miopenSoftmaxMode_t* mode);

6132 

6138 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);

6139 

6147 MIOPEN_EXPORT miopenStatus_t

6148 miopenSetProblemTensorDescriptor(miopenProblem_t problem,

6149  miopenTensorArgumentId_t id,

6150  const miopenTensorDescriptor_t descriptor);

6151 

6154 MIOPEN_DECLARE_OBJECT(miopenFindOptions);

6155 

6161 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);

6162 

6168 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);

6169 

6176 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value);

6177 

6184 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,

6185  miopenFindResultsOrder_t value);

6186 

6194 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,

6195  size_t value);

6196 

6204 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,

6205  void* buffer,

6206  size_t size);

6207 

6216 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,

6217  miopenTensorArgumentId_t id,

6218  void* buffer);

6219 

6227 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,

6228  unsigned attach);

6229 

6232 MIOPEN_DECLARE_OBJECT(miopenSolution);

6233 

6245 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,

6246  miopenProblem_t problem,

6247  miopenFindOptions_t options,

6248  miopenSolution_t* solutions,

6249  size_t* numSolutions,

6250  size_t maxSolutions);

6251 

6254 struct miopenTensorArgument_t

6255 {

6256  /* @brief Identifier of the tensor argument.

6257  */

6258  miopenTensorArgumentId_t id;

6259  /* @brief Tensor descriptor to override the value stored in the solution.

6260  *

6261  * Some solvers may support overriding input and output tensor descriptors, but right now there

6262  * is no way to tell from the API. Intended for the future use.

6263  */

6264  miopenTensorDescriptor_t* descriptor;

6265  /* @brief Pointer to the device memory buffer to use for the operation or to the host memory if

6266  * the value is scalar.

6267  */

6268  void* buffer;

6269 };

6270 

6282 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,

6283  miopenSolution_t solution,

6284  size_t nInputs,

6285  const miopenTensorArgument_t* tensors,

6286  void* workspace,

6287  size_t workspaceSize);

6288 

6294 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);

6295 

6303 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,

6304  const char* data,

6305  size_t size);

6306 

6313 MIOPEN_EXPORT miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data);

6314 

6321 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size);

6322 

6329 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,

6330  size_t* workspaceSize);

6331 

6338 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time);

6339 

6346 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,

6347  uint64_t* solverId);

6348 

6355 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,

6356  miopenConvAlgorithm_t* result);

6357 

6358 #ifdef MIOPEN_BETA_API

6359 

6368 MIOPEN_EXPORT miopenStatus_t

6369 miopenCreateActivationProblem(miopenProblem_t* problem,

6370  miopenActivationDescriptor_t operatorDesc,

6371  miopenProblemDirection_t direction);

6372 

6381 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,

6382  miopenBatchNormMode_t mode,

6383  bool runningMeanVariance,

6384  miopenProblemDirection_t direction);

6385 

6405 MIOPEN_EXPORT miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2);

6406 

6414 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,

6415  miopenProblemDirection_t direction);

6416 

6425 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,

6426  miopenSoftmaxDescriptor_t operatorDesc,

6427  miopenProblemDirection_t direction);

6428 

6429 #endif

6430 

6432 // CLOSEOUT find2 DOXYGEN GROUP

6433 

6434 #ifdef MIOPEN_BETA_API

6435 

6440 typedef enum

6441 {

6442  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,

6443  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =

6444  1,

6445 } miopenReduceCalculationNanPropagation_t;

6446 

6447 // ReduceCalculation APIs

6456 typedef enum

6457 {

6458  MIOPEN_REDUCE_CALCULATION_PROD =

6459  1,

6460  MIOPEN_REDUCE_CALCULATION_SUM =

6461  2,

6462 } miopenReduceCalculationOp_t;

6463 

6473 MIOPEN_EXPORT miopenStatus_t

6474 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,

6475  const miopenTensorDescriptor_t xDesc,

6476  const int32_t dim,

6477  const miopenReduceCalculationOp_t reduceCalculationOp,

6478  const miopenTensorDescriptor_t reduceDesc,

6479  size_t* sizeInBytes);

6480 

6494 MIOPEN_EXPORT miopenStatus_t

6495 miopenReduceCalculationForward(miopenHandle_t handle,

6496  miopenReduceCalculationNanPropagation_t nanPropagation,

6497  void* workspace,

6498  size_t workspaceSizeInBytes,

6499  const miopenTensorDescriptor_t xDesc,

6500  const void* x,

6501  const int32_t dim,

6502  const miopenReduceCalculationOp_t reduceCalculationOp,

6503  const miopenTensorDescriptor_t reduceDesc,

6504  void* y);

6505 

6507 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP

6508 #endif // MIOPEN_BETA_API

6509 

6510 #ifdef MIOPEN_BETA_API

6511 

6516 typedef enum

6517 {

6518  MIOPEN_REDUCE_EXTREME_ARGMIN =

6519  1,

6520  MIOPEN_REDUCE_EXTREME_ARGMAX =

6521  2,

6522  MIOPEN_REDUCE_EXTREME_MIN =

6523  3,

6524  MIOPEN_REDUCE_EXTREME_MAX =

6525  4,

6526 } miopenReduceExtremeOp_t;

6527 

6528 // ReduceExtreme APIs

6548 MIOPEN_EXPORT miopenStatus_t

6549 miopenReduceExtremeForward(miopenHandle_t handle,

6550  const miopenTensorDescriptor_t xDesc,

6551  const void* x,

6552  const int32_t dim,

6553  const miopenReduceExtremeOp_t reduceExtremeOp,

6554  const miopenTensorDescriptor_t yDesc,

6555  void* y,

6556  const miopenTensorDescriptor_t indiceDesc,

6557  void* indice);

6558 

6560 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP

6561 #endif // MIOPEN_BETA_API

6562 

6563 #ifdef MIOPEN_BETA_API

6564 // GroupNorm APIs

6589 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,

6590  miopenNormMode_t mode,

6591  const miopenTensorDescriptor_t xDesc,

6592  const void* x,

6593  const miopenTensorDescriptor_t weightDesc,

6594  const void* weight,

6595  const miopenTensorDescriptor_t biasDesc,

6596  const void* bias,

6597  const uint64_t num_groups,

6598  const float epsilon,

6599  const miopenTensorDescriptor_t yDesc,

6600  void* y,

6601  const miopenTensorDescriptor_t meanDesc,

6602  void* mean,

6603  const miopenTensorDescriptor_t rstdDesc,

6604  void* rstd);

6605 

6607 // CLOSEOUT groupnorm DOXYGEN GROUP

6608 #endif // MIOPEN_BETA_API

6609 

6610 #ifdef MIOPEN_BETA_API

6611 // LayerNorm APIs

6638 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,

6639  miopenNormMode_t mode,

6640  const miopenTensorDescriptor_t xDesc,

6641  const void* x,

6642  const miopenTensorDescriptor_t x2Desc,

6643  const void* x2,

6644  const miopenTensorDescriptor_t weightDesc,

6645  const void* weight,

6646  const miopenTensorDescriptor_t biasDesc,

6647  const void* bias,

6648  const float epsilon,

6649  const int32_t normalized_dim,

6650  const miopenTensorDescriptor_t yDesc,

6651  void* y,

6652  const miopenTensorDescriptor_t meanDesc,

6653  void* mean,

6654  const miopenTensorDescriptor_t rstdDesc,

6655  void* rstd);

6656 

6658 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6659 #endif // MIOPEN_BETA_API

6660 

6661 #ifdef MIOPEN_BETA_API

6662 // LayerNorm APIs

6682 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,

6683  miopenNormMode_t mode,

6684  const miopenTensorDescriptor_t xDesc,

6685  const void* x,

6686  const miopenTensorDescriptor_t weightDesc,

6687  const void* weight,

6688  const float epsilon,

6689  const miopenTensorDescriptor_t yDesc,

6690  void* y,

6691  const miopenTensorDescriptor_t rstdDesc,

6692  void* rstd);

6693 

6708 MIOPEN_EXPORT miopenStatus_t

6709 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,

6710  miopenNormMode_t mode,

6711  const miopenTensorDescriptor_t dyDesc,

6712  const miopenTensorDescriptor_t xDesc,

6713  const miopenTensorDescriptor_t weightDesc,

6714  const miopenTensorDescriptor_t rstdDesc,

6715  const miopenTensorDescriptor_t dxDesc,

6716  const miopenTensorDescriptor_t dwDesc,

6717  size_t* sizeInBytes);

6718 

6739 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,

6740  miopenNormMode_t mode,

6741  void* workspace,

6742  size_t workspaceSizeInBytes,

6743  const miopenTensorDescriptor_t dyDesc,

6744  const void* dy,

6745  const miopenTensorDescriptor_t xDesc,

6746  const void* x,

6747  const miopenTensorDescriptor_t weightDesc,

6748  const void* weight,

6749  const miopenTensorDescriptor_t rstdDesc,

6750  const void* rstd,

6751  const miopenTensorDescriptor_t dxDesc,

6752  void* dx,

6753  const miopenTensorDescriptor_t dwDesc,

6754  void* dw);

6756 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6757 #endif // MIOPEN_BETA_API

6758 

6759 #ifdef MIOPEN_BETA_API

6760 // Graph API

6772 typedef enum

6773 {

6774  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,

6775  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,

6776  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,

6777  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,

6778  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,

6779  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,

6780  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,

6781  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,

6782  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,

6783  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,

6784  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,

6785  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,

6786  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,

6787  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,

6788  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,

6789  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,

6790  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,

6791  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,

6792  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,

6793  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,

6794  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,

6795  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,

6796  MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,

6797  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,

6798  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,

6799  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,

6800  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,

6801  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,

6802  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,

6803  MIOPEN_BACKEND_RNG_DESCRIPTOR,

6804  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,

6805  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,

6806 } miopenBackendDescriptorType_t;

6807 

6815 typedef enum

6816 {

6817  MIOPEN_ATTR_POINTWISE_MODE = 0,

6818  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,

6819  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,

6820  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,

6821  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,

6822  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,

6823  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,

6824  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,

6825  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,

6826  MIOPEN_ATTR_POINTWISE_AXIS = 9,

6827 

6828  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,

6829  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,

6830  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,

6831  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,

6832  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,

6833  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,

6834  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,

6835 

6836  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,

6837  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,

6838  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,

6839  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,

6840 

6841  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,

6842  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,

6843  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,

6844 

6845  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,

6846  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,

6847  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,

6848  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,

6849  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,

6850  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,

6851 

6852  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,

6853  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,

6854  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,

6855  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,

6856 

6857  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,

6858  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,

6859 

6860  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,

6861  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,

6862  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,

6863  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,

6864  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,

6865  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,

6866  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,

6867  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,

6868  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,

6869  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,

6870  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,

6871  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,

6872  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,

6873  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,

6874  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,

6875  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,

6876  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,

6877  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,

6878  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,

6879  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,

6880  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,

6881  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,

6882  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,

6883  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,

6884  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,

6885  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,

6886  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,

6887 

6888  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,

6889  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,

6890  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,

6891  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,

6892  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,

6893 

6894  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,

6895  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,

6896  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,

6897  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,

6898  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,

6899  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,

6900  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,

6901  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,

6902  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,

6903  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,

6904  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,

6905  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,

6906  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,

6907  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,

6908  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,

6909  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,

6910  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,

6911 

6912  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,

6913  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,

6914  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,

6915 

6916  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,

6917  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,

6918  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,

6919  MIOPEN_ATTR_TENSOR_STRIDES = 903,

6920  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,

6921  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,

6922  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,

6923  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,

6924  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,

6925  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,

6926  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,

6927 

6928  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,

6929  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,

6930  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,

6931  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,

6932 

6933  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,

6934  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,

6935 

6936  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,

6937  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,

6938  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,

6939  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,

6940 

6941  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,

6942  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,

6943  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,

6944  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,

6945  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,

6946  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,

6947  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,

6948 

6949  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,

6950  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,

6951 

6952  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,

6953  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,

6954  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,

6955  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,

6956  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,

6957  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,

6958  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,

6959  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,

6960 

6961  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,

6962  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,

6963 

6964  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,

6965  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,

6966  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,

6967 

6968  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,

6969  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,

6970  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,

6971  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,

6972  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,

6973  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,

6974  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,

6975  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,

6976  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,

6977  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,

6978  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,

6979 

6980  MIOPEN_ATTR_RESAMPLE_MODE = 1700,

6981  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,

6982  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,

6983  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,

6984  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,

6985  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,

6986  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,

6987  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,

6988  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,

6989 

6990  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,

6991  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,

6992  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,

6993  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,

6994  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,

6995  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,

6996 

6997  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,

6998  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,

6999  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,

7000  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,

7001  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,

7002  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,

7003  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,

7004  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,

7005 

7006  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,

7007  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,

7008  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,

7009  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,

7010 

7011  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,

7012  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,

7013  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,

7014  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,

7015  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,

7016 

7017  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,

7018  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,

7019  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,

7020  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,

7021  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,

7022  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,

7023  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,

7024  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,

7025  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,

7026  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,

7027  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,

7028  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,

7029  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,

7030  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,

7031  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,

7032 

7033  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,

7034  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,

7035  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,

7036  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,

7037  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,

7038  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,

7039  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,

7040  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,

7041  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,

7042  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,

7043  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,

7044 

7045  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,

7046  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,

7047 

7048  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,

7049  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,

7050  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,

7051  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,

7052  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,

7053  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,

7054 

7055  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,

7056  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,

7057  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,

7058  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,

7059 

7060 } miopenBackendAttributeName_t;

7061 

7069 typedef enum

7070 {

7071  MIOPEN_TYPE_HANDLE = 0,

7072  MIOPEN_TYPE_DATA_TYPE,

7073  MIOPEN_TYPE_BOOLEAN,

7074  MIOPEN_TYPE_INT64,

7075  MIOPEN_TYPE_FLOAT,

7076  MIOPEN_TYPE_DOUBLE,

7077  MIOPEN_TYPE_VOID_PTR,

7078  MIOPEN_TYPE_CONVOLUTION_MODE,

7079  MIOPEN_TYPE_HEUR_MODE,

7080  MIOPEN_TYPE_KNOB_TYPE,

7081  MIOPEN_TYPE_NAN_PROPOGATION,

7082  MIOPEN_TYPE_NUMERICAL_NOTE,

7083  MIOPEN_TYPE_LAYOUT_TYPE,

7084  MIOPEN_TYPE_ATTRIB_NAME,

7085  MIOPEN_TYPE_POINTWISE_MODE,

7086  MIOPEN_TYPE_BACKEND_DESCRIPTOR,

7087  MIOPEN_TYPE_GENSTATS_MODE,

7088  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,

7089  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,

7090  MIOPEN_TYPE_BEHAVIOR_NOTE,

7091  MIOPEN_TYPE_TENSOR_REORDERING_MODE,

7092  MIOPEN_TYPE_RESAMPLE_MODE,

7093  MIOPEN_TYPE_PADDING_MODE,

7094  MIOPEN_TYPE_INT32,

7095  MIOPEN_TYPE_CHAR,

7096  MIOPEN_TYPE_SIGNAL_MODE,

7097  MIOPEN_TYPE_FRACTION,

7098  MIOPEN_TYPE_NORM_MODE,

7099  MIOPEN_TYPE_NORM_FWD_PHASE,

7100  MIOPEN_TYPE_RNG_DISTRIBUTION

7101 } miopenBackendAttributeType_t;

7102 

7108 typedef enum

7109 {

7111  MIOPEN_POINTWISE_ADD,

7112 

7115  MIOPEN_POINTWISE_ADD_SQUARE,

7116 

7118  MIOPEN_POINTWISE_DIV,

7119 

7121  MIOPEN_POINTWISE_MAX,

7122 

7124  MIOPEN_POINTWISE_MIN,

7125 

7128  MIOPEN_POINTWISE_MOD,

7129 

7131  MIOPEN_POINTWISE_MUL,

7132 

7134  MIOPEN_POINTWISE_POW,

7135 

7137  MIOPEN_POINTWISE_SUB,

7138 

7140  MIOPEN_POINTWISE_ABS,

7141 

7143  MIOPEN_POINTWISE_CEIL,

7144 

7146  MIOPEN_POINTWISE_COS,

7147 

7149  MIOPEN_POINTWISE_EXP,

7150 

7152  MIOPEN_POINTWISE_FLOOR,

7153 

7155  MIOPEN_POINTWISE_LOG,

7156 

7158  MIOPEN_POINTWISE_NEG,

7159 

7161  MIOPEN_POINTWISE_RSQRT,

7162 

7164  MIOPEN_POINTWISE_SIN,

7165 

7167  MIOPEN_POINTWISE_SQRT,

7168 

7170  MIOPEN_POINTWISE_TAN,

7171 

7173  MIOPEN_POINTWISE_ERF,

7174 

7178  MIOPEN_POINTWISE_IDENTITY,

7179 

7181  MIOPEN_POINTWISE_RELU_FWD,

7182 

7184  MIOPEN_POINTWISE_TANH_FWD,

7185 

7187  MIOPEN_POINTWISE_SIGMOID_FWD,

7188 

7190  MIOPEN_POINTWISE_ELU_FWD,

7191 

7194  MIOPEN_POINTWISE_GELU_FWD,

7195 

7197  MIOPEN_POINTWISE_SOFTPLUS_FWD,

7198 

7200  MIOPEN_POINTWISE_SWISH_FWD,

7201 

7205  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,

7206 

7209  MIOPEN_POINTWISE_RELU_BWD,

7210 

7212  MIOPEN_POINTWISE_TANH_BWD,

7213 

7215  MIOPEN_POINTWISE_SIGMOID_BWD,

7216 

7219  MIOPEN_POINTWISE_ELU_BWD,

7220 

7223  MIOPEN_POINTWISE_GELU_BWD,

7224 

7226  MIOPEN_POINTWISE_SOFTPLUS_BWD,

7227 

7229  MIOPEN_POINTWISE_SWISH_BWD,

7230 

7236  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,

7237 

7239  MIOPEN_POINTWISE_CMP_EQ,

7240 

7242  MIOPEN_POINTWISE_CMP_NEQ,

7243 

7245  MIOPEN_POINTWISE_CMP_GT,

7246 

7249  MIOPEN_POINTWISE_CMP_GE,

7250 

7252  MIOPEN_POINTWISE_CMP_LT,

7253 

7256  MIOPEN_POINTWISE_CMP_LE,

7257 

7259  MIOPEN_POINTWISE_LOGICAL_AND,

7260 

7262  MIOPEN_POINTWISE_LOGICAL_OR,

7263 

7265  MIOPEN_POINTWISE_LOGICAL_NOT,

7266 

7268  MIOPEN_POINTWISE_GEN_INDEX,

7269 

7272  MIOPEN_POINTWISE_BINARY_SELECT,

7273 

7276  MIOPEN_POINTWISE_RECIPROCAL

7277 } miopenPointwiseMode_t;

7278 

7284 typedef enum

7285 {

7286  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,

7287  MIOPEN_RNG_DISTRIBUTION_UNIFORM,

7288  MIOPEN_RNG_DISTRIBUTION_NORMAL,

7289 } miopenRngDistribution_t;

7290 

7291 typedef enum

7292 {

7293  /* IDENTITY alpha = 1.0 and beta = 0.0 */

7294  /* SCALE alpha = 4.2 and beta = 0.0 */

7295  /* BILINEAR alpha = 3.2 and beta = 1.1 */

7296  /* ERROR_STATE alpha = 0.0 and beta = 3.1 */

7297 

7298  DEFAULT = 0, /* alpha = 1.0 and beta = 0.0.*/

7299  SCALE = 1, /* alpha with some value and beta 0.0*/

7300  BILINEAR = 2, /* both alpha and beta with some value*/

7301  ERROR_STATE = 3, /* alpha 0.0 and beta with some value, this should not occur.

7302  But used to check for errors.*/

7303 } miopenAlphaBetaCase_t;

7308 typedef enum

7309 {

7310  MIOPEN_HEUR_MODE_INSTANT = 0,

7311  MIOPEN_HEUR_MODE_B = 1,

7312  MIOPEN_HEUR_MODE_FALLBACK = 2,

7313  MIOPEN_HEUR_MODE_A = 3,

7314  MIOPEN_HEUR_MODES_COUNT = 4,

7315 } miopenBackendHeurMode_t;

7316 

7329 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)

7330 

7331 

7344 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(

7345  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);

7346 

7376 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,

7377  miopenBackendAttributeName_t attributeName,

7378  miopenBackendAttributeType_t attributeType,

7379  int64_t elementCount,

7380  void* arrayOfElements);

7381 

7398 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);

7399 

7434 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,

7435  miopenBackendAttributeName_t attributeName,

7436  miopenBackendAttributeType_t attributeType,

7437  int64_t requestedElementCount,

7438  int64_t* elementCount,

7439  void* arrayOfElements);

7440 

7460 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,

7461  miopenBackendDescriptor_t executionPlan,

7462  miopenBackendDescriptor_t variantPack);

7463 

7480 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);

7481 

7499 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,

7500  miopenBackendDescriptorType_t descriptorType,

7501  size_t sizeInBytes);

7502 

7504 // CLOSEOUT BackendAPI DOXYGEN GROUP

7505 #endif // MIOPEN_BETA_API

7506 

7507 #ifdef MIOPEN_BETA_API

7508 // FusedAdam APIs

7651 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,

7652  const miopenTensorDescriptor_t paramDesc,

7653  void* param,

7654  const miopenTensorDescriptor_t gradDesc,

7655  const void* grad,

7656  const miopenTensorDescriptor_t expAvgDesc,

7657  void* expAvg,

7658  const miopenTensorDescriptor_t expAvgSqDesc,

7659  void* expAvgSq,

7660  const miopenTensorDescriptor_t maxExpAvgSqDesc,

7661  void* maxExpAvgSq,

7662  const miopenTensorDescriptor_t stateStepDesc,

7663  void* stateStep,

7664  const unsigned int state_step,

7665  const float lr,

7666  const float beta1,

7667  const float beta2,

7668  const float weight_decay,

7669  const float eps,

7670  const bool amsgrad,

7671  const bool maximize,

7672  const bool adamw,

7673  const miopenTensorDescriptor_t gradScaleDesc,

7674  const void* gradScale,

7675  const miopenTensorDescriptor_t foundInfDesc,

7676  const void* foundInf);

7677 

7818 MIOPEN_EXPORT miopenStatus_t

7819 miopenFusedAdamWithOutput(miopenHandle_t handle,

7820  const miopenTensorDescriptor_t paramInDesc,

7821  void* paramIn,

7822  const miopenTensorDescriptor_t paramOutDesc,

7823  void* paramOut,

7824  const miopenTensorDescriptor_t paramOutFloat16Desc,

7825  void* paramOutFloat16,

7826  const miopenTensorDescriptor_t gradInDesc,

7827  const void* gradIn,

7828  const miopenTensorDescriptor_t expAvgInDesc,

7829  void* expAvgIn,

7830  const miopenTensorDescriptor_t expAvgOutDesc,

7831  void* expAvgOut,

7832  const miopenTensorDescriptor_t expAvgSqInDesc,

7833  void* expAvgSqIn,

7834  const miopenTensorDescriptor_t expAvgSqOutDesc,

7835  void* expAvgSqOut,

7836  const miopenTensorDescriptor_t maxExpAvgSqInDesc,

7837  void* maxExpAvgSqIn,

7838  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,

7839  void* maxExpAvgSqOut,

7840  const miopenTensorDescriptor_t stateStepInDesc,

7841  void* stateStepIn,

7842  const miopenTensorDescriptor_t stateStepOutDesc,

7843  void* stateStepOut,

7844  const unsigned int state_step,

7845  const float lr,

7846  const float beta1,

7847  const float beta2,

7848  const float weight_decay,

7849  const float eps,

7850  const bool amsgrad,

7851  const bool maximize,

7852  const bool adamw,

7853  const miopenTensorDescriptor_t gradScaleDesc,

7854  const void* gradScale,

7855  const miopenTensorDescriptor_t foundInfDesc,

7856  const void* foundInf);

7857 

7859 // CLOSEOUT SGD DOXYGEN GROUP

7860 #endif // MIOPEN_BETA_API

7861 

7862 #ifdef MIOPEN_BETA_API

7863 // TransformersAdamW APIs

7954 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,

7955  const miopenTensorDescriptor_t paramDesc,

7956  void* param,

7957  const miopenTensorDescriptor_t gradDesc,

7958  const void* grad,

7959  const miopenTensorDescriptor_t expAvgDesc,

7960  void* expAvg,

7961  const miopenTensorDescriptor_t expAvgSqDesc,

7962  void* expAvgSq,

7963  const miopenTensorDescriptor_t stateStepDesc,

7964  void* stateStep,

7965  const unsigned int state_step,

7966  const float lr,

7967  const float beta1,

7968  const float beta2,

7969  const float weight_decay,

7970  const float eps,

7971  const bool correct_bias,

7972  const miopenTensorDescriptor_t gradScaleDesc,

7973  const void* gradScale,

7974  const miopenTensorDescriptor_t foundInfDesc,

7975  const void* foundInf);

7976 

8103 MIOPEN_EXPORT miopenStatus_t

8104 miopenTransformersAdamWWithOutput(miopenHandle_t handle,

8105  const miopenTensorDescriptor_t paramInDesc,

8106  void* paramIn,

8107  const miopenTensorDescriptor_t paramOutDesc,

8108  void* paramOut,

8109  const miopenTensorDescriptor_t paramOutFloat16Desc,

8110  void* paramOutFloat16,

8111  const miopenTensorDescriptor_t gradInDesc,

8112  const void* gradIn,

8113  const miopenTensorDescriptor_t expAvgInDesc,

8114  void* expAvgIn,

8115  const miopenTensorDescriptor_t expAvgOutDesc,

8116  void* expAvgOut,

8117  const miopenTensorDescriptor_t expAvgSqInDesc,

8118  void* expAvgSqIn,

8119  const miopenTensorDescriptor_t expAvgSqOutDesc,

8120  void* expAvgSqOut,

8121  const miopenTensorDescriptor_t stateStepInDesc,

8122  void* stateStepIn,

8123  const miopenTensorDescriptor_t stateStepOutDesc,

8124  void* stateStepOut,

8125  const unsigned int state_step,

8126  const float lr,

8127  const float beta1,

8128  const float beta2,

8129  const float weight_decay,

8130  const float eps,

8131  const float step_size,

8132  const bool correct_bias,

8133  const miopenTensorDescriptor_t gradScaleDesc,

8134  const void* gradScale,

8135  const miopenTensorDescriptor_t foundInfDesc,

8136  const void* foundInf);

8137 

8139 // CLOSEOUT SGD DOXYGEN GROUP

8140 #endif // MIOPEN_BETA_API

8141 

8142 #ifdef MIOPEN_BETA_API

8143 // GetItem APIs

8156 MIOPEN_EXPORT miopenStatus_t

8157 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,

8158  uint32_t indexCount,

8159  const miopenTensorDescriptor_t* indexDescs,

8160  size_t* sizeInBytes);

8161 

8186 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,

8187  void* workspace,

8188  size_t workspaceSizeInBytes,

8189  const miopenTensorDescriptor_t dyDesc,

8190  const void* dy,

8191  uint32_t indexCount,

8192  const miopenTensorDescriptor_t* indexDescs,

8193  const void* const* indexs,

8194  const miopenTensorDescriptor_t dxDesc,

8195  void* dx,

8196  const miopenTensorDescriptor_t errorDesc,

8197  void* error,

8198  uint32_t dimCount,

8199  const int32_t* dims,

8200  uint32_t sliceCount,

8201  const int32_t* slices,

8202  uint32_t offset);

8203 

8205 // CLOSEOUT GETITEM DOXYGEN GROUP

8206 #endif // MIOPEN_BETA_API

8207 

8208 #ifdef MIOPEN_BETA_API

8209 // RotaryPositionalEmbeddings APIs

8227 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,

8228  const miopenTensorDescriptor_t xDesc,

8229  const void* x,

8230  const miopenTensorDescriptor_t cosDesc,

8231  const void* cos,

8232  const miopenTensorDescriptor_t sinDesc,

8233  const void* sin,

8234  const miopenTensorDescriptor_t yDesc,

8235  void* y);

8236 

8250 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,

8251  const miopenTensorDescriptor_t dyDesc,

8252  const void* dy,

8253  const miopenTensorDescriptor_t cosDesc,

8254  const void* cos,

8255  const miopenTensorDescriptor_t sinDesc,

8256  const void* sin,

8257  const miopenTensorDescriptor_t dxDesc,

8258  void* dx);

8260 // CLOSEOUT ROPE DOXYGEN GROUP

8261 // kthvalue APIs

8282 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,

8283  miopenTensorDescriptor_t inputDesc,

8284  const void* input,

8285  miopenTensorDescriptor_t outputDesc,

8286  void* output,

8287  miopenTensorDescriptor_t indicesDesc,

8288  size_t* indices,

8289  size_t k,

8290  int32_t dim = -1,

8291  bool keepDim = false);

8292 

8294 // CLOSEOUT kthvalue DOXYGEN GROUP

8295 #endif // MIOPEN_BETA_API

8296 

8297 #ifdef MIOPEN_BETA_API

8311 MIOPEN_EXPORT miopenStatus_t

8312 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,

8313  miopenTensorDescriptor_t inputDesc,

8314  miopenTensorDescriptor_t weightDesc,

8315  size_t* sizeInBytes);

8316 

8333 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,

8334  void* workspace,

8335  size_t workspaceSizeInBytes,

8336  miopenTensorDescriptor_t inputDesc,

8337  const void* input,

8338  miopenTensorDescriptor_t weightDesc,

8339  const void* weight,

8340  miopenTensorDescriptor_t doutputDesc,

8341  const void* doutput,

8342  miopenTensorDescriptor_t dinputDesc,

8343  void* dinput,

8344  miopenTensorDescriptor_t dweightDesc,

8345  void* dweight);

8346 

8348 // CLOSEOUT RELU DOXYGEN GROUP

8349 #endif // MIOPEN_BETA_API

8350 

8351 #ifdef MIOPEN_BETA_API

8352 

8357 typedef enum

8358 {

8359  MIOPEN_LOSS_REDUCTION_NONE = 0,

8360  MIOPEN_LOSS_REDUCTION_SUM = 1,

8361  MIOPEN_LOSS_REDUCTION_MEAN = 2,

8363 } miopenLossReductionMode_t;

8364 

8365 // SoftMarginLoss APIs

8383 MIOPEN_EXPORT miopenStatus_t

8384 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,

8385  miopenTensorDescriptor_t inputDesc,

8386  miopenTensorDescriptor_t targetDesc,

8387  miopenTensorDescriptor_t outputDesc,

8388  miopenLossReductionMode_t reduction,

8389  size_t* sizeInBytes);

8390 

8407 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,

8408  miopenTensorDescriptor_t inputDesc,

8409  const void* input,

8410  miopenTensorDescriptor_t targetDesc,

8411  const void* target,

8412  miopenTensorDescriptor_t outputDesc,

8413  void* output,

8414  miopenLossReductionMode_t reduction,

8415  void* workspace = nullptr,

8416  size_t workspaceSizeInBytes = 0);

8417 

8432 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,

8433  miopenTensorDescriptor_t inputDesc,

8434  const void* input,

8435  miopenTensorDescriptor_t targetDesc,

8436  const void* target,

8437  miopenTensorDescriptor_t doutputDesc,

8438  const void* doutput,

8439  miopenTensorDescriptor_t dinputDesc,

8440  void* dinput,

8441  miopenLossReductionMode_t reduction);

8442 

8444 // CLOSEOUT LossFunction DOXYGEN GROUP

8445 #endif

8446 

8447 #ifdef MIOPEN_BETA_API

8448 // MultiMarginLoss APIs

8472 MIOPEN_EXPORT miopenStatus_t

8473 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,

8474  miopenTensorDescriptor_t inputDesc,

8475  miopenTensorDescriptor_t targetDesc,

8476  miopenTensorDescriptor_t weightDesc,

8477  miopenTensorDescriptor_t outputDesc,

8478  long p,

8479  float margin,

8480  miopenLossReductionMode_t reduction,

8481  size_t* sizeInBytes);

8482 

8510 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,

8511  miopenTensorDescriptor_t inputDesc,

8512  const void* input,

8513  miopenTensorDescriptor_t targetDesc,

8514  const void* target,

8515  miopenTensorDescriptor_t weightDesc,

8516  const void* weight,

8517  miopenTensorDescriptor_t outputDesc,

8518  void* output,

8519  long p,

8520  float margin,

8521  miopenLossReductionMode_t reduction,

8522  void* workspace,

8523  size_t workspaceSizeInBytes);

8524 

8526 // CLOSEOUT LossFunction DOXYGEN GROUP

8527 #endif // MIOPEN_BETA_API

8528 

8540 typedef enum

8541 {

8542  miopenTuningPolicyNone = 1,

8543  miopenTuningPolicyDbUpdate = 2,

8544  miopenTuningPolicySearch = 3,

8545  miopenTuningPolicySearchDbUpdate = 4,

8546  miopenTuningPolicyDbClean = 5,

8547 } miopenTuningPolicy_t;

8548 

8557 MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,

8558  miopenTuningPolicy_t newValue);

8559 

8567 MIOPEN_EXPORT miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle,

8568  miopenTuningPolicy_t* value);

8569 

8570 #ifdef __cplusplus

8571 }

8572 #endif

8573 

8574 #ifdef __clang__

8575 #pragma clang diagnostic pop

8576 #endif

8577 

8578 #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:3615

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:3617

miopenVerticalFusion

@ miopenVerticalFusion

Definition: miopen.h:3616

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:7309

miopenPointwiseMode_t

miopenPointwiseMode_t

Intended poinwise math operation for a pointwise operation descriptor.

Definition: miopen.h:7109

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:6816

miopenRngDistribution_t

miopenRngDistribution_t

Distribution for random number generation.

Definition: miopen.h:7285

miopenBackendDescriptorType_t

miopenBackendDescriptorType_t

Descriptor type.

Definition: miopen.h:6773

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:7292

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:7070

MIOPEN_HEUR_MODE_INSTANT

@ MIOPEN_HEUR_MODE_INSTANT

Definition: miopen.h:7310

MIOPEN_HEUR_MODE_A

@ MIOPEN_HEUR_MODE_A

Definition: miopen.h:7313

MIOPEN_HEUR_MODE_B

@ MIOPEN_HEUR_MODE_B

Definition: miopen.h:7311

MIOPEN_HEUR_MODES_COUNT

@ MIOPEN_HEUR_MODES_COUNT

Definition: miopen.h:7314

MIOPEN_HEUR_MODE_FALLBACK

@ MIOPEN_HEUR_MODE_FALLBACK

Definition: miopen.h:7312

MIOPEN_POINTWISE_SOFTPLUS_FWD

@ MIOPEN_POINTWISE_SOFTPLUS_FWD

Definition: miopen.h:7197

MIOPEN_POINTWISE_ELU_FWD

@ MIOPEN_POINTWISE_ELU_FWD

Definition: miopen.h:7190

MIOPEN_POINTWISE_RELU_FWD

@ MIOPEN_POINTWISE_RELU_FWD

Definition: miopen.h:7181

MIOPEN_POINTWISE_DIV

@ MIOPEN_POINTWISE_DIV

Definition: miopen.h:7118

MIOPEN_POINTWISE_SIGMOID_BWD

@ MIOPEN_POINTWISE_SIGMOID_BWD

Definition: miopen.h:7215

MIOPEN_POINTWISE_POW

@ MIOPEN_POINTWISE_POW

Definition: miopen.h:7134

MIOPEN_POINTWISE_MOD

@ MIOPEN_POINTWISE_MOD

Definition: miopen.h:7128

MIOPEN_POINTWISE_SQRT

@ MIOPEN_POINTWISE_SQRT

Definition: miopen.h:7167

MIOPEN_POINTWISE_BINARY_SELECT

@ MIOPEN_POINTWISE_BINARY_SELECT

Definition: miopen.h:7272

MIOPEN_POINTWISE_GELU_BWD

@ MIOPEN_POINTWISE_GELU_BWD

Definition: miopen.h:7223

MIOPEN_POINTWISE_MIN

@ MIOPEN_POINTWISE_MIN

Definition: miopen.h:7124

MIOPEN_POINTWISE_CMP_NEQ

@ MIOPEN_POINTWISE_CMP_NEQ

Definition: miopen.h:7242

MIOPEN_POINTWISE_FLOOR

@ MIOPEN_POINTWISE_FLOOR

Definition: miopen.h:7152

MIOPEN_POINTWISE_RSQRT

@ MIOPEN_POINTWISE_RSQRT

Definition: miopen.h:7161

MIOPEN_POINTWISE_CMP_EQ

@ MIOPEN_POINTWISE_CMP_EQ

Definition: miopen.h:7239

MIOPEN_POINTWISE_CMP_GE

@ MIOPEN_POINTWISE_CMP_GE

Definition: miopen.h:7249

MIOPEN_POINTWISE_ADD_SQUARE

@ MIOPEN_POINTWISE_ADD_SQUARE

Definition: miopen.h:7115

MIOPEN_POINTWISE_ERF

@ MIOPEN_POINTWISE_ERF

Definition: miopen.h:7173

MIOPEN_POINTWISE_SWISH_FWD

@ MIOPEN_POINTWISE_SWISH_FWD

Definition: miopen.h:7200

MIOPEN_POINTWISE_LOG

@ MIOPEN_POINTWISE_LOG

Definition: miopen.h:7155

MIOPEN_POINTWISE_SUB

@ MIOPEN_POINTWISE_SUB

Definition: miopen.h:7137

MIOPEN_POINTWISE_NEG

@ MIOPEN_POINTWISE_NEG

Definition: miopen.h:7158

MIOPEN_POINTWISE_LOGICAL_AND

@ MIOPEN_POINTWISE_LOGICAL_AND

Definition: miopen.h:7259

MIOPEN_POINTWISE_SWISH_BWD

@ MIOPEN_POINTWISE_SWISH_BWD

Definition: miopen.h:7229

MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

Definition: miopen.h:7205

MIOPEN_POINTWISE_SIN

@ MIOPEN_POINTWISE_SIN

Definition: miopen.h:7164

MIOPEN_POINTWISE_RECIPROCAL

@ MIOPEN_POINTWISE_RECIPROCAL

Definition: miopen.h:7276

MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

Definition: miopen.h:7236

MIOPEN_POINTWISE_GELU_FWD

@ MIOPEN_POINTWISE_GELU_FWD

Definition: miopen.h:7194

MIOPEN_POINTWISE_ABS

@ MIOPEN_POINTWISE_ABS

Definition: miopen.h:7140

MIOPEN_POINTWISE_CMP_LT

@ MIOPEN_POINTWISE_CMP_LT

Definition: miopen.h:7252

MIOPEN_POINTWISE_EXP

@ MIOPEN_POINTWISE_EXP

Definition: miopen.h:7149

MIOPEN_POINTWISE_GEN_INDEX

@ MIOPEN_POINTWISE_GEN_INDEX

Definition: miopen.h:7268

MIOPEN_POINTWISE_CEIL

@ MIOPEN_POINTWISE_CEIL

Definition: miopen.h:7143

MIOPEN_POINTWISE_LOGICAL_NOT

@ MIOPEN_POINTWISE_LOGICAL_NOT

Definition: miopen.h:7265

MIOPEN_POINTWISE_SIGMOID_FWD

@ MIOPEN_POINTWISE_SIGMOID_FWD

Definition: miopen.h:7187

MIOPEN_POINTWISE_SOFTPLUS_BWD

@ MIOPEN_POINTWISE_SOFTPLUS_BWD

Definition: miopen.h:7226

MIOPEN_POINTWISE_LOGICAL_OR

@ MIOPEN_POINTWISE_LOGICAL_OR

Definition: miopen.h:7262

MIOPEN_POINTWISE_TAN

@ MIOPEN_POINTWISE_TAN

Definition: miopen.h:7170

MIOPEN_POINTWISE_ELU_BWD

@ MIOPEN_POINTWISE_ELU_BWD

Definition: miopen.h:7219

MIOPEN_POINTWISE_IDENTITY

@ MIOPEN_POINTWISE_IDENTITY

Definition: miopen.h:7178

MIOPEN_POINTWISE_CMP_LE

@ MIOPEN_POINTWISE_CMP_LE

Definition: miopen.h:7256

MIOPEN_POINTWISE_COS

@ MIOPEN_POINTWISE_COS

Definition: miopen.h:7146

MIOPEN_POINTWISE_TANH_BWD

@ MIOPEN_POINTWISE_TANH_BWD

Definition: miopen.h:7212

MIOPEN_POINTWISE_MUL

@ MIOPEN_POINTWISE_MUL

Definition: miopen.h:7131

MIOPEN_POINTWISE_TANH_FWD

@ MIOPEN_POINTWISE_TANH_FWD

Definition: miopen.h:7184

MIOPEN_POINTWISE_RELU_BWD

@ MIOPEN_POINTWISE_RELU_BWD

Definition: miopen.h:7209

MIOPEN_POINTWISE_ADD

@ MIOPEN_POINTWISE_ADD

Definition: miopen.h:7111

MIOPEN_POINTWISE_MAX

@ MIOPEN_POINTWISE_MAX

Definition: miopen.h:7121

MIOPEN_POINTWISE_CMP_GT

@ MIOPEN_POINTWISE_CMP_GT

Definition: miopen.h:7245

MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

Definition: miopen.h:7033

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

Definition: miopen.h:6863

MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

Definition: miopen.h:6987

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

Definition: miopen.h:6990

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

Definition: miopen.h:6869

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

Definition: miopen.h:6860

MIOPEN_ATTR_OPERATION_SIGNAL_MODE

@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE

Definition: miopen.h:7011

MIOPEN_ATTR_OPERATION_RNG_DESC

@ MIOPEN_ATTR_OPERATION_RNG_DESC

Definition: miopen.h:7057

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

Definition: miopen.h:6861

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

Definition: miopen.h:6974

MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

Definition: miopen.h:7036

MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

Definition: miopen.h:7024

MIOPEN_ATTR_OPERATIONGRAPH_OPS

@ MIOPEN_ATTR_OPERATIONGRAPH_OPS

Definition: miopen.h:6913

MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

Definition: miopen.h:6937

MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

Definition: miopen.h:6832

MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

Definition: miopen.h:7015

MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

Definition: miopen.h:7040

MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

Definition: miopen.h:7043

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

Definition: miopen.h:7004

MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

Definition: miopen.h:6833

MIOPEN_ATTR_REDUCTION_OPERATOR

@ MIOPEN_ATTR_REDUCTION_OPERATOR

Definition: miopen.h:6961

MIOPEN_ATTR_OPERATION_MATMUL_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_DESC

Definition: miopen.h:6955

MIOPEN_ATTR_CONVOLUTION_DILATIONS

@ MIOPEN_ATTR_CONVOLUTION_DILATIONS

Definition: miopen.h:6830

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

Definition: miopen.h:6998

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

Definition: miopen.h:6882

MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

Definition: miopen.h:6982

MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

Definition: miopen.h:6848

MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

Definition: miopen.h:7020

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

Definition: miopen.h:6902

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

Definition: miopen.h:6970

MIOPEN_ATTR_KNOB_INFO_TYPE

@ MIOPEN_ATTR_KNOB_INFO_TYPE

Definition: miopen.h:6936

MIOPEN_ATTR_LAYOUT_INFO_TYPES

@ MIOPEN_ATTR_LAYOUT_INFO_TYPES

Definition: miopen.h:6934

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

Definition: miopen.h:6896

MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

Definition: miopen.h:6912

MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

Definition: miopen.h:7037

MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

Definition: miopen.h:7052

MIOPEN_ATTR_POINTWISE_MATH_PREC

@ MIOPEN_ATTR_POINTWISE_MATH_PREC

Definition: miopen.h:6818

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

Definition: miopen.h:6958

MIOPEN_ATTR_OPERATION_GENSTATS_MODE

@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE

Definition: miopen.h:6888

MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

Definition: miopen.h:6858

MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

Definition: miopen.h:6930

MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

Definition: miopen.h:6965

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

Definition: miopen.h:6873

MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

Definition: miopen.h:6931

MIOPEN_ATTR_TENSOR_IS_BY_VALUE

@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE

Definition: miopen.h:6924

MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

Definition: miopen.h:7017

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

Definition: miopen.h:6862

MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

Definition: miopen.h:6894

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

Definition: miopen.h:7027

MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

Definition: miopen.h:7045

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

Definition: miopen.h:7003

MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

Definition: miopen.h:6879

MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

Definition: miopen.h:6928

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

Definition: miopen.h:6973

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

Definition: miopen.h:6993

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

Definition: miopen.h:6898

MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

Definition: miopen.h:7013

MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

Definition: miopen.h:7012

MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

Definition: miopen.h:6886

MIOPEN_ATTR_ENGINEHEUR_RESULTS

@ MIOPEN_ATTR_ENGINEHEUR_RESULTS

Definition: miopen.h:6838

MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

Definition: miopen.h:6916

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

Definition: miopen.h:6876

MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

Definition: miopen.h:6908

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

Definition: miopen.h:6978

MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

Definition: miopen.h:6889

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

Definition: miopen.h:7026

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

Definition: miopen.h:6906

MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

Definition: miopen.h:6845

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

Definition: miopen.h:6972

MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

Definition: miopen.h:7009

MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

Definition: miopen.h:7039

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

Definition: miopen.h:6867

MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

Definition: miopen.h:6847

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

Definition: miopen.h:6870

MIOPEN_ATTR_TENSOR_VECTOR_COUNT

@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT

Definition: miopen.h:6920

MIOPEN_ATTR_OPERATION_MATMUL_CDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC

Definition: miopen.h:6954

MIOPEN_ATTR_REDUCTION_COMP_TYPE

@ MIOPEN_ATTR_REDUCTION_COMP_TYPE

Definition: miopen.h:6962

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

Definition: miopen.h:7001

MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

Definition: miopen.h:6921

MIOPEN_ATTR_TENSOR_DIMENSIONS

@ MIOPEN_ATTR_TENSOR_DIMENSIONS

Definition: miopen.h:6918

MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

Definition: miopen.h:6891

MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

Definition: miopen.h:7008

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

Definition: miopen.h:6883

MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

Definition: miopen.h:6944

MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

Definition: miopen.h:6946

MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

Definition: miopen.h:6850

MIOPEN_ATTR_RESAMPLE_STRIDES

@ MIOPEN_ATTR_RESAMPLE_STRIDES

Definition: miopen.h:6985

MIOPEN_ATTR_POINTWISE_ELU_ALPHA

@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA

Definition: miopen.h:6823

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

Definition: miopen.h:7029

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

Definition: miopen.h:6999

MIOPEN_ATTR_OPERATION_RNG_SEED

@ MIOPEN_ATTR_OPERATION_RNG_SEED

Definition: miopen.h:7056

MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

Definition: miopen.h:7034

MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

Definition: miopen.h:6884

MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

Definition: miopen.h:7007

MIOPEN_ATTR_RESAMPLE_MODE

@ MIOPEN_ATTR_RESAMPLE_MODE

Definition: miopen.h:6980

MIOPEN_ATTR_RNG_DISTRIBUTION

@ MIOPEN_ATTR_RNG_DISTRIBUTION

Definition: miopen.h:7048

MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

Definition: miopen.h:7035

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

Definition: miopen.h:6957

MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

Definition: miopen.h:7018

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

Definition: miopen.h:6822

MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

Definition: miopen.h:7046

MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

Definition: miopen.h:6929

MIOPEN_ATTR_POINTWISE_AXIS

@ MIOPEN_ATTR_POINTWISE_AXIS

Definition: miopen.h:6826

MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

Definition: miopen.h:7030

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

Definition: miopen.h:6820

MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

Definition: miopen.h:6941

MIOPEN_ATTR_OPERATION_MATMUL_BDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC

Definition: miopen.h:6953

MIOPEN_ATTR_TENSOR_DATA_TYPE

@ MIOPEN_ATTR_TENSOR_DATA_TYPE

Definition: miopen.h:6917

MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

Definition: miopen.h:7014

MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

Definition: miopen.h:6938

MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

Definition: miopen.h:7023

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

Definition: miopen.h:6995

MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

Definition: miopen.h:6984

MIOPEN_ATTR_MATMUL_COMP_TYPE

@ MIOPEN_ATTR_MATMUL_COMP_TYPE

Definition: miopen.h:6949

MIOPEN_ATTR_TENSOR_UNIQUE_ID

@ MIOPEN_ATTR_TENSOR_UNIQUE_ID

Definition: miopen.h:6922

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

Definition: miopen.h:6976

MIOPEN_ATTR_OPERATION_CONCAT_AXIS

@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS

Definition: miopen.h:7006

MIOPEN_ATTR_OPERATION_RNG_YDESC

@ MIOPEN_ATTR_OPERATION_RNG_YDESC

Definition: miopen.h:7055

MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

Definition: miopen.h:6942

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

Definition: miopen.h:6868

MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

Definition: miopen.h:6837

MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

Definition: miopen.h:6926

MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

Definition: miopen.h:6824

MIOPEN_ATTR_TENSOR_IS_VIRTUAL

@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL

Definition: miopen.h:6923

MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

Definition: miopen.h:6843

MIOPEN_ATTR_MATMUL_PADDING_VALUE

@ MIOPEN_ATTR_MATMUL_PADDING_VALUE

Definition: miopen.h:6950

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

Definition: miopen.h:6910

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

Definition: miopen.h:6905

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

Definition: miopen.h:6864

MIOPEN_ATTR_KNOB_INFO_STRIDE

@ MIOPEN_ATTR_KNOB_INFO_STRIDE

Definition: miopen.h:6939

MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

Definition: miopen.h:6986

MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

Definition: miopen.h:6881

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

Definition: miopen.h:6991

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

Definition: miopen.h:6971

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

Definition: miopen.h:6871

MIOPEN_ATTR_CONVOLUTION_CONV_MODE

@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE

Definition: miopen.h:6829

MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

Definition: miopen.h:6964

MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

Definition: miopen.h:6849

MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

Definition: miopen.h:6895

MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

Definition: miopen.h:6947

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

Definition: miopen.h:6907

MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

Definition: miopen.h:6857

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

Definition: miopen.h:6997

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

Definition: miopen.h:6900

MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

Definition: miopen.h:6885

MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

Definition: miopen.h:7025

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

Definition: miopen.h:6977

MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

Definition: miopen.h:7058

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

Definition: miopen.h:6865

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

Definition: miopen.h:6901

MIOPEN_ATTR_ENGINE_LAYOUT_INFO

@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO

Definition: miopen.h:6945

MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

Definition: miopen.h:6852

MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

Definition: miopen.h:6828

MIOPEN_ATTR_RESAMPLE_COMP_TYPE

@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE

Definition: miopen.h:6981

MIOPEN_ATTR_ENGINECFG_ENGINE

@ MIOPEN_ATTR_ENGINECFG_ENGINE

Definition: miopen.h:6841

MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

Definition: miopen.h:6983

MIOPEN_ATTR_RESAMPLE_PADDING_MODE

@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE

Definition: miopen.h:6988

MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

Definition: miopen.h:6834

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

Definition: miopen.h:7028

MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

Definition: miopen.h:6890

MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

Definition: miopen.h:7021

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

Definition: miopen.h:6897

MIOPEN_ATTR_ENGINE_KNOB_INFO

@ MIOPEN_ATTR_ENGINE_KNOB_INFO

Definition: miopen.h:6943

MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

Definition: miopen.h:6956

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

Definition: miopen.h:6875

MIOPEN_ATTR_TENSOR_REORDERING_MODE

@ MIOPEN_ATTR_TENSOR_REORDERING_MODE

Definition: miopen.h:6925

MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

Definition: miopen.h:6853

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

Definition: miopen.h:6959

MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

Definition: miopen.h:6878

MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

Definition: miopen.h:7050

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

Definition: miopen.h:6854

MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

Definition: miopen.h:6933

MIOPEN_ATTR_ENGINEHEUR_MODE

@ MIOPEN_ATTR_ENGINEHEUR_MODE

Definition: miopen.h:6836

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

Definition: miopen.h:7000

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

Definition: miopen.h:7002

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

Definition: miopen.h:6909

MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

Definition: miopen.h:6880

MIOPEN_ATTR_POINTWISE_MODE

@ MIOPEN_ATTR_POINTWISE_MODE

Definition: miopen.h:6817

MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

Definition: miopen.h:6842

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

Definition: miopen.h:6877

MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

Definition: miopen.h:7042

MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

Definition: miopen.h:6819

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

Definition: miopen.h:6855

MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

Definition: miopen.h:6821

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

Definition: miopen.h:6975

MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

Definition: miopen.h:7053

MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

Definition: miopen.h:6839

MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

Definition: miopen.h:6899

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

Definition: miopen.h:6903

MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

Definition: miopen.h:7049

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

Definition: miopen.h:6968

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

Definition: miopen.h:6969

MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

Definition: miopen.h:7031

MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

Definition: miopen.h:7022

MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

Definition: miopen.h:6892

MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

Definition: miopen.h:6846

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

Definition: miopen.h:6994

MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

Definition: miopen.h:7041

MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

Definition: miopen.h:7038

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

Definition: miopen.h:6866

MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

Definition: miopen.h:7051

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

Definition: miopen.h:6874

MIOPEN_ATTR_TENSOR_STRIDES

@ MIOPEN_ATTR_TENSOR_STRIDES

Definition: miopen.h:6919

MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

Definition: miopen.h:6831

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

Definition: miopen.h:6872

MIOPEN_ATTR_POINTWISE_SWISH_BETA

@ MIOPEN_ATTR_POINTWISE_SWISH_BETA

Definition: miopen.h:6825

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

Definition: miopen.h:6992

MIOPEN_ATTR_OPERATION_REDUCTION_DESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC

Definition: miopen.h:6966

MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

Definition: miopen.h:7019

MIOPEN_ATTR_OPERATION_MATMUL_ADESC

@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC

Definition: miopen.h:6952

MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

Definition: miopen.h:6914

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

Definition: miopen.h:6904

MIOPEN_RNG_DISTRIBUTION_BERNOULLI

@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI

Definition: miopen.h:7286

MIOPEN_RNG_DISTRIBUTION_UNIFORM

@ MIOPEN_RNG_DISTRIBUTION_UNIFORM

Definition: miopen.h:7287

MIOPEN_RNG_DISTRIBUTION_NORMAL

@ MIOPEN_RNG_DISTRIBUTION_NORMAL

Definition: miopen.h:7288

MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

Definition: miopen.h:6784

MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

Definition: miopen.h:6802

MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

Definition: miopen.h:6776

MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

Definition: miopen.h:6800

MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

Definition: miopen.h:6795

MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

Definition: miopen.h:6774

MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

Definition: miopen.h:6797

MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

Definition: miopen.h:6781

MIOPEN_BACKEND_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_RNG_DESCRIPTOR

Definition: miopen.h:6803

MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

Definition: miopen.h:6792

MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

Definition: miopen.h:6791

MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

Definition: miopen.h:6777

MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR

Definition: miopen.h:6796

MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

Definition: miopen.h:6782

MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

Definition: miopen.h:6793

MIOPEN_BACKEND_TENSOR_DESCRIPTOR

@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR

Definition: miopen.h:6804

MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

Definition: miopen.h:6794

MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

Definition: miopen.h:6799

MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

Definition: miopen.h:6787

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

Definition: miopen.h:6786

MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

Definition: miopen.h:6779

MIOPEN_BACKEND_ENGINE_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR

Definition: miopen.h:6775

MIOPEN_BACKEND_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR

Definition: miopen.h:6783

MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

Definition: miopen.h:6788

MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

Definition: miopen.h:6805

MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

Definition: miopen.h:6801

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

Definition: miopen.h:6785

MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

Definition: miopen.h:6789

MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

Definition: miopen.h:6790

MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

Definition: miopen.h:6798

MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

Definition: miopen.h:6778

MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

Definition: miopen.h:6780

SCALE

@ SCALE

Definition: miopen.h:7299

BILINEAR

@ BILINEAR

Definition: miopen.h:7300

DEFAULT

@ DEFAULT

Definition: miopen.h:7298

ERROR_STATE

@ ERROR_STATE

Definition: miopen.h:7301

MIOPEN_TYPE_RNG_DISTRIBUTION

@ MIOPEN_TYPE_RNG_DISTRIBUTION

Definition: miopen.h:7100

MIOPEN_TYPE_FLOAT

@ MIOPEN_TYPE_FLOAT

Definition: miopen.h:7075

MIOPEN_TYPE_NUMERICAL_NOTE

@ MIOPEN_TYPE_NUMERICAL_NOTE

Definition: miopen.h:7082

MIOPEN_TYPE_RESAMPLE_MODE

@ MIOPEN_TYPE_RESAMPLE_MODE

Definition: miopen.h:7092

MIOPEN_TYPE_INT32

@ MIOPEN_TYPE_INT32

Definition: miopen.h:7094

MIOPEN_TYPE_POINTWISE_MODE

@ MIOPEN_TYPE_POINTWISE_MODE

Definition: miopen.h:7085

MIOPEN_TYPE_HANDLE

@ MIOPEN_TYPE_HANDLE

Definition: miopen.h:7071

MIOPEN_TYPE_HEUR_MODE

@ MIOPEN_TYPE_HEUR_MODE

Definition: miopen.h:7079

MIOPEN_TYPE_CONVOLUTION_MODE

@ MIOPEN_TYPE_CONVOLUTION_MODE

Definition: miopen.h:7078

MIOPEN_TYPE_TENSOR_REORDERING_MODE

@ MIOPEN_TYPE_TENSOR_REORDERING_MODE

Definition: miopen.h:7091

MIOPEN_TYPE_BOOLEAN

@ MIOPEN_TYPE_BOOLEAN

Definition: miopen.h:7073

MIOPEN_TYPE_NORM_MODE

@ MIOPEN_TYPE_NORM_MODE

Definition: miopen.h:7098

MIOPEN_TYPE_FRACTION

@ MIOPEN_TYPE_FRACTION

Definition: miopen.h:7097

MIOPEN_TYPE_BACKEND_DESCRIPTOR

@ MIOPEN_TYPE_BACKEND_DESCRIPTOR

Definition: miopen.h:7086

MIOPEN_TYPE_ATTRIB_NAME

@ MIOPEN_TYPE_ATTRIB_NAME

Definition: miopen.h:7084

MIOPEN_TYPE_BEHAVIOR_NOTE

@ MIOPEN_TYPE_BEHAVIOR_NOTE

Definition: miopen.h:7090

MIOPEN_TYPE_DATA_TYPE

@ MIOPEN_TYPE_DATA_TYPE

Definition: miopen.h:7072

MIOPEN_TYPE_NAN_PROPOGATION

@ MIOPEN_TYPE_NAN_PROPOGATION

Definition: miopen.h:7081

MIOPEN_TYPE_DOUBLE

@ MIOPEN_TYPE_DOUBLE

Definition: miopen.h:7076

MIOPEN_TYPE_SIGNAL_MODE

@ MIOPEN_TYPE_SIGNAL_MODE

Definition: miopen.h:7096

MIOPEN_TYPE_CHAR

@ MIOPEN_TYPE_CHAR

Definition: miopen.h:7095

MIOPEN_TYPE_PADDING_MODE

@ MIOPEN_TYPE_PADDING_MODE

Definition: miopen.h:7093

MIOPEN_TYPE_INT64

@ MIOPEN_TYPE_INT64

Definition: miopen.h:7074

MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

Definition: miopen.h:7089

MIOPEN_TYPE_LAYOUT_TYPE

@ MIOPEN_TYPE_LAYOUT_TYPE

Definition: miopen.h:7083

MIOPEN_TYPE_GENSTATS_MODE

@ MIOPEN_TYPE_GENSTATS_MODE

Definition: miopen.h:7087

MIOPEN_TYPE_VOID_PTR

@ MIOPEN_TYPE_VOID_PTR

Definition: miopen.h:7077

MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

Definition: miopen.h:7088

MIOPEN_TYPE_KNOB_TYPE

@ MIOPEN_TYPE_KNOB_TYPE

Definition: miopen.h:7080

MIOPEN_TYPE_NORM_FWD_PHASE

@ MIOPEN_TYPE_NORM_FWD_PHASE

Definition: miopen.h:7099

miopenSetLRNDescriptor

miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc, miopenLRNMode_t mode, unsigned int lrnN, double lrnAlpha, double lrnBeta, double lrnK)

Sets a LRN layer descriptor details.

miopenCreateLRNDescriptor

miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t *lrnDesc)

Creates a local response normalization (LRN) layer descriptor.

miopenGetLRNDescriptor

miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc, miopenLRNMode_t *mode, unsigned int *lrnN, double *lrnAlpha, double *lrnBeta, double *lrnK)

Gets a LRN layer descriptor details.

miopenLRNBackward

miopenStatus_t miopenLRNBackward(miopenHandle_t handle, const miopenLRNDescriptor_t lrnDesc, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, const void *workSpace)

Execute a LRN backward layer.

miopenLRNGetWorkSpaceSize

miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Determine the workspace requirements.

miopenLRNMode_t

miopenLRNMode_t

Definition: miopen.h:483

miopenLRNForward

miopenStatus_t miopenLRNForward(miopenHandle_t handle, const miopenLRNDescriptor_t lrnDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, bool do_backward, void *workSpace)

Execute a LRN forward layer.

miopenDestroyLRNDescriptor

miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc)

Destroys the LRN descriptor object.

miopenGetCTCLossWorkspaceSize

miopenStatus_t miopenGetCTCLossWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t probsDesc, const miopenTensorDescriptor_t gradientsDesc, const int *labels, const int *labelLengths, const int *inputLengths, miopenCTCLossAlgo_t algo, const miopenCTCLossDescriptor_t ctcLossDesc, size_t *workSpaceSize)

Query the amount of memory required to execute miopenCTCLoss.

miopenGetSoftMarginLossForwardWorkspaceSize

miopenStatus_t miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, miopenTensorDescriptor_t targetDesc, miopenTensorDescriptor_t outputDesc, miopenLossReductionMode_t reduction, size_t *sizeInBytes)

Helper function to query the minimum workspace size required by the SoftMarginLossForward call.

miopenLossReductionMode_t

miopenLossReductionMode_t

Definition: miopen.h:8358

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:5473

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:5474

miopenRNNMode_t

miopenRNNMode_t

Definition: miopen.h:4078

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:4089

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:4111

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:4120

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:4155

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:4098

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:4146

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:4129

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:4137

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:4080

miopenLSTM

@ miopenLSTM

Definition: miopen.h:4081

miopenGRU

@ miopenGRU

Definition: miopen.h:4082

miopenRNNRELU

@ miopenRNNRELU

Definition: miopen.h:4079

miopenRNNlinear

@ miopenRNNlinear

Definition: miopen.h:4090

miopenRNNskip

@ miopenRNNskip

Definition: miopen.h:4091

miopenRNNbidirection

@ miopenRNNbidirection

Definition: miopen.h:4113

miopenRNNunidirection

@ miopenRNNunidirection

Definition: miopen.h:4112

miopenRNNwithBias

@ miopenRNNwithBias

Definition: miopen.h:4122

miopenRNNNoBias

@ miopenRNNNoBias

Definition: miopen.h:4121

miopenRNNDataSeqMajorPadded

@ miopenRNNDataSeqMajorPadded

Definition: miopen.h:4158

miopenRNNDataSeqMajorNotPadded

@ miopenRNNDataSeqMajorNotPadded

Definition: miopen.h:4157

miopenRNNDataBatchMajorPadded

@ miopenRNNDataBatchMajorPadded

Definition: miopen.h:4159

miopenRNNDataUnknownLayout

@ miopenRNNDataUnknownLayout

Definition: miopen.h:4156

miopenRNNroundedDynamic

@ miopenRNNroundedDynamic

Definition: miopen.h:4103

miopenRNNfundamental

@ miopenRNNfundamental

Definition: miopen.h:4101

miopenRNNdefault

@ miopenRNNdefault

Definition: miopen.h:4099

miopenRNNTraining

@ miopenRNNTraining

Definition: miopen.h:4147

miopenRNNInference

@ miopenRNNInference

Definition: miopen.h:4148

miopenRNNAlgoGEMM

@ miopenRNNAlgoGEMM

Definition: miopen.h:4130

miopenRNNIOWithPadding

@ miopenRNNIOWithPadding

Definition: miopen.h:4139

miopenRNNIONotPadded

@ miopenRNNIONotPadded

Definition: miopen.h:4138

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:6517

miopenRoPEBackward

miopenStatus_t miopenRoPEBackward(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t cosDesc, const void *cos, const miopenTensorDescriptor_t sinDesc, const void *sin, const miopenTensorDescriptor_t dxDesc, void *dx)

Execute a rope backward layer.

miopenRoPEForward

miopenStatus_t miopenRoPEForward(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t cosDesc, const void *cos, const miopenTensorDescriptor_t sinDesc, const void *sin, const miopenTensorDescriptor_t yDesc, void *y)

Execute a rope forward layer.

miopenFusedAdam

miopenStatus_t miopenFusedAdam(miopenHandle_t handle, const miopenTensorDescriptor_t paramDesc, void *param, const miopenTensorDescriptor_t gradDesc, const void *grad, const miopenTensorDescriptor_t expAvgDesc, void *expAvg, const miopenTensorDescriptor_t expAvgSqDesc, void *expAvgSq, const miopenTensorDescriptor_t maxExpAvgSqDesc, void *maxExpAvgSq, const miopenTensorDescriptor_t stateStepDesc, void *stateStep, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const bool amsgrad, const bool maximize, const bool adamw, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)

Perform Fused Adam optimization for a single tensor (Adaptive Moment Estimation).

miopenTransformersAdamW

miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle, const miopenTensorDescriptor_t paramDesc, void *param, const miopenTensorDescriptor_t gradDesc, const void *grad, const miopenTensorDescriptor_t expAvgDesc, void *expAvg, const miopenTensorDescriptor_t expAvgSqDesc, void *expAvgSq, const miopenTensorDescriptor_t stateStepDesc, void *stateStep, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const bool correct_bias, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)

Implements Adam algorithm with weight decay fix as introduced in Decoupled Weight Decay Regularizatio...

miopenFusedAdamWithOutput

miopenStatus_t miopenFusedAdamWithOutput(miopenHandle_t handle, const miopenTensorDescriptor_t paramInDesc, void *paramIn, const miopenTensorDescriptor_t paramOutDesc, void *paramOut, const miopenTensorDescriptor_t paramOutFloat16Desc, void *paramOutFloat16, const miopenTensorDescriptor_t gradInDesc, const void *gradIn, const miopenTensorDescriptor_t expAvgInDesc, void *expAvgIn, const miopenTensorDescriptor_t expAvgOutDesc, void *expAvgOut, const miopenTensorDescriptor_t expAvgSqInDesc, void *expAvgSqIn, const miopenTensorDescriptor_t expAvgSqOutDesc, void *expAvgSqOut, const miopenTensorDescriptor_t maxExpAvgSqInDesc, void *maxExpAvgSqIn, const miopenTensorDescriptor_t maxExpAvgSqOutDesc, void *maxExpAvgSqOut, const miopenTensorDescriptor_t stateStepInDesc, void *stateStepIn, const miopenTensorDescriptor_t stateStepOutDesc, void *stateStepOut, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const bool amsgrad, const bool maximize, const bool adamw, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)

Execute single tensor Adam optimization and receive the result in a separate output tensor.

miopenTransformersAdamWWithOutput

miopenStatus_t miopenTransformersAdamWWithOutput(miopenHandle_t handle, const miopenTensorDescriptor_t paramInDesc, void *paramIn, const miopenTensorDescriptor_t paramOutDesc, void *paramOut, const miopenTensorDescriptor_t paramOutFloat16Desc, void *paramOutFloat16, const miopenTensorDescriptor_t gradInDesc, const void *gradIn, const miopenTensorDescriptor_t expAvgInDesc, void *expAvgIn, const miopenTensorDescriptor_t expAvgOutDesc, void *expAvgOut, const miopenTensorDescriptor_t expAvgSqInDesc, void *expAvgSqIn, const miopenTensorDescriptor_t expAvgSqOutDesc, void *expAvgSqOut, const miopenTensorDescriptor_t stateStepInDesc, void *stateStepIn, const miopenTensorDescriptor_t stateStepOutDesc, void *stateStepOut, const unsigned int state_step, const float lr, const float beta1, const float beta2, const float weight_decay, const float eps, const float step_size, const bool correct_bias, const miopenTensorDescriptor_t gradScaleDesc, const void *gradScale, const miopenTensorDescriptor_t foundInfDesc, const void *foundInf)

Execute single tensor Adam optimization and receive the result in a separate output tensor.

miopenReduceTensorIndices_t

miopenReduceTensorIndices_t

Definition: miopen.h:611

miopenSetReduceTensorDescriptor

miopenStatus_t miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc, miopenReduceTensorOp_t reduceTensorOp, miopenDataType_t reduceTensorCompType, miopenNanPropagation_t reduceTensorNanOpt, miopenReduceTensorIndices_t reduceTensorIndices, miopenIndicesType_t reduceTensorIndicesType)

Initialize a ReduceTensor descriptor object.

miopenCreateReduceTensorDescriptor

miopenStatus_t miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t *reduceTensorDesc)

Creates the ReduceTensor descriptor object.

miopenReduceTensorOp_t

miopenReduceTensorOp_t

Definition: miopen.h:576

miopenIndicesType_t

miopenIndicesType_t

Definition: miopen.h:621

miopenReduceTensor

miopenStatus_t miopenReduceTensor(miopenHandle_t handle, const miopenReduceTensorDescriptor_t reduceTensorDesc, void *indices, size_t indicesSizeInBytes, void *workspace, size_t workspaceSizeInBytes, const void *alpha, const miopenTensorDescriptor_t aDesc, const void *A, const void *beta, const miopenTensorDescriptor_t cDesc, void *C)

TensorReduce function doing reduction on tensor A by implementing C = alpha * reduceOp(A)

miopenGetReductionIndicesSize

miopenStatus_t miopenGetReductionIndicesSize(miopenHandle_t handle, const miopenReduceTensorDescriptor_t reduceTensorDesc, const miopenTensorDescriptor_t aDesc, const miopenTensorDescriptor_t cDesc, size_t *sizeInBytes)

Helper function to query the minimum index space size required by the ReduceTensor call.

miopenDestroyReduceTensorDescriptor

miopenStatus_t miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc)

Destroy the ReduceTensor descriptor object.

miopenGetReductionWorkspaceSize

miopenStatus_t miopenGetReductionWorkspaceSize(miopenHandle_t handle, const miopenReduceTensorDescriptor_t reduceTensorDesc, const miopenTensorDescriptor_t aDesc, const miopenTensorDescriptor_t cDesc, size_t *sizeInBytes)

Helper function to query the minimum workspace size required by the ReduceTensor call.

miopenGetReduceTensorDescriptor

miopenStatus_t miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc, miopenReduceTensorOp_t *reduceTensorOp, miopenDataType_t *reduceTensorCompType, miopenNanPropagation_t *reduceTensorNanOpt, miopenReduceTensorIndices_t *reduceTensorIndices, miopenIndicesType_t *reduceTensorIndicesType)

Query a ReduceTensor descriptor object.

miopenActivationForward

miopenStatus_t miopenActivationForward(miopenHandle_t handle, const miopenActivationDescriptor_t activDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)

Execute an activation forward layer.

miopenGLUBackward

miopenStatus_t miopenGLUBackward(miopenHandle_t handle, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputGradDesc, const void *outputGrad, const miopenTensorDescriptor_t inputGradDesc, void *inputGrad, const uint32_t dim)

Execute a GLU backward layer.

miopenActivationBackward

miopenStatus_t miopenActivationBackward(miopenHandle_t handle, const miopenActivationDescriptor_t activDesc, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx)

Execute a activation backwards layer.

miopenActivationMode_t

miopenActivationMode_t

Definition: miopen.h:522

miopenSetActivationDescriptor

miopenStatus_t miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc, miopenActivationMode_t mode, double activAlpha, double activBeta, double activGamma)

Sets the activation layer descriptor details.

miopenCreateActivationDescriptor

miopenStatus_t miopenCreateActivationDescriptor(miopenActivationDescriptor_t *activDesc)

Creates the Activation descriptor object.

miopenGetActivationDescriptor

miopenStatus_t miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc, miopenActivationMode_t *mode, double *activAlpha, double *activBeta, double *activGamma)

Gets the activation layer descriptor details.

miopenGLUForward

miopenStatus_t miopenGLUForward(miopenHandle_t handle, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, const uint32_t dim)

Execute a GLU forward layer.

miopenDestroyActivationDescriptor

miopenStatus_t miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc)

Destroys the activation descriptor object.

miopenBatchNormalizationForwardInference

miopenStatus_t miopenBatchNormalizationForwardInference(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon)

Execute forward inference layer for batch normalization.

miopenBatchNormalizationForwardInference_V2

miopenStatus_t miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon)

Execute forward inference layer for batch normalization.

miopenBatchNormForwardTrainingActivation

miopenStatus_t miopenBatchNormForwardTrainingActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, void *resultRunningMean, void *resultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance, const miopenActivationDescriptor_t activDesc)

Execute forward training layer for batch normalization with fused activation.

miopenBatchNormBackwardActivation

miopenStatus_t miopenBatchNormBackwardActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, const void *alphaDataDiff, const void *betaDataDiff, const void *alphaParamDiff, const void *betaParamDiff, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarianceDesc, const void *bnScale, const void *bnBias, void *resultBnScaleDiff, void *resultBnBiasDiff, double epsilon, const void *savedMean, const void *savedInvVariance, const miopenActivationDescriptor_t activDesc)

Execute backwards propagation layer for batch normalization with fused activation.

miopenBatchNormalizationForwardTraining

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:512

miopenBatchNormForwardInferenceActivation

miopenStatus_t miopenBatchNormForwardInferenceActivation(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedVariance, double epsilon, const miopenActivationDescriptor_t activDesc)

Execute forward inference layer for batch normalization with fused activation.

miopenDeriveBNTensorDescriptor

miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc, const miopenTensorDescriptor_t xDesc, miopenBatchNormMode_t bn_mode)

Derive tensor for gamma and beta from input tensor descriptor.

miopenCatForward

miopenStatus_t miopenCatForward(miopenHandle_t handle, const int32_t xCount, const miopenTensorDescriptor_t *xDescs, const void *const *xs, const miopenTensorDescriptor_t yDesc, void *y, const int32_t dim)

Execute a cat forward layer.

miopenInitConvolutionNdDescriptor

miopenStatus_t miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc, int spatialDim, const int *padA, const int *strideA, const int *dilationA, miopenConvolutionMode_t c_mode)

Creates a N-dimensional convolution layer descriptor.

miopenConvolutionForwardImmediate

miopenStatus_t miopenConvolutionForwardImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, void *y, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)

Executes the Forward convolution operation based on the provided solution ID.

miopenConvolutionBackwardDataCompileSolution

miopenStatus_t miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const uint64_t solution_id)

Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionBac...

miopenConvolutionForwardGetSolutionWorkspaceSize

miopenStatus_t miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const uint64_t solution_id, size_t *workSpaceSize)

Returns the workspace size required for a particular solution id.

miopenConvolutionForward

miopenStatus_t miopenConvolutionForward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvFwdAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, void *workSpace, size_t workSpaceSize)

Execute a forward convolution layer.

miopenGetConvolutionGroupCount

miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)

Get the number of groups to be used in Group/Depthwise convolution.

miopenGetConvolutionFindMode

miopenStatus_t miopenGetConvolutionFindMode(const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t *findMode)

Reads the Find Mode attribute from the convolution descriptor.

miopenInitConvolutionDescriptor

miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc, miopenConvolutionMode_t c_mode, int pad_h, int pad_w, int stride_h, int stride_w, int dilation_h, int dilation_w)

Creates a 2-D convolution layer descriptor.

miopenConvAlgorithm_t

miopenConvAlgorithm_t

Definition: miopen.h:1276

miopenConvolutionBackwardData

miopenStatus_t miopenConvolutionBackwardData(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvBwdDataAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace, size_t workSpaceSize)

Execute a backward data convolution layer.

miopenGetConvolutionAttribute

miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc, const miopenConvolutionAttrib_t attr, int *value)

Get the attribute of the convolution descriptor.

miopenGetConvolutionNdForwardOutputDim

miopenStatus_t miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t inputTensorDesc, const miopenTensorDescriptor_t filterDesc, int *nDim, int *outputTensorDimA)

Get the shape of a resulting N-dimensional tensor from a (N-2)-dimensional convolution.

miopenConvolutionBackwardWeightsCompileSolution

miopenStatus_t miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, const uint64_t solution_id)

Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionBac...

miopenFindConvolutionBackwardWeightsAlgorithm

miopenStatus_t miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, void *dw, const int requestAlgoCount, int *returnedAlgoCount, miopenConvAlgoPerf_t *perfResults, void *workSpace, size_t workSpaceSize, bool exhaustiveSearch)

Search and run the backwards weights convolutional algorithms and return a list of kernel times.

miopenGetConvolutionForwardOutputDim

miopenStatus_t miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t inputTensorDesc, const miopenTensorDescriptor_t filterDesc, int *n, int *c, int *h, int *w)

Get the shape of a resulting 4-D tensor from a 2-D convolution.

miopenConvFwdAlgorithm_t

miopenConvFwdAlgorithm_t

Definition: miopen.h:1239

miopenConvolutionForwardGetWorkSpaceSize

miopenStatus_t miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Query the workspace size required for a forward convolution algorithm.

miopenCreateConvolutionDescriptor

miopenStatus_t miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t *convDesc)

Creates a convolution layer descriptor.

miopenConvolutionBackwardWeightsGetSolution

miopenStatus_t miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, const size_t maxSolutionCount, size_t *solutionCount, miopenConvSolution_t *solutions)

Query the applicable solutions for a backward convolution w-r-t weights as described by input,...

miopenGetConvolutionNdDescriptor

miopenStatus_t miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc, int requestedSpatialDim, int *spatialDim, int *padA, int *strideA, int *dilationA, miopenConvolutionMode_t *c_mode)

Retrieves a N-dimensional convolution layer descriptor's details.

miopenConvBwdDataAlgorithm_t

miopenConvBwdDataAlgorithm_t

Definition: miopen.h:1262

miopenConvolutionAttrib_t

miopenConvolutionAttrib_t

Definition: miopen.h:633

miopenConvolutionBackwardWeightsGetWorkSpaceSize

miopenStatus_t miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, size_t *workSpaceSize)

Get the GPU memory required for the backward weights convolution algorithm.

miopenConvolutionBackwardWeightsImmediate

miopenStatus_t miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, void *dw, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)

Executes the Backward convolution w-r-t weights operation based on the provided solution ID.

miopenFindConvolutionBackwardDataAlgorithm

miopenStatus_t miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, void *dx, const int requestAlgoCount, int *returnedAlgoCount, miopenConvAlgoPerf_t *perfResults, void *workSpace, size_t workSpaceSize, bool exhaustiveSearch)

Search and run the backwards data convolution algorithms and return a list of kernel times.

miopenConvolutionBackwardDataGetSolution

miopenStatus_t miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const size_t maxSolutionCount, size_t *solutionCount, miopenConvSolution_t *solutions)

Query the applicable solutions for a backward convolution w-r-t data as described by input,...

miopenConvolutionForwardBias

miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t bDesc, const void *b, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)

Calculate element-wise scale and shift of a tensor via a bias tensor.

miopenConvolutionMode_t

miopenConvolutionMode_t

Definition: miopen.h:437

miopenSetConvolutionAttribute

miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc, const miopenConvolutionAttrib_t attr, int value)

Set the attribute of the convolution descriptor.

miopenConvolutionBackwardDataImmediate

miopenStatus_t miopenConvolutionBackwardDataImmediate(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace, size_t workSpaceSize, const uint64_t solution_id)

Executes the Backward convolution w-r-t data operation based on the provided solution ID.

miopenSetTransposeConvNdOutputPadding

miopenStatus_t miopenSetTransposeConvNdOutputPadding(miopenConvolutionDescriptor_t convDesc, int spatialDim, const int *adjA)

Set the output padding to be used in N-dimensional Transpose convolution.

miopenSetConvolutionFindMode

miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t findMode)

Sets the Find Mode attribute in the convolution descriptor.

miopenSetTransposeConvOutputPadding

miopenStatus_t miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w)

Set the output padding to be used in 2-D Transpose convolution.

miopenConvolutionFindMode_t

miopenConvolutionFindMode_t

Definition: miopen.h:662

miopenGetConvolutionSpatialDim

miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc, int *spatialDim)

Retrieves the spatial dimension of a convolution layer descriptor.

miopenConvBwdWeightsAlgorithm_t

miopenConvBwdWeightsAlgorithm_t

Definition: miopen.h:1251

miopenConvolutionForwardCompileSolution

miopenStatus_t miopenConvolutionForwardCompileSolution(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const uint64_t solution_id)

Compiles the solution provided by the user, this solution may be acquired by the miopenConvolutionFor...

miopenConvolutionBackwardDataGetSolutionCount

miopenStatus_t miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, size_t *solutionCount)

Query the maximum number of solutions applicable for the given input/output and weights tensor descri...

miopenConvolutionBackwardWeights

miopenStatus_t miopenConvolutionBackwardWeights(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenConvolutionDescriptor_t convDesc, miopenConvBwdWeightsAlgorithm_t algo, const void *beta, const miopenTensorDescriptor_t dwDesc, void *dw, void *workSpace, size_t workSpaceSize)

Execute a backward weights convolution layer.

miopenConvolutionBackwardDataGetWorkSpaceSize

miopenStatus_t miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, size_t *workSpaceSize)

Query the workspace size required for a backward data convolution algorithm.

miopenFindConvolutionForwardAlgorithm

miopenStatus_t miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, void *y, const int requestAlgoCount, int *returnedAlgoCount, miopenConvAlgoPerf_t *perfResults, void *workSpace, size_t workSpaceSize, bool exhaustiveSearch)

Search and run the forward convolutional algorithms and return a list of kernel times.

miopenDestroyConvolutionDescriptor

miopenStatus_t miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc)

Destroys the tensor descriptor object.

miopenConvolutionBackwardWeightsGetSolutionCount

miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, size_t *solutionCount)

Query the maximum number of solutions applicable for the given input/output and weights tensor descri...

miopenSetConvolutionGroupCount

miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int groupCount)

Set the number of groups to be used in Group/Depthwise convolution.

miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize

miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dwDesc, const uint64_t solution_id, size_t *workSpaceSize)

Returns the workspace size required for a particular solution id.

miopenConvolutionForwardGetSolution

miopenStatus_t miopenConvolutionForwardGetSolution(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, const size_t maxSolutionCount, size_t *solutionCount, miopenConvSolution_t *solutions)

Query the applicable solutions for a convolution configuration described by input,...

miopenGetConvolutionDescriptor

miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc, miopenConvolutionMode_t *c_mode, int *pad_h, int *pad_w, int *stride_h, int *stride_w, int *dilation_h, int *dilation_w)

Retrieves a 2-D convolution layer descriptor's details.

miopenConvolutionForwardGetSolutionCount

miopenStatus_t miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle, const miopenTensorDescriptor_t wDesc, const miopenTensorDescriptor_t xDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t yDesc, size_t *solutionCount)

Query the maximum number of solutions applicable for the given input/output and weights tensor descri...

miopenConvolutionBackwardDataGetSolutionWorkspaceSize

miopenStatus_t miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t wDesc, const miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t dxDesc, const uint64_t solution_id, size_t *workSpaceSize)

Returns the workspace size required for a particular solution id.

miopenConvolutionBackwardBias

miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t dyDesc, const void *dy, const void *beta, const miopenTensorDescriptor_t dbDesc, void *db)

Calculates the gradient with respect to the bias.

miopenConvolutionAlgoDirect

@ miopenConvolutionAlgoDirect

Definition: miopen.h:1278

miopenConvolutionAlgoWinograd

@ miopenConvolutionAlgoWinograd

Definition: miopen.h:1280

miopenConvolutionAlgoFFT

@ miopenConvolutionAlgoFFT

Definition: miopen.h:1279

miopenConvolutionAlgoImplicitGEMM

@ miopenConvolutionAlgoImplicitGEMM

Definition: miopen.h:1281

miopenConvolutionAlgoGEMM

@ miopenConvolutionAlgoGEMM

Definition: miopen.h:1277

miopenConvolutionFwdAlgoFFT

@ miopenConvolutionFwdAlgoFFT

Definition: miopen.h:1242

miopenConvolutionFwdAlgoImplicitGEMM

@ miopenConvolutionFwdAlgoImplicitGEMM

Definition: miopen.h:1244

miopenConvolutionFwdAlgoGEMM

@ miopenConvolutionFwdAlgoGEMM

Definition: miopen.h:1240

miopenConvolutionFwdAlgoWinograd

@ miopenConvolutionFwdAlgoWinograd

Definition: miopen.h:1243

miopenConvolutionFwdAlgoDirect

@ miopenConvolutionFwdAlgoDirect

Definition: miopen.h:1241

miopenTransposeBwdDataAlgoGEMM

@ miopenTransposeBwdDataAlgoGEMM

Definition: miopen.h:1267

miopenConvolutionBwdDataAlgoDirect

@ miopenConvolutionBwdDataAlgoDirect

Definition: miopen.h:1264

miopenConvolutionBwdDataAlgoGEMM

@ miopenConvolutionBwdDataAlgoGEMM

Definition: miopen.h:1263

miopenConvolutionBwdDataAlgoFFT

@ miopenConvolutionBwdDataAlgoFFT

Definition: miopen.h:1265

miopenConvolutionBwdDataAlgoWinograd

@ miopenConvolutionBwdDataAlgoWinograd

Definition: miopen.h:1266

miopenConvolutionBwdDataAlgoImplicitGEMM

@ miopenConvolutionBwdDataAlgoImplicitGEMM

Definition: miopen.h:1269

miopenConvolutionBwdWeightsAlgoGEMM

@ miopenConvolutionBwdWeightsAlgoGEMM

Definition: miopen.h:1252

miopenConvolutionBwdWeightsAlgoWinograd

@ miopenConvolutionBwdWeightsAlgoWinograd

Definition: miopen.h:1254

miopenConvolutionBwdWeightsAlgoDirect

@ miopenConvolutionBwdWeightsAlgoDirect

Definition: miopen.h:1253

miopenConvolutionBwdWeightsAlgoImplicitGEMM

@ miopenConvolutionBwdWeightsAlgoImplicitGEMM

Definition: miopen.h:1255

miopenDestroyDropoutDescriptor

miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)

Destroys the dropout descriptor object.

miopenRNGType_t

miopenRNGType_t

Definition: miopen.h:5593

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:5594

miopenFindResultsOrder_t

miopenFindResultsOrder_t

Definition: miopen.h:6024

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:6052

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:5943

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:5930

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:6026

miopenFindResultsOrderByTime

@ miopenFindResultsOrderByTime

Definition: miopen.h:6025

miopenMhaMaskCausal

@ miopenMhaMaskCausal

Definition: miopen.h:6054

miopenMhaMaskNone

@ miopenMhaMaskNone

Definition: miopen.h:6053

miopenTensorMhaDescaleS

@ miopenTensorMhaDescaleS

Definition: miopen.h:5955

miopenTensorMhaO

@ miopenTensorMhaO

Definition: miopen.h:5961

miopenTensorMhaAmaxDV

@ miopenTensorMhaAmaxDV

Definition: miopen.h:5979

miopenTensorBatchnormScaleDiff

@ miopenTensorBatchnormScaleDiff

Definition: miopen.h:6002

miopenTensorMhaMask

@ miopenTensorMhaMask

Definition: miopen.h:6013

miopenTensorMhaDescaleDS

@ miopenTensorMhaDescaleDS

Definition: miopen.h:5969

miopenTensorMhaDropoutSeed

@ miopenTensorMhaDropoutSeed

Definition: miopen.h:5959

miopenTensorBatchnormSavedMean

@ miopenTensorBatchnormSavedMean

Definition: miopen.h:5999

miopenTensorActivationDY

@ miopenTensorActivationDY

Definition: miopen.h:5987

miopenTensorBatchnormDX

@ miopenTensorBatchnormDX

Definition: miopen.h:6007

miopenTensorMhaDescaleV

@ miopenTensorMhaDescaleV

Definition: miopen.h:5954

miopenTensorMhaK

@ miopenTensorMhaK

Definition: miopen.h:5949

miopenTensorConvolutionX

@ miopenTensorConvolutionX

Definition: miopen.h:5945

miopenTensorMhaAmaxDK

@ miopenTensorMhaAmaxDK

Definition: miopen.h:5978

miopenTensorMhaScaleDS

@ miopenTensorMhaScaleDS

Definition: miopen.h:5970

miopenTensorBatchnormBias

@ miopenTensorBatchnormBias

Definition: miopen.h:6005

miopenTensorMhaM

@ miopenTensorMhaM

Definition: miopen.h:5964

miopenTensorBatchnormRunningMean

@ miopenTensorBatchnormRunningMean

Definition: miopen.h:5997

miopenTensorMhaDropoutProbability

@ miopenTensorMhaDropoutProbability

Definition: miopen.h:5958

miopenTensorSoftmaxY

@ miopenTensorSoftmaxY

Definition: miopen.h:5992

miopenTensorSoftmaxDY

@ miopenTensorSoftmaxDY

Definition: miopen.h:5994

miopenTensorMhaDescaleO

@ miopenTensorMhaDescaleO

Definition: miopen.h:5967

miopenTensorMhaScaleO

@ miopenTensorMhaScaleO

Definition: miopen.h:5957

miopenScalarBatchnormExpAvgFactor

@ miopenScalarBatchnormExpAvgFactor

Definition: miopen.h:6015

miopenTensorBatchnormScale

@ miopenTensorBatchnormScale

Definition: miopen.h:6001

miopenTensorBatchnormRunningVariance

@ miopenTensorBatchnormRunningVariance

Definition: miopen.h:5998

miopenTensorActivationDX

@ miopenTensorActivationDX

Definition: miopen.h:5986

miopenTensorMhaScaleDK

@ miopenTensorMhaScaleDK

Definition: miopen.h:5972

miopenTensorMhaV

@ miopenTensorMhaV

Definition: miopen.h:5951

miopenTensorMhaAmaxS

@ miopenTensorMhaAmaxS

Definition: miopen.h:5963

miopenTensorBatchnormBiasDiff

@ miopenTensorBatchnormBiasDiff

Definition: miopen.h:6006

miopenTensorBatchnormSavedVariance

@ miopenTensorBatchnormSavedVariance

Definition: miopen.h:6000

miopenTensorActivationX

@ miopenTensorActivationX

Definition: miopen.h:5984

miopenTensorMhaScaleDV

@ miopenTensorMhaScaleDV

Definition: miopen.h:5973

miopenTensorMhaAmaxO

@ miopenTensorMhaAmaxO

Definition: miopen.h:5962

miopenScalarBatchnormEpsilon

@ miopenScalarBatchnormEpsilon

Definition: miopen.h:6016

miopenTensorMhaScaleDQ

@ miopenTensorMhaScaleDQ

Definition: miopen.h:5971

miopenTensorSoftmaxDX

@ miopenTensorSoftmaxDX

Definition: miopen.h:5993

miopenTensorMhaAmaxDS

@ miopenTensorMhaAmaxDS

Definition: miopen.h:5980

miopenTensorMhaDV

@ miopenTensorMhaDV

Definition: miopen.h:5976

miopenTensorMhaQ

@ miopenTensorMhaQ

Definition: miopen.h:5950

miopenTensorMhaAmaxDQ

@ miopenTensorMhaAmaxDQ

Definition: miopen.h:5977

miopenTensorConvolutionY

@ miopenTensorConvolutionY

Definition: miopen.h:5947

miopenTensorBatchnormEstimatedMean

@ miopenTensorBatchnormEstimatedMean

Definition: miopen.h:6003

miopenTensorBatchnormDY

@ miopenTensorBatchnormDY

Definition: miopen.h:6008

miopenTensorMhaZInv

@ miopenTensorMhaZInv

Definition: miopen.h:5965

miopenTensorMhaDescaleQ

@ miopenTensorMhaDescaleQ

Definition: miopen.h:5953

miopenTensorMhaBias

@ miopenTensorMhaBias

Definition: miopen.h:5981

miopenTensorBatchnormEstimatedVariance

@ miopenTensorBatchnormEstimatedVariance

Definition: miopen.h:6004

miopenTensorArgumentIsScalar

@ miopenTensorArgumentIsScalar

Definition: miopen.h:6011

miopenTensorArgumentIdInvalid

@ miopenTensorArgumentIdInvalid

Definition: miopen.h:5944

miopenTensorMhaDO

@ miopenTensorMhaDO

Definition: miopen.h:5966

miopenTensorMhaDescaleDO

@ miopenTensorMhaDescaleDO

Definition: miopen.h:5968

miopenTensorConvolutionW

@ miopenTensorConvolutionW

Definition: miopen.h:5946

miopenTensorMhaDescaleK

@ miopenTensorMhaDescaleK

Definition: miopen.h:5952

miopenTensorMhaDropoutOffset

@ miopenTensorMhaDropoutOffset

Definition: miopen.h:5960

miopenTensorBiasY

@ miopenTensorBiasY

Definition: miopen.h:5989

miopenTensorMhaDQ

@ miopenTensorMhaDQ

Definition: miopen.h:5974

miopenTensorSoftmaxX

@ miopenTensorSoftmaxX

Definition: miopen.h:5991

miopenTensorBatchnormY

@ miopenTensorBatchnormY

Definition: miopen.h:5996

miopenTensorMhaScaleS

@ miopenTensorMhaScaleS

Definition: miopen.h:5956

miopenTensorBias

@ miopenTensorBias

Definition: miopen.h:5990

miopenTensorActivationY

@ miopenTensorActivationY

Definition: miopen.h:5985

miopenTensorBatchnormX

@ miopenTensorBatchnormX

Definition: miopen.h:5995

miopenTensorBiasX

@ miopenTensorBiasX

Definition: miopen.h:5988

miopenTensorMhaDK

@ miopenTensorMhaDK

Definition: miopen.h:5975

miopenProblemDirectionBackwardWeights

@ miopenProblemDirectionBackwardWeights

Definition: miopen.h:5933

miopenProblemDirectionInference

@ miopenProblemDirectionInference

Definition: miopen.h:5935

miopenProblemDirectionForward

@ miopenProblemDirectionForward

Definition: miopen.h:5931

miopenProblemDirectionBackward

@ miopenProblemDirectionBackward

Definition: miopen.h:5932

miopenGetGetitemWorkspaceSize

miopenStatus_t miopenGetGetitemWorkspaceSize(miopenHandle_t handle, uint32_t indexCount, const miopenTensorDescriptor_t *indexDescs, size_t *sizeInBytes)

Helper function to query the minimum workspace size required by the getitem call.

miopenGetitemBackward

miopenStatus_t miopenGetitemBackward(miopenHandle_t handle, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, uint32_t indexCount, const miopenTensorDescriptor_t *indexDescs, const void *const *indexs, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t errorDesc, void *error, uint32_t dimCount, const int32_t *dims, uint32_t sliceCount, const int32_t *slices, uint32_t offset)

Execute a getitem backward layer.

miopenGroupNormForward

miopenStatus_t miopenGroupNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const uint64_t num_groups, const float epsilon, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)

Execute a groupnorm forward layer.

miopenCreateWithStream

miopenStatus_t miopenCreateWithStream(miopenHandle_t *handle, miopenAcceleratorQueue_t stream)

Create a MIOpen handle with an accelerator stream.

miopenDestroy

miopenStatus_t miopenDestroy(miopenHandle_t handle)

Destroys the MIOpen handle.

miopenTuningPolicy_t

miopenTuningPolicy_t

Definition: miopen.h:8541

miopenGetTuningPolicy

miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t *value)

Get tuning policy from a handle.

miopenDeallocatorFunction

void(* miopenDeallocatorFunction)(void *context, void *memory)

Custom deallocator function.

Definition: miopen.h:166

miopenMathType_t

miopenMathType_t

Definition: miopen.h:124

miopenGetStream

miopenStatus_t miopenGetStream(miopenHandle_t handle, miopenAcceleratorQueue_t *streamID)

Get the previously created accelerator command queue.

miopenEnableProfiling

miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable)

Enable profiling to retrieve kernel time.

miopenGetVersion

miopenStatus_t miopenGetVersion(size_t *major, size_t *minor, size_t *patch)

Method to return version of MIOpen.

miopenSetTuningPolicy

miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t newValue)

Update tuning policy for a specific handle. API alternative for MIOPEN_FIND_ENFORCE environment varia...

miopenStatus_t

miopenStatus_t

Definition: miopen.h:109

miopenSetAllocator

miopenStatus_t miopenSetAllocator(miopenHandle_t handle, miopenAllocatorFunction allocator, miopenDeallocatorFunction deallocator, void *allocatorContext)

Set allocator for previously created miopenHandle.

miopenF8RoundingMode_t

miopenF8RoundingMode_t

Definition: miopen.h:133

miopenAllocatorFunction

void *(* miopenAllocatorFunction)(void *context, size_t sizeBytes)

Custom allocator function.

Definition: miopen.h:156

miopenGetErrorString

const char * miopenGetErrorString(miopenStatus_t error)

Get character string for an error code.

miopenCreate

miopenStatus_t miopenCreate(miopenHandle_t *handle)

Method to create the MIOpen handle object.

miopenGetKernelTime

miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float *time)

Get time for last kernel launched.

miopenSetStream

miopenStatus_t miopenSetStream(miopenHandle_t handle, miopenAcceleratorQueue_t streamID)

Set accelerator command queue previously created.

miopenMathDefault

@ miopenMathDefault

Definition: miopen.h:126

miopenMathPedantic

@ miopenMathPedantic

Definition: miopen.h:127

miopenStatusUnsupportedOp

@ miopenStatusUnsupportedOp

Definition: miopen.h:118

miopenStatusGpuOperationsSkipped

@ miopenStatusGpuOperationsSkipped

Definition: miopen.h:119

miopenStatusUnknownError

@ miopenStatusUnknownError

Definition: miopen.h:117

miopenStatusSuccess

@ miopenStatusSuccess

Definition: miopen.h:110

miopenStatusVersionMismatch

@ miopenStatusVersionMismatch

Definition: miopen.h:120

miopenStatusAllocFailed

@ miopenStatusAllocFailed

Definition: miopen.h:114

miopenStatusNotImplemented

@ miopenStatusNotImplemented

Definition: miopen.h:116

miopenStatusBadParm

@ miopenStatusBadParm

Definition: miopen.h:113

miopenStatusNotInitialized

@ miopenStatusNotInitialized

Definition: miopen.h:111

miopenStatusInternalError

@ miopenStatusInternalError

Definition: miopen.h:115

miopenStatusInvalidValue

@ miopenStatusInvalidValue

Definition: miopen.h:112

miopenF8RoundingModeStandard

@ miopenF8RoundingModeStandard

Definition: miopen.h:134

miopenF8RoundingModeStochastic

@ miopenF8RoundingModeStochastic

Definition: miopen.h:135

miopenKthvalueForward

miopenStatus_t miopenKthvalueForward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t outputDesc, void *output, miopenTensorDescriptor_t indicesDesc, size_t *indices, size_t k, int32_t dim=-1, bool keepDim=false)

Execute a Kthvalue forward layer.

miopenLayerNormForward

miopenStatus_t miopenLayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const float epsilon, const int32_t normalized_dim, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)

Execute a layernorm forward layer.

miopenT5LayerNormBackward

miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle, miopenNormMode_t mode, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t rstdDesc, const void *rstd, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t dwDesc, void *dw)

Execute a T5layernorm backward layer.

miopenLayerNormBackward

miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle, miopenNormMode_t mode, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t meanDesc, const void *mean, const miopenTensorDescriptor_t rstdDesc, const void *rstd, const int32_t normalized_dim, const miopenTensorDescriptor_t dxDesc, void *dx, const miopenTensorDescriptor_t dwDesc, void *dw, const miopenTensorDescriptor_t dbDesc, void *db)

Execute a layernorm backward layer.

miopenT5LayerNormForward

miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t weightDesc, const void *weight, const float epsilon, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t rstdDesc, void *rstd)

Execute a T5layernorm forward layer.

miopenNormMode_t

miopenNormMode_t

Definition: miopen.h:493

miopenGetLayerNormBackwardWorkspaceSize

miopenStatus_t miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenTensorDescriptor_t weightDesc, const miopenTensorDescriptor_t meanDesc, const miopenTensorDescriptor_t rstdDesc, const int32_t normalized_dim, const miopenTensorDescriptor_t dxDesc, const miopenTensorDescriptor_t dwDesc, const miopenTensorDescriptor_t dbDesc, size_t *sizeInBytes)

Helper function to query the minimum workspace size required by the layernorm backward call.

miopenGetT5LayerNormBackwardWorkspaceSize

miopenStatus_t miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t dyDesc, const miopenTensorDescriptor_t xDesc, const miopenTensorDescriptor_t weightDesc, const miopenTensorDescriptor_t rstdDesc, const miopenTensorDescriptor_t dxDesc, const miopenTensorDescriptor_t dwDesc, size_t *sizeInBytes)

Helper function to query the minimum workspace size required by the T5layernorm backward call.

miopenAddLayerNormForward

miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle, miopenNormMode_t mode, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t x2Desc, const void *x2, const miopenTensorDescriptor_t weightDesc, const void *weight, const miopenTensorDescriptor_t biasDesc, const void *bias, const float epsilon, const int32_t normalized_dim, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t meanDesc, void *mean, const miopenTensorDescriptor_t rstdDesc, void *rstd)

Execute a add and layernorm forward layer.

miopenSet2dPoolingDescriptor

miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc, miopenPoolingMode_t mode, int windowHeight, int windowWidth, int pad_h, int pad_w, int stride_h, int stride_w)

Sets a 2-D pooling layer descriptor details.

miopenSetPoolingWorkSpaceIndexMode

miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index)

Set workspace index mode for pooling layer. The default mode is miopenPoolingWorkSpaceIndexMask.

miopenGetPoolingForwardOutputDim

miopenStatus_t miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t tensorDesc, int *n, int *c, int *h, int *w)

Gets the shape of the output tensor for 2-D pooling.

miopenPoolingGetWorkSpaceSize

miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Get the amount of GPU memory required for pooling.

miopenSetNdPoolingDescriptor

miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc, const miopenPoolingMode_t mode, int nbDims, const int *windowDimA, const int *padA, const int *stridesA)

Set details of a N-D pooling layer descriptor.

miopenPoolingForward

miopenStatus_t miopenPoolingForward(miopenHandle_t handle, const miopenPoolingDescriptor_t poolDesc, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, bool do_backward, void *workSpace, size_t workSpaceSize)

Execute a forward pooling layer.

miopenPoolingMode_t

miopenPoolingMode_t

Definition: miopen.h:460

miopenPoolingGetWorkSpaceSizeV2

miopenStatus_t miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Get the amount of GPU memory required for pooling.

miopenGetPoolingWorkSpaceIndexMode

miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t *workspace_index)

Get workspace index mode for pooling layer.

miopenIndexType_t

miopenIndexType_t

Definition: miopen.h:413

miopenGetPoolingIndexType

miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t *index_type)

Get the index data type for pooling layer. The index type to any of the miopenIndexType_t sizes; 8,...

miopenPoolingWorkspaceIndexMode_t

miopenPoolingWorkspaceIndexMode_t

Definition: miopen.h:473

miopenGetPoolingNdForwardOutputDim

miopenStatus_t miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc, const miopenTensorDescriptor_t tensorDesc, int dims, int *tensorDimArr)

Gets the shape of the output tensor for N-D pooling.

miopenGetNdPoolingDescriptor

miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc, int nbDimsRequested, miopenPoolingMode_t *mode, int *nbDims, int *windowDimA, int *padA, int *stridesA)

Get details of a N-D pooling layer descriptor.

miopenCreatePoolingDescriptor

miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t *poolDesc)

Creates a pooling layer descriptor.

miopenSetPoolingIndexType

miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t index_type)

Set index data type for pooling layer. The default indexing type is uint8_t. Users can set the index ...

miopenGet2dPoolingDescriptor

miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc, miopenPoolingMode_t *mode, int *windowHeight, int *windowWidth, int *pad_h, int *pad_w, int *stride_h, int *stride_w)

Gets a 2-D pooling layer descriptor details.

miopenDestroyPoolingDescriptor

miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc)

Destroys the pooling descriptor object.

miopenPoolingBackward

miopenStatus_t miopenPoolingBackward(miopenHandle_t handle, const miopenPoolingDescriptor_t poolDesc, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, void *workSpace)

Execute a backward pooling layer.

miopenReduceCalculationForward

miopenStatus_t miopenReduceCalculationForward(miopenHandle_t handle, miopenReduceCalculationNanPropagation_t nanPropagation, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t xDesc, const void *x, const int32_t dim, const miopenReduceCalculationOp_t reduceCalculationOp, const miopenTensorDescriptor_t reduceDesc, void *y)

Execute a reducecalculation forward layer.

miopenReduceCalculationOp_t

miopenReduceCalculationOp_t

Definition: miopen.h:6457

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:6458

MIOPEN_REDUCE_CALCULATION_SUM

@ MIOPEN_REDUCE_CALCULATION_SUM

Definition: miopen.h:6460

miopenSoftmaxBackward_V2

miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx, miopenSoftmaxAlgorithm_t algorithm, miopenSoftmaxMode_t mode)

Execute a softmax backwards layer with expanded modes and algorithms.

miopenSoftmaxForward

miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)

Execute a softmax forward layer.

miopenSoftmaxForward_V2

miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y, miopenSoftmaxAlgorithm_t algorithm, miopenSoftmaxMode_t mode)

Execute a softmax forward layer with expanded modes and algorithms.

miopenSoftmaxBackward

miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t yDesc, const void *y, const miopenTensorDescriptor_t dyDesc, const void *dy, const void *beta, const miopenTensorDescriptor_t dxDesc, void *dx)

Execute a softmax backwards layer.

miopenSoftmaxMode_t

miopenSoftmaxMode_t

Definition: miopen.h:556

miopenSoftmaxAlgorithm_t

miopenSoftmaxAlgorithm_t

Definition: miopen.h:545

miopenDestroySeqTensorDescriptor

miopenStatus_t miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc)

Destroys the sequence data tensor descriptor.

miopenGetTensorDescriptor

miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t *dataType, int *dimsA, int *stridesA)

Get the details of the N-dimensional tensor descriptor.

miopenSetNdTensorDescriptorWithLayout

miopenStatus_t miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, miopenTensorLayout_t tensorLayout, const int *lens, int num_lens)

Set shape of ND tensor with specific layout.

miopenSetTensor

miopenStatus_t miopenSetTensor(miopenHandle_t handle, const miopenTensorDescriptor_t yDesc, void *y, const void *alpha)

Fills a tensor with a single value.

miopenOpTensor

miopenStatus_t miopenOpTensor(miopenHandle_t handle, miopenTensorOp_t tensorOp, const void *alpha1, const miopenTensorDescriptor_t aDesc, const void *A, const void *alpha2, const miopenTensorDescriptor_t bDesc, const void *B, const void *beta, const miopenTensorDescriptor_t cDesc, void *C)

Execute element-wise tensor operations.

miopenGetTensorNumBytes

miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc, size_t *numBytes)

Returns number of bytes associated with tensor descriptor.

miopenGet4dTensorDescriptor

miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t *dataType, int *n, int *c, int *h, int *w, int *nStride, int *cStride, int *hStride, int *wStride)

Get the details of the tensor descriptor.

miopenTensorLayout_t

miopenTensorLayout_t

Definition: miopen.h:396

miopenTransformTensor

miopenStatus_t miopenTransformTensor(miopenHandle_t handle, const void *alpha, const miopenTensorDescriptor_t xDesc, const void *x, const void *beta, const miopenTensorDescriptor_t yDesc, void *y)

Copies one tensor to another tensor with a different layout/scale.

miopenCreateTensorDescriptor

miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t *tensorDesc)

Create a Tensor Descriptor.

miopenSetTensorDescriptorV2

miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int nbDims, const size_t *dimsA, const size_t *stridesA)

Set shape of N-dimensional tensor.

miopenScaleTensor

miopenStatus_t miopenScaleTensor(miopenHandle_t handle, const miopenTensorDescriptor_t yDesc, void *y, const void *alpha)

Scales all elements in a tensor by a single value.

miopenSetTensorCastType

miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc, miopenDataType_t cast_type)

Set the tensor cast type.

miopenSet4dTensorDescriptor

miopenStatus_t miopenSet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w)

Set shape of 4D tensor.

miopenSet4dTensorDescriptorEx

miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w, int nStride, int cStride, int hStride, int wStride)

Set shape and stride of 4D tensor.

miopenDataType_t

miopenDataType_t

Definition: miopen.h:376

miopenCreateSeqTensorDescriptor

miopenStatus_t miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t *tensorDesc)

Create a Tensor Descriptor for sequence data.

miopenTensorOp_t

miopenTensorOp_t

Definition: miopen.h:425

miopenGetTensorDescriptorSize

miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc, int *size)

Set shape of N-dimensional tensor.

miopenDestroyTensorDescriptor

miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc)

Destroys the tensor descriptor.

miopenSetTensorDescriptor

miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int nbDims, const int *dimsA, const int *stridesA)

Set shape of N-dimensional tensor.

miopenPaddingMode_t

miopenPaddingMode_t

Definition: miopen.h:449

miopenPaddingDefault

@ miopenPaddingDefault

Definition: miopen.h:450

miopenPaddingSame

@ miopenPaddingSame

Definition: miopen.h:451

miopenPaddingValid

@ miopenPaddingValid

Definition: miopen.h:452

miopenReduceCalculationNanPropagation_t

miopenReduceCalculationNanPropagation_t

Definition: miopen.h:6441

MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

Definition: miopen.h:6443

MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

Definition: miopen.h:6442

MIOPEN_DECLARE_OBJECT

#define MIOPEN_DECLARE_OBJECT(name)

Definition: miopen.h:79

miopenNanPropagation_t

miopenNanPropagation_t

Definition: miopen.h:601

MIOPEN_PROPAGATE_NAN

@ MIOPEN_PROPAGATE_NAN

Definition: miopen.h:603

MIOPEN_NOT_PROPAGATE_NAN

@ MIOPEN_NOT_PROPAGATE_NAN

Definition: miopen.h:602

MIOPEN_LOSS_REDUCTION_MEAN

@ MIOPEN_LOSS_REDUCTION_MEAN

Definition: miopen.h:8361

MIOPEN_LOSS_REDUCTION_SUM

@ MIOPEN_LOSS_REDUCTION_SUM

Definition: miopen.h:8360

MIOPEN_LOSS_REDUCTION_NONE

@ MIOPEN_LOSS_REDUCTION_NONE

Definition: miopen.h:8359

miopenTuningPolicyDbClean

@ miopenTuningPolicyDbClean

Definition: miopen.h:8546

miopenTuningPolicyDbUpdate

@ miopenTuningPolicyDbUpdate

Definition: miopen.h:8543

miopenTuningPolicyNone

@ miopenTuningPolicyNone

Definition: miopen.h:8542

miopenTuningPolicySearch

@ miopenTuningPolicySearch

Definition: miopen.h:8544

miopenTuningPolicySearchDbUpdate

@ miopenTuningPolicySearchDbUpdate

Definition: miopen.h:8545

miopenPoolingAverage

@ miopenPoolingAverage

Definition: miopen.h:462

miopenPoolingAverageInclusive

@ miopenPoolingAverageInclusive

Definition: miopen.h:463

miopenPoolingMax

@ miopenPoolingMax

Definition: miopen.h:461

miopenTensorCHWN

@ miopenTensorCHWN

Definition: miopen.h:399

miopenTensorNHWC

@ miopenTensorNHWC

Definition: miopen.h:398

miopenTensorNDHWC

@ miopenTensorNDHWC

Definition: miopen.h:405

miopenTensorNCHW

@ miopenTensorNCHW

Definition: miopen.h:397

miopenTensorCHWNc4

@ miopenTensorCHWNc4

Definition: miopen.h:402

miopenTensorNCHWc8

@ miopenTensorNCHWc8

Definition: miopen.h:401

miopenTensorNCDHW

@ miopenTensorNCDHW

Definition: miopen.h:404

miopenTensorCHWNc8

@ miopenTensorCHWNc8

Definition: miopen.h:403

miopenTensorNCHWc4

@ miopenTensorNCHWc4

Definition: miopen.h:400

MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

Definition: miopen.h:613

MIOPEN_REDUCE_TENSOR_NO_INDICES

@ MIOPEN_REDUCE_TENSOR_NO_INDICES

Definition: miopen.h:612

miopenActivationLEAKYRELU

@ miopenActivationLEAKYRELU

Definition: miopen.h:532

miopenActivationPASTHRU

@ miopenActivationPASTHRU

Definition: miopen.h:523

miopenActivationABS

@ miopenActivationABS

Definition: miopen.h:528

miopenActivationLOGISTIC

@ miopenActivationLOGISTIC

Definition: miopen.h:524

miopenActivationCLIPPEDRELU

@ miopenActivationCLIPPEDRELU

Definition: miopen.h:530

miopenActivationRELU

@ miopenActivationRELU

Definition: miopen.h:526

miopenActivationPOWER

@ miopenActivationPOWER

Definition: miopen.h:529

miopenActivationELU

@ miopenActivationELU

Definition: miopen.h:534

miopenActivationCLAMP

@ miopenActivationCLAMP

Definition: miopen.h:537

miopenActivationSOFTRELU

@ miopenActivationSOFTRELU

Definition: miopen.h:527

miopenActivationTANH

@ miopenActivationTANH

Definition: miopen.h:525

MIOPEN_REDUCE_TENSOR_MUL

@ MIOPEN_REDUCE_TENSOR_MUL

Definition: miopen.h:578

MIOPEN_REDUCE_TENSOR_MAX

@ MIOPEN_REDUCE_TENSOR_MAX

Definition: miopen.h:582

MIOPEN_REDUCE_TENSOR_AVG

@ MIOPEN_REDUCE_TENSOR_AVG

Definition: miopen.h:586

MIOPEN_REDUCE_TENSOR_NORM1

@ MIOPEN_REDUCE_TENSOR_NORM1

Definition: miopen.h:588

MIOPEN_REDUCE_TENSOR_AMAX

@ MIOPEN_REDUCE_TENSOR_AMAX

Definition: miopen.h:584

MIOPEN_REDUCE_TENSOR_MIN

@ MIOPEN_REDUCE_TENSOR_MIN

Definition: miopen.h:580

MIOPEN_REDUCE_TENSOR_ADD

@ MIOPEN_REDUCE_TENSOR_ADD

Definition: miopen.h:577

MIOPEN_REDUCE_TENSOR_NORM2

@ MIOPEN_REDUCE_TENSOR_NORM2

Definition: miopen.h:590

MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

Definition: miopen.h:638

MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

Definition: miopen.h:642

MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE

@ MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE

Definition: miopen.h:651

MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

Definition: miopen.h:634

miopenIndexUint16

@ miopenIndexUint16

Definition: miopen.h:415

miopenIndexUint64

@ miopenIndexUint64

Definition: miopen.h:417

miopenIndexUint32

@ miopenIndexUint32

Definition: miopen.h:416

miopenIndexUint8

@ miopenIndexUint8

Definition: miopen.h:414

miopenFloat

@ miopenFloat

Definition: miopen.h:378

miopenBFloat8_fnuz

@ miopenBFloat8_fnuz

Definition: miopen.h:386

miopenBFloat16

@ miopenBFloat16

Definition: miopen.h:382

miopenInt8

@ miopenInt8

Definition: miopen.h:380

miopenInt32

@ miopenInt32

Definition: miopen.h:379

miopenHalf

@ miopenHalf

Definition: miopen.h:377

miopenInt64

@ miopenInt64

Definition: miopen.h:387

miopenDouble

@ miopenDouble

Definition: miopen.h:384

miopenFloat8_fnuz

@ miopenFloat8_fnuz

Definition: miopen.h:385

MIOPEN_8BIT_INDICES

@ MIOPEN_8BIT_INDICES

Definition: miopen.h:625

MIOPEN_32BIT_INDICES

@ MIOPEN_32BIT_INDICES

Definition: miopen.h:622

MIOPEN_16BIT_INDICES

@ MIOPEN_16BIT_INDICES

Definition: miopen.h:624

MIOPEN_64BIT_INDICES

@ MIOPEN_64BIT_INDICES

Definition: miopen.h:623

miopenPoolingWorkspaceIndexImage

@ miopenPoolingWorkspaceIndexImage

Definition: miopen.h:475

miopenPoolingWorkspaceIndexMask

@ miopenPoolingWorkspaceIndexMask

Definition: miopen.h:474

miopenDepthwise

@ miopenDepthwise

Definition: miopen.h:441

miopenGroupConv

@ miopenGroupConv

Definition: miopen.h:440

miopenTranspose

@ miopenTranspose

Definition: miopen.h:439

miopenConvolution

@ miopenConvolution

Definition: miopen.h:438

MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

Definition: miopen.h:497

MIOPEN_WEIGHT_BIAS

@ MIOPEN_WEIGHT_BIAS

Definition: miopen.h:495

MIOPEN_ELEMENTWISE_AFFINE

@ MIOPEN_ELEMENTWISE_AFFINE

Definition: miopen.h:494

MIOPEN_WEIGHT_BIAS_T5

@ MIOPEN_WEIGHT_BIAS_T5

Definition: miopen.h:503

MIOPEN_ELEMENTWISE_AFFINE_T5

@ MIOPEN_ELEMENTWISE_AFFINE_T5

Definition: miopen.h:501

MIOPEN_WEIGHT_BIAS_FUSED_ADD

@ MIOPEN_WEIGHT_BIAS_FUSED_ADD

Definition: miopen.h:499

MIOPEN_REDUCE_EXTREME_ARGMAX

@ MIOPEN_REDUCE_EXTREME_ARGMAX

Definition: miopen.h:6520

MIOPEN_REDUCE_EXTREME_MIN

@ MIOPEN_REDUCE_EXTREME_MIN

Definition: miopen.h:6522

MIOPEN_REDUCE_EXTREME_MAX

@ MIOPEN_REDUCE_EXTREME_MAX

Definition: miopen.h:6524

MIOPEN_REDUCE_EXTREME_ARGMIN

@ MIOPEN_REDUCE_EXTREME_ARGMIN

Definition: miopen.h:6518

miopenTensorOpMin

@ miopenTensorOpMin

Definition: miopen.h:428

miopenTensorOpAdd

@ miopenTensorOpAdd

Definition: miopen.h:426

miopenTensorOpMul

@ miopenTensorOpMul

Definition: miopen.h:427

miopenTensorOpMax

@ miopenTensorOpMax

Definition: miopen.h:429

miopenBNSpatial

@ miopenBNSpatial

Definition: miopen.h:514

miopenBNPerActivation

@ miopenBNPerActivation

Definition: miopen.h:513

miopenConvolutionFindModeDynamicHybrid

@ miopenConvolutionFindModeDynamicHybrid

Definition: miopen.h:674

miopenConvolutionFindModeDefault

@ miopenConvolutionFindModeDefault

Definition: miopen.h:681

miopenConvolutionFindModeTrustVerifyFull

@ miopenConvolutionFindModeTrustVerifyFull

Definition: miopen.h:680

miopenConvolutionFindModeTrustVerify

@ miopenConvolutionFindModeTrustVerify

Definition: miopen.h:679

miopenConvolutionFindModeHybrid

@ miopenConvolutionFindModeHybrid

Definition: miopen.h:669

miopenConvolutionFindModeFast

@ miopenConvolutionFindModeFast

Definition: miopen.h:665

miopenConvolutionFindModeNormal

@ miopenConvolutionFindModeNormal

Definition: miopen.h:663

miopenLRNWithinChannel

@ miopenLRNWithinChannel

Definition: miopen.h:484

miopenLRNCrossChannel

@ miopenLRNCrossChannel

Definition: miopen.h:485

MIOPEN_SOFTMAX_MODE_INSTANCE

@ MIOPEN_SOFTMAX_MODE_INSTANCE

Definition: miopen.h:557

MIOPEN_SOFTMAX_MODE_CHANNEL

@ MIOPEN_SOFTMAX_MODE_CHANNEL

Definition: miopen.h:558

MIOPEN_SOFTMAX_FAST

@ MIOPEN_SOFTMAX_FAST

Definition: miopen.h:546

MIOPEN_SOFTMAX_ACCURATE

@ MIOPEN_SOFTMAX_ACCURATE

Definition: miopen.h:547

MIOPEN_SOFTMAX_LOG

@ MIOPEN_SOFTMAX_LOG

Definition: miopen.h:548

miopenConvAlgoPerf_t

Perf struct for forward, backward filter, or backward data algorithms.

Definition: miopen.h:1291

miopenConvAlgoPerf_t::fwd_algo

miopenConvFwdAlgorithm_t fwd_algo

Definition: miopen.h:1294

miopenConvAlgoPerf_t::bwd_data_algo

miopenConvBwdDataAlgorithm_t bwd_data_algo

Definition: miopen.h:1298

miopenConvAlgoPerf_t::memory

size_t memory

Definition: miopen.h:1302

miopenConvAlgoPerf_t::bwd_weights_algo

miopenConvBwdWeightsAlgorithm_t bwd_weights_algo

Definition: miopen.h:1295

miopenConvAlgoPerf_t::time

float time

Definition: miopen.h:1301

miopenConvSolution_t

Performance struct for forward, backward filter, or backward data algorithms in immediate mode.

Definition: miopen.h:1315

miopenConvSolution_t::algorithm

miopenConvAlgorithm_t algorithm

Definition: miopen.h:1322

miopenConvSolution_t::solution_id

uint64_t solution_id

Definition: miopen.h:1321

miopenConvSolution_t::workspace_size

size_t workspace_size

Definition: miopen.h:1319

miopenConvSolution_t::time

float time

Definition: miopen.h:1316

miopenTensorArgument_t

Values of a tensor or scalar argument for the miopenRunSolution function.

Definition: miopen.h:6255

miopenTensorArgument_t::id

miopenTensorArgumentId_t id

Definition: miopen.h:6258

miopenTensorArgument_t::buffer

void * buffer

Definition: miopen.h:6268

miopenTensorArgument_t::descriptor

miopenTensorDescriptor_t * descriptor

Definition: miopen.h:6264