/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/latest/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 sum

68  * @defgroup ReduceExtreme

69  * @defgroup groupnorm

70  * @defgroup cat

71  * @defgroup SGD

72  *

73  */

74 

76 #define MIOPEN_DECLARE_OBJECT(name) \

77  struct name \

78  { \

79  }; \

80  typedef struct name* name##_t;

81 

82 #ifdef __cplusplus

83 extern "C" {

84 #endif

85 

86 #if MIOPEN_BACKEND_OPENCL

87 typedef cl_command_queue miopenAcceleratorQueue_t;

88 #elif MIOPEN_BACKEND_HIP

89 typedef hipStream_t miopenAcceleratorQueue_t;

90 #endif

91 

95 MIOPEN_DECLARE_OBJECT(miopenHandle);

96 

105 typedef enum

106 {

107  miopenStatusSuccess = 0,

108  miopenStatusNotInitialized = 1,

109  miopenStatusInvalidValue = 2,

110  miopenStatusBadParm = 3,

111  miopenStatusAllocFailed = 4,

112  miopenStatusInternalError = 5,

113  miopenStatusNotImplemented = 6,

114  miopenStatusUnknownError = 7,

115  miopenStatusUnsupportedOp = 8,

116  miopenStatusGpuOperationsSkipped = 9,

117  miopenStatusVersionMismatch = 10,

118 } miopenStatus_t;

119 

120 #ifdef MIOPEN_BETA_API

121 typedef enum

122 {

123  miopenF8RoundingModeStandard = 0,

124  miopenF8RoundingModeStochastic = 1,

125 } miopenF8RoundingMode_t;

126 #endif

127 

135 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);

136 

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

146 

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

156 

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

171 

180 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);

181 

193 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,

194  miopenAcceleratorQueue_t stream);

195 

202 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);

203 

211 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,

212  miopenAcceleratorQueue_t streamID);

213 

221 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,

222  miopenAcceleratorQueue_t* streamID);

223 

240 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,

241  miopenAllocatorFunction allocator,

242  miopenDeallocatorFunction deallocator,

243  void* allocatorContext);

244 

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

257 

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

267 // CLOSEOUT HANDLE DOXYGEN GROUP

268 

276 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);

277 

285 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);

286 

293 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);

294 

302 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);

303 

311 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);

312 

320 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);

321 

328 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);

329 

333 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);

334 

338 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);

339 

343 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);

344 

348 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);

349 

353 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);

354 

358 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);

359 

364 typedef enum

365 {

366  miopenHalf = 0,

367  miopenFloat = 1,

368  miopenInt32 = 2,

369  miopenInt8 = 3,

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

371  miopenBFloat16 = 5,

373  miopenDouble = 6,

374 #ifdef MIOPEN_BETA_API

375  miopenFloat8 = 7,

376  miopenBFloat8 = 8,

377 #else

378 // miopenReserved1 = 7,

379 // miopenReserved2 = 8,

380 #endif

381  miopenInt64 = 9,

382 } miopenDataType_t;

383 

389 typedef enum

390 {

391  miopenTensorNCHW = 0,

392  miopenTensorNHWC = 1,

393  miopenTensorCHWN = 2,

394  miopenTensorNCHWc4 = 3,

395  miopenTensorNCHWc8 = 4,

396  miopenTensorCHWNc4 = 5,

397  miopenTensorCHWNc8 = 6,

398  miopenTensorNCDHW = 7,

399  miopenTensorNDHWC = 8,

400 } miopenTensorLayout_t;

401 

406 typedef enum

407 {

408  miopenIndexUint8 = 0,

409  miopenIndexUint16 = 1,

410  miopenIndexUint32 = 2,

411  miopenIndexUint64 = 3,

412 } miopenIndexType_t;

413 

418 typedef enum

419 {

420  miopenTensorOpAdd = 0,

421  miopenTensorOpMul = 1,

422  miopenTensorOpMin = 2,

423  miopenTensorOpMax = 3,

424 } miopenTensorOp_t;

425 

430 typedef enum

431 {

432  miopenConvolution = 0,

433  miopenTranspose = 1,

434  miopenGroupConv = 2,

435  miopenDepthwise = 3,

436 } miopenConvolutionMode_t;

437 

442 typedef enum

443 {

444  miopenPaddingDefault = 0,

445  miopenPaddingSame = 1,

446  miopenPaddingValid = 2,

447 } miopenPaddingMode_t;

448 

453 typedef enum

454 {

455  miopenPoolingMax = 0,

456  miopenPoolingAverage = 1,

457  miopenPoolingAverageInclusive = 2,

458 } miopenPoolingMode_t;

459 

466 typedef enum

467 {

468  miopenPoolingWorkspaceIndexMask = 0,

469  miopenPoolingWorkspaceIndexImage = 1,

470 } miopenPoolingWorkspaceIndexMode_t;

471 

476 typedef enum

477 {

478  miopenLRNWithinChannel = 0,

479  miopenLRNCrossChannel = 1,

480 } miopenLRNMode_t;

481 #ifdef MIOPEN_BETA_API

486 typedef enum

487 {

488  MIOPEN_ELEMENTWISE_AFFINE = 0,

489  MIOPEN_WEIGHT_BIAS =

490  1,

491  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =

492  2,

493  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,

495  MIOPEN_ELEMENTWISE_AFFINE_T5 =

496  4,

497  MIOPEN_WEIGHT_BIAS_T5 = 5,

499 } miopenNormMode_t;

500 #endif

505 typedef enum

506 {

507  miopenBNPerActivation = 0,

508  miopenBNSpatial = 1,

509 } miopenBatchNormMode_t;

510 

515 typedef enum

516 {

517  miopenActivationPASTHRU = 0,

518  miopenActivationLOGISTIC = 1,

519  miopenActivationTANH = 2,

520  miopenActivationRELU = 3,

521  miopenActivationSOFTRELU = 4,

522  miopenActivationABS = 5,

523  miopenActivationPOWER = 6,

524  miopenActivationCLIPPEDRELU =

525  7,

526  miopenActivationLEAKYRELU =

527  8,

528  miopenActivationELU =

529  9,

531 } miopenActivationMode_t;

532 

537 typedef enum

538 {

539  MIOPEN_SOFTMAX_FAST = 0,

540  MIOPEN_SOFTMAX_ACCURATE = 1,

541  MIOPEN_SOFTMAX_LOG = 2,

542 } miopenSoftmaxAlgorithm_t;

543 

548 typedef enum

549 {

550  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,

551  MIOPEN_SOFTMAX_MODE_CHANNEL =

552  1,

553 } miopenSoftmaxMode_t;

554 

562 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1

563 

568 typedef enum

569 {

570  MIOPEN_REDUCE_TENSOR_ADD = 0,

571  MIOPEN_REDUCE_TENSOR_MUL =

572  1,

573  MIOPEN_REDUCE_TENSOR_MIN =

574  2,

575  MIOPEN_REDUCE_TENSOR_MAX =

576  3,

577  MIOPEN_REDUCE_TENSOR_AMAX =

578  4,

579  MIOPEN_REDUCE_TENSOR_AVG =

580  5,

581  MIOPEN_REDUCE_TENSOR_NORM1 =

582  6,

583  MIOPEN_REDUCE_TENSOR_NORM2 = 7,

585  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =

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

587 } miopenReduceTensorOp_t;

588 

593 typedef enum

594 {

595  MIOPEN_NOT_PROPAGATE_NAN = 0,

596  MIOPEN_PROPAGATE_NAN = 1,

597 } miopenNanPropagation_t;

598 

603 typedef enum

604 {

605  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,

606  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,

607 } miopenReduceTensorIndices_t;

608 

613 typedef enum

614 {

615  MIOPEN_32BIT_INDICES = 0,

616  MIOPEN_64BIT_INDICES = 1,

617  MIOPEN_16BIT_INDICES = 2,

618  MIOPEN_8BIT_INDICES = 3,

619 } miopenIndicesType_t;

620 

625 typedef enum

626 {

627  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =

628  0,

631  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =

632  1,

634 #ifdef MIOPEN_BETA_API

635  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =

636  2,

640 #else

641 // miopenReserved1 = 2,

642 #endif

643 } miopenConvolutionAttrib_t;

644 

656 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);

657 

670 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(

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

672 

683 MIOPEN_EXPORT miopenStatus_t

684 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,

685  miopenDataType_t dataType,

686  miopenTensorLayout_t tensorLayout,

687  const int* lens,

688  int num_lens);

708 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,

709  miopenDataType_t dataType,

710  int n,

711  int c,

712  int h,

713  int w,

714  int nStride,

715  int cStride,

716  int hStride,

717  int wStride);

718 

735 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

736  miopenDataType_t* dataType,

737  int* n,

738  int* c,

739  int* h,

740  int* w,

741  int* nStride,

742  int* cStride,

743  int* hStride,

744  int* wStride);

745 

756 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

757  miopenDataType_t dataType,

758  int nbDims,

759  const int* dimsA,

760  const int* stridesA);

761 

762 #ifdef MIOPEN_BETA_API

765 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,

766  miopenDataType_t dataType,

767  int nbDims,

768  const size_t* dimsA,

769  const size_t* stridesA);

770 #endif

771 

772 #ifdef MIOPEN_BETA_API

782 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,

783  miopenDataType_t cast_type);

784 #endif

785 

794 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,

795  int* size);

796 

805 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

806  miopenDataType_t* dataType,

807  int* dimsA,

808  int* stridesA);

809 

815 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);

816 

823 MIOPEN_EXPORT miopenStatus_t

824 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);

825 

831 MIOPEN_EXPORT miopenStatus_t

832 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);

833 

853 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,

854  miopenTensorOp_t tensorOp,

855  const void* alpha1,

856  const miopenTensorDescriptor_t aDesc,

857  const void* A,

858  const void* alpha2,

859  const miopenTensorDescriptor_t bDesc,

860  const void* B,

861  const void* beta,

862  const miopenTensorDescriptor_t cDesc,

863  void* C);

864 

875 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,

876  const miopenTensorDescriptor_t yDesc,

877  void* y,

878  const void* alpha);

879 

890 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,

891  const miopenTensorDescriptor_t yDesc,

892  void* y,

893  const void* alpha);

894 

901 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,

902  size_t* numBytes);

903 

921 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,

922  const void* alpha,

923  const miopenTensorDescriptor_t xDesc,

924  const void* x,

925  const void* beta,

926  const miopenTensorDescriptor_t yDesc,

927  void* y);

928 

930 // CLOSEOUT TENSOR DOXYGEN GROUP

931 

942 MIOPEN_EXPORT miopenStatus_t

943 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);

944 

960 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

961  miopenConvolutionMode_t c_mode,

962  int pad_h,

963  int pad_w,

964  int stride_h,

965  int stride_w,

966  int dilation_h,

967  int dilation_w);

968 

979 MIOPEN_EXPORT miopenStatus_t

980 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

981  int spatialDim,

982  const int* padA,

983  const int* strideA,

984  const int* dilationA,

985  miopenConvolutionMode_t c_mode);

986 

993 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,

994  int* spatialDim);

995 

1011 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

1012  miopenConvolutionMode_t* c_mode,

1013  int* pad_h,

1014  int* pad_w,

1015  int* stride_h,

1016  int* stride_w,

1017  int* dilation_h,

1018  int* dilation_w);

1019 

1031 MIOPEN_EXPORT miopenStatus_t

1032 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1033  int requestedSpatialDim,

1034  int* spatialDim,

1035  int* padA,

1036  int* strideA,

1037  int* dilationA,

1038  miopenConvolutionMode_t* c_mode);

1039 

1046 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1047  int* groupCount);

1048 

1062 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1063  int groupCount);

1064 

1077 MIOPEN_EXPORT miopenStatus_t

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

1079 

1092 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(

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

1094 

1112 MIOPEN_EXPORT miopenStatus_t

1113 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1114  const miopenTensorDescriptor_t inputTensorDesc,

1115  const miopenTensorDescriptor_t filterDesc,

1116  int* n,

1117  int* c,

1118  int* h,

1119  int* w);

1120 

1134 MIOPEN_EXPORT miopenStatus_t

1135 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1136  const miopenTensorDescriptor_t inputTensorDesc,

1137  const miopenTensorDescriptor_t filterDesc,

1138  int* nDim,

1139  int* outputTensorDimA);

1140 

1146 MIOPEN_EXPORT miopenStatus_t

1147 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);

1148 

1155 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1156  const miopenConvolutionAttrib_t attr,

1157  int value);

1158 

1165 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1166  const miopenConvolutionAttrib_t attr,

1167  int* value);

1168 

1173 typedef enum

1174 {

1175  miopenConvolutionFwdAlgoGEMM = 0,

1176  miopenConvolutionFwdAlgoDirect = 1,

1177  miopenConvolutionFwdAlgoFFT = 2,

1178  miopenConvolutionFwdAlgoWinograd = 3,

1179  miopenConvolutionFwdAlgoImplicitGEMM = 5,

1180 } miopenConvFwdAlgorithm_t;

1181 

1185 typedef enum

1186 {

1187  miopenConvolutionBwdWeightsAlgoGEMM = 0,

1188  miopenConvolutionBwdWeightsAlgoDirect = 1,

1189  miopenConvolutionBwdWeightsAlgoWinograd = 3,

1190  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,

1191 } miopenConvBwdWeightsAlgorithm_t;

1192 

1196 typedef enum

1197 {

1198  miopenConvolutionBwdDataAlgoGEMM = 0,

1199  miopenConvolutionBwdDataAlgoDirect = 1,

1200  miopenConvolutionBwdDataAlgoFFT = 2,

1201  miopenConvolutionBwdDataAlgoWinograd = 3,

1202  miopenTransposeBwdDataAlgoGEMM =

1203  4,

1204  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,

1205 } miopenConvBwdDataAlgorithm_t;

1206 

1210 typedef enum

1211 {

1212  miopenConvolutionAlgoGEMM = 0,

1213  miopenConvolutionAlgoDirect = 1,

1214  miopenConvolutionAlgoFFT = 2,

1215  miopenConvolutionAlgoWinograd = 3,

1216  miopenConvolutionAlgoImplicitGEMM = 5,

1217 } miopenConvAlgorithm_t;

1218 

1225 typedef struct

1226 {

1227  union

1228  {

1229  miopenConvFwdAlgorithm_t fwd_algo;

1230  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;

1232  miopenConvBwdDataAlgorithm_t

1233  bwd_data_algo;

1234  };

1235 

1236  float time;

1237  size_t memory;

1239 } miopenConvAlgoPerf_t;

1240 

1249 typedef struct

1250 {

1251  float time;

1254  size_t workspace_size;

1256  uint64_t solution_id;

1257  miopenConvAlgorithm_t algorithm;

1259 } miopenConvSolution_t;

1260 

1276 MIOPEN_EXPORT miopenStatus_t

1277 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,

1278  const miopenTensorDescriptor_t wDesc,

1279  const miopenTensorDescriptor_t xDesc,

1280  const miopenConvolutionDescriptor_t convDesc,

1281  const miopenTensorDescriptor_t yDesc,

1282  size_t* solutionCount);

1283 

1307 MIOPEN_EXPORT miopenStatus_t

1308 miopenConvolutionForwardGetSolution(miopenHandle_t handle,

1309  const miopenTensorDescriptor_t wDesc,

1310  const miopenTensorDescriptor_t xDesc,

1311  const miopenConvolutionDescriptor_t convDesc,

1312  const miopenTensorDescriptor_t yDesc,

1313  const size_t maxSolutionCount,

1314  size_t* solutionCount,

1315  miopenConvSolution_t* solutions);

1316 

1334 MIOPEN_EXPORT miopenStatus_t

1335 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,

1336  const miopenTensorDescriptor_t wDesc,

1337  const miopenTensorDescriptor_t xDesc,

1338  const miopenConvolutionDescriptor_t convDesc,

1339  const miopenTensorDescriptor_t yDesc,

1340  const uint64_t solution_id,

1341  size_t* workSpaceSize);

1342 

1360 MIOPEN_EXPORT miopenStatus_t

1361 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,

1362  const miopenTensorDescriptor_t wDesc,

1363  const miopenTensorDescriptor_t xDesc,

1364  const miopenConvolutionDescriptor_t convDesc,

1365  const miopenTensorDescriptor_t yDesc,

1366  const uint64_t solution_id);

1367 

1385 MIOPEN_EXPORT miopenStatus_t

1386 miopenConvolutionForwardImmediate(miopenHandle_t handle,

1387  const miopenTensorDescriptor_t wDesc,

1388  const void* w,

1389  const miopenTensorDescriptor_t xDesc,

1390  const void* x,

1391  const miopenConvolutionDescriptor_t convDesc,

1392  const miopenTensorDescriptor_t yDesc,

1393  void* y,

1394  void* workSpace,

1395  size_t workSpaceSize,

1396  const uint64_t solution_id);

1397 

1415 MIOPEN_EXPORT miopenStatus_t

1416 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,

1417  const miopenTensorDescriptor_t dyDesc,

1418  const miopenTensorDescriptor_t wDesc,

1419  const miopenConvolutionDescriptor_t convDesc,

1420  const miopenTensorDescriptor_t dxDesc,

1421  size_t* solutionCount);

1422 

1447 MIOPEN_EXPORT miopenStatus_t

1448 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,

1449  const miopenTensorDescriptor_t dyDesc,

1450  const miopenTensorDescriptor_t wDesc,

1451  const miopenConvolutionDescriptor_t convDesc,

1452  const miopenTensorDescriptor_t dxDesc,

1453  const size_t maxSolutionCount,

1454  size_t* solutionCount,

1455  miopenConvSolution_t* solutions);

1456 

1474 MIOPEN_EXPORT miopenStatus_t

1475 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,

1476  const miopenTensorDescriptor_t dyDesc,

1477  const miopenTensorDescriptor_t wDesc,

1478  const miopenConvolutionDescriptor_t convDesc,

1479  const miopenTensorDescriptor_t dxDesc,

1480  const uint64_t solution_id,

1481  size_t* workSpaceSize);

1482 

1501 MIOPEN_EXPORT miopenStatus_t

1502 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,

1503  const miopenTensorDescriptor_t dyDesc,

1504  const miopenTensorDescriptor_t wDesc,

1505  const miopenConvolutionDescriptor_t convDesc,

1506  const miopenTensorDescriptor_t dxDesc,

1507  const uint64_t solution_id);

1508 

1526 MIOPEN_EXPORT miopenStatus_t

1527 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,

1528  const miopenTensorDescriptor_t dyDesc,

1529  const void* dy,

1530  const miopenTensorDescriptor_t wDesc,

1531  const void* w,

1532  const miopenConvolutionDescriptor_t convDesc,

1533  const miopenTensorDescriptor_t dxDesc,

1534  void* dx,

1535  void* workSpace,

1536  size_t workSpaceSize,

1537  const uint64_t solution_id);

1538 

1556 MIOPEN_EXPORT miopenStatus_t

1557 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,

1558  const miopenTensorDescriptor_t dyDesc,

1559  const miopenTensorDescriptor_t xDesc,

1560  const miopenConvolutionDescriptor_t convDesc,

1561  const miopenTensorDescriptor_t dwDesc,

1562  size_t* solutionCount);

1563 

1587 MIOPEN_EXPORT miopenStatus_t

1588 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,

1589  const miopenTensorDescriptor_t dyDesc,

1590  const miopenTensorDescriptor_t xDesc,

1591  const miopenConvolutionDescriptor_t convDesc,

1592  const miopenTensorDescriptor_t dwDesc,

1593  const size_t maxSolutionCount,

1594  size_t* solutionCount,

1595  miopenConvSolution_t* solutions);

1596 

1614 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(

1615  miopenHandle_t handle,

1616  const miopenTensorDescriptor_t dyDesc,

1617  const miopenTensorDescriptor_t xDesc,

1618  const miopenConvolutionDescriptor_t convDesc,

1619  const miopenTensorDescriptor_t dwDesc,

1620  const uint64_t solution_id,

1621  size_t* workSpaceSize);

1622 

1640 MIOPEN_EXPORT miopenStatus_t

1641 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,

1642  const miopenTensorDescriptor_t dyDesc,

1643  const miopenTensorDescriptor_t xDesc,

1644  const miopenConvolutionDescriptor_t convDesc,

1645  const miopenTensorDescriptor_t dwDesc,

1646  const uint64_t solution_id);

1647 

1666 MIOPEN_EXPORT miopenStatus_t

1667 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,

1668  const miopenTensorDescriptor_t dyDesc,

1669  const void* dy,

1670  const miopenTensorDescriptor_t xDesc,

1671  const void* x,

1672  const miopenConvolutionDescriptor_t convDesc,

1673  const miopenTensorDescriptor_t dwDesc,

1674  void* dw,

1675  void* workSpace,

1676  size_t workSpaceSize,

1677  const uint64_t solution_id);

1678 

1705 MIOPEN_EXPORT miopenStatus_t

1706 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,

1707  const miopenTensorDescriptor_t wDesc,

1708  const miopenTensorDescriptor_t xDesc,

1709  const miopenConvolutionDescriptor_t convDesc,

1710  const miopenTensorDescriptor_t yDesc,

1711  size_t* workSpaceSize);

1712 

1756 MIOPEN_EXPORT miopenStatus_t

1757 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,

1758  const miopenTensorDescriptor_t xDesc,

1759  const void* x,

1760  const miopenTensorDescriptor_t wDesc,

1761  const void* w,

1762  const miopenConvolutionDescriptor_t convDesc,

1763  const miopenTensorDescriptor_t yDesc,

1764  void* y,

1765  const int requestAlgoCount,

1766  int* returnedAlgoCount,

1767  miopenConvAlgoPerf_t* perfResults,

1768  void* workSpace,

1769  size_t workSpaceSize,

1770  bool exhaustiveSearch);

1771 

1806 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,

1807  const void* alpha,

1808  const miopenTensorDescriptor_t xDesc,

1809  const void* x,

1810  const miopenTensorDescriptor_t wDesc,

1811  const void* w,

1812  const miopenConvolutionDescriptor_t convDesc,

1813  miopenConvFwdAlgorithm_t algo,

1814  const void* beta,

1815  const miopenTensorDescriptor_t yDesc,

1816  void* y,

1817  void* workSpace,

1818  size_t workSpaceSize);

1819 

1835 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,

1836  const void* alpha,

1837  const miopenTensorDescriptor_t bDesc,

1838  const void* b,

1839  const void* beta,

1840  const miopenTensorDescriptor_t yDesc,

1841  void* y);

1842 

1870 MIOPEN_EXPORT miopenStatus_t

1871 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,

1872  const miopenTensorDescriptor_t dyDesc,

1873  const miopenTensorDescriptor_t wDesc,

1874  const miopenConvolutionDescriptor_t convDesc,

1875  const miopenTensorDescriptor_t dxDesc,

1876  size_t* workSpaceSize);

1877 

1921 MIOPEN_EXPORT miopenStatus_t

1922 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,

1923  const miopenTensorDescriptor_t dyDesc,

1924  const void* dy,

1925  const miopenTensorDescriptor_t wDesc,

1926  const void* w,

1927  const miopenConvolutionDescriptor_t convDesc,

1928  const miopenTensorDescriptor_t dxDesc,

1929  void* dx,

1930  const int requestAlgoCount,

1931  int* returnedAlgoCount,

1932  miopenConvAlgoPerf_t* perfResults,

1933  void* workSpace,

1934  size_t workSpaceSize,

1935  bool exhaustiveSearch);

1936 

1970 MIOPEN_EXPORT miopenStatus_t

1971 miopenConvolutionBackwardData(miopenHandle_t handle,

1972  const void* alpha,

1973  const miopenTensorDescriptor_t dyDesc,

1974  const void* dy,

1975  const miopenTensorDescriptor_t wDesc,

1976  const void* w,

1977  const miopenConvolutionDescriptor_t convDesc,

1978  miopenConvBwdDataAlgorithm_t algo,

1979  const void* beta,

1980  const miopenTensorDescriptor_t dxDesc,

1981  void* dx,

1982  void* workSpace,

1983  size_t workSpaceSize);

1984 

2012 MIOPEN_EXPORT miopenStatus_t

2013 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,

2014  const miopenTensorDescriptor_t dyDesc,

2015  const miopenTensorDescriptor_t xDesc,

2016  const miopenConvolutionDescriptor_t convDesc,

2017  const miopenTensorDescriptor_t dwDesc,

2018  size_t* workSpaceSize);

2019 

2063 MIOPEN_EXPORT miopenStatus_t

2064 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,

2065  const miopenTensorDescriptor_t dyDesc,

2066  const void* dy,

2067  const miopenTensorDescriptor_t xDesc,

2068  const void* x,

2069  const miopenConvolutionDescriptor_t convDesc,

2070  const miopenTensorDescriptor_t dwDesc,

2071  void* dw,

2072  const int requestAlgoCount,

2073  int* returnedAlgoCount,

2074  miopenConvAlgoPerf_t* perfResults,

2075  void* workSpace,

2076  size_t workSpaceSize,

2077  bool exhaustiveSearch);

2078 

2112 MIOPEN_EXPORT miopenStatus_t

2113 miopenConvolutionBackwardWeights(miopenHandle_t handle,

2114  const void* alpha,

2115  const miopenTensorDescriptor_t dyDesc,

2116  const void* dy,

2117  const miopenTensorDescriptor_t xDesc,

2118  const void* x,

2119  const miopenConvolutionDescriptor_t convDesc,

2120  miopenConvBwdWeightsAlgorithm_t algo,

2121  const void* beta,

2122  const miopenTensorDescriptor_t dwDesc,

2123  void* dw,

2124  void* workSpace,

2125  size_t workSpaceSize);

2126 

2142 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,

2143  const void* alpha,

2144  const miopenTensorDescriptor_t dyDesc,

2145  const void* dy,

2146  const void* beta,

2147  const miopenTensorDescriptor_t dbDesc,

2148  void* db);

2149 

2151 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP

2152 

2153 // Pooling APIs

2164 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);

2165 

2174 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2175  miopenIndexType_t index_type);

2176 

2184 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2185  miopenIndexType_t* index_type);

2186 

2194 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(

2195  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);

2196 

2203 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(

2204  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);

2205 

2220 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2221  miopenPoolingMode_t mode,

2222  int windowHeight,

2223  int windowWidth,

2224  int pad_h,

2225  int pad_w,

2226  int stride_h,

2227  int stride_w);

2228 

2243 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2244  miopenPoolingMode_t* mode,

2245  int* windowHeight,

2246  int* windowWidth,

2247  int* pad_h,

2248  int* pad_w,

2249  int* stride_h,

2250  int* stride_w);

2251 

2266 MIOPEN_EXPORT miopenStatus_t

2267 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2268  const miopenTensorDescriptor_t tensorDesc,

2269  int* n,

2270  int* c,

2271  int* h,

2272  int* w);

2273 

2289 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2290  const miopenPoolingMode_t mode,

2291  int nbDims,

2292  const int* windowDimA,

2293  const int* padA,

2294  const int* stridesA);

2295 

2312 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2313  int nbDimsRequested,

2314  miopenPoolingMode_t* mode,

2315  int* nbDims,

2316  int* windowDimA,

2317  int* padA,

2318  int* stridesA);

2319 

2332 MIOPEN_EXPORT miopenStatus_t

2333 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2334  const miopenTensorDescriptor_t tensorDesc,

2335  int dims,

2336  int* tensorDimArr);

2337 

2350 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2351  size_t* workSpaceSize);

2352 

2365 MIOPEN_EXPORT miopenStatus_t

2366 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,

2367  const miopenTensorDescriptor_t yDesc,

2368  size_t* workSpaceSize);

2369 

2390 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,

2391  const miopenPoolingDescriptor_t poolDesc,

2392  const void* alpha,

2393  const miopenTensorDescriptor_t xDesc,

2394  const void* x,

2395  const void* beta,

2396  const miopenTensorDescriptor_t yDesc,

2397  void* y,

2398  bool do_backward,

2399  void* workSpace,

2400  size_t workSpaceSize);

2401 

2422 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,

2423  const miopenPoolingDescriptor_t poolDesc,

2424  const void* alpha,

2425  const miopenTensorDescriptor_t yDesc,

2426  const void* y,

2427  const miopenTensorDescriptor_t dyDesc,

2428  const void* dy,

2429  const miopenTensorDescriptor_t xDesc,

2430  const void* x,

2431  const void* beta,

2432  const miopenTensorDescriptor_t dxDesc,

2433  void* dx,

2434  void* workSpace);

2435 

2441 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);

2442 

2444 // CLOSEOUT POOLING DOXYGEN GROUP

2445 

2446 // LRN APIs

2456 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);

2457 

2471 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2472  miopenLRNMode_t mode,

2473  unsigned int lrnN,

2474  double lrnAlpha,

2475  double lrnBeta,

2476  double lrnK);

2477 

2490 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2491  miopenLRNMode_t* mode,

2492  unsigned int* lrnN,

2493  double* lrnAlpha,

2494  double* lrnBeta,

2495  double* lrnK);

2496 

2506 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2507  size_t* workSpaceSize);

2508 

2527 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,

2528  const miopenLRNDescriptor_t lrnDesc,

2529  const void* alpha,

2530  const miopenTensorDescriptor_t xDesc,

2531  const void* x,

2532  const void* beta,

2533  const miopenTensorDescriptor_t yDesc,

2534  void* y,

2535  bool do_backward,

2536  void* workSpace);

2537 

2555 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,

2556  const miopenLRNDescriptor_t lrnDesc,

2557  const void* alpha,

2558  const miopenTensorDescriptor_t yDesc,

2559  const void* y,

2560  const miopenTensorDescriptor_t dyDesc,

2561  const void* dy,

2562  const miopenTensorDescriptor_t xDesc,

2563  const void* x,

2564  const void* beta,

2565  const miopenTensorDescriptor_t dxDesc,

2566  void* dx,

2567  const void* workSpace);

2568 

2574 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);

2575 

2577 // CLOSEOUT LRN DOXYGEN GROUP

2578 

2579 #ifdef MIOPEN_BETA_API

2580 // LayerNorm APIs

2605 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,

2606  miopenNormMode_t mode,

2607  const miopenTensorDescriptor_t xDesc,

2608  const void* x,

2609  const miopenTensorDescriptor_t weightDesc,

2610  const void* weight,

2611  const miopenTensorDescriptor_t biasDesc,

2612  const void* bias,

2613  const float epsilon,

2614  const int32_t normalized_dim,

2615  const miopenTensorDescriptor_t yDesc,

2616  void* y,

2617  const miopenTensorDescriptor_t meanDesc,

2618  void* mean,

2619  const miopenTensorDescriptor_t rstdDesc,

2620  void* rstd);

2621 

2623 // CLOSEOUT LAYERNORM DOXYGEN GROUP

2624 #endif

2625 

2626 #ifdef MIOPEN_BETA_API

2627 // Cat APIs

2643 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,

2644  const int32_t xCount,

2645  const miopenTensorDescriptor_t* xDescs,

2646  const void* const* xs,

2647  const miopenTensorDescriptor_t yDesc,

2648  void* y,

2649  const int32_t dim);

2650 

2652 // CLOSEOUT CAT DOXYGEN GROUP

2653 #endif

2654 

2655 // Batch-Normalization APIs

2677 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,

2678  const miopenTensorDescriptor_t xDesc,

2679  miopenBatchNormMode_t bn_mode);

2680 

2719 MIOPEN_EXPORT miopenStatus_t

2720 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,

2721  miopenBatchNormMode_t bn_mode,

2722  void* alpha,

2723  void* beta,

2724  const miopenTensorDescriptor_t xDesc,

2725  const void* x,

2726  const miopenTensorDescriptor_t yDesc,

2727  void* y,

2728  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

2729  void* bnScale,

2730  void* bnBias,

2731  double expAvgFactor,

2732  void* resultRunningMean,

2733  void* resultRunningVariance,

2734  double epsilon,

2735  void* resultSaveMean,

2736  void* resultSaveInvVariance);

2737 

2767 MIOPEN_EXPORT miopenStatus_t

2768 miopenBatchNormalizationForwardInference(miopenHandle_t handle,

2769  miopenBatchNormMode_t bn_mode,

2770  void* alpha,

2771  void* beta,

2772  const miopenTensorDescriptor_t xDesc,

2773  const void* x,

2774  const miopenTensorDescriptor_t yDesc,

2775  void* y,

2776  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

2777  void* bnScale,

2778  void* bnBias,

2779  void* estimatedMean,

2780  void* estimatedVariance,

2781  double epsilon);

2782 

2817 MIOPEN_EXPORT miopenStatus_t

2818 miopenBatchNormalizationBackward(miopenHandle_t handle,

2819  miopenBatchNormMode_t bn_mode,

2820  const void* alphaDataDiff,

2821  const void* betaDataDiff,

2822  const void* alphaParamDiff,

2823  const void* betaParamDiff,

2824  const miopenTensorDescriptor_t xDesc,

2825  const void* x,

2826  const miopenTensorDescriptor_t dyDesc,

2827  const void* dy,

2828  const miopenTensorDescriptor_t dxDesc,

2829  void* dx,

2830  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,

2831  const void* bnScale,

2832  void* resultBnScaleDiff,

2833  void* resultBnBiasDiff,

2834  double epsilon,

2835  const void* savedMean,

2836  const void* savedInvVariance);

2837 

2839 // CLOSEOUT BATCHNORM DOXYGEN GROUP

2840 

2841 // Activation APIs

2851 MIOPEN_EXPORT miopenStatus_t

2852 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);

2853 

2865 MIOPEN_EXPORT miopenStatus_t

2866 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

2867  miopenActivationMode_t mode,

2868  double activAlpha,

2869  double activBeta,

2870  double activGamma);

2871 

2883 MIOPEN_EXPORT miopenStatus_t

2884 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

2885  miopenActivationMode_t* mode,

2886  double* activAlpha,

2887  double* activBeta,

2888  double* activGamma);

2889 

2902 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,

2903  const miopenActivationDescriptor_t activDesc,

2904  const void* alpha,

2905  const miopenTensorDescriptor_t xDesc,

2906  const void* x,

2907  const void* beta,

2908  const miopenTensorDescriptor_t yDesc,

2909  void* y);

2910 

2927 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,

2928  const miopenActivationDescriptor_t activDesc,

2929  const void* alpha,

2930  const miopenTensorDescriptor_t yDesc,

2931  const void* y,

2932  const miopenTensorDescriptor_t dyDesc,

2933  const void* dy,

2934  const miopenTensorDescriptor_t xDesc,

2935  const void* x,

2936  const void* beta,

2937  const miopenTensorDescriptor_t dxDesc,

2938  void* dx);

2939 

2945 MIOPEN_EXPORT miopenStatus_t

2946 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);

2947 

2949 // CLOSEOUT ACTIVATION DOXYGEN GROUP

2950 

2951 // Softmax APIs

2969 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,

2970  const void* alpha,

2971  const miopenTensorDescriptor_t xDesc,

2972  const void* x,

2973  const void* beta,

2974  const miopenTensorDescriptor_t yDesc,

2975  void* y);

2976 

2992 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,

2993  const void* alpha,

2994  const miopenTensorDescriptor_t yDesc,

2995  const void* y,

2996  const miopenTensorDescriptor_t dyDesc,

2997  const void* dy,

2998  const void* beta,

2999  const miopenTensorDescriptor_t dxDesc,

3000  void* dx);

3001 

3015 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,

3016  const void* alpha,

3017  const miopenTensorDescriptor_t xDesc,

3018  const void* x,

3019  const void* beta,

3020  const miopenTensorDescriptor_t yDesc,

3021  void* y,

3022  miopenSoftmaxAlgorithm_t algorithm,

3023  miopenSoftmaxMode_t mode);

3024 

3040 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,

3041  const void* alpha,

3042  const miopenTensorDescriptor_t yDesc,

3043  const void* y,

3044  const miopenTensorDescriptor_t dyDesc,

3045  const void* dy,

3046  const void* beta,

3047  const miopenTensorDescriptor_t dxDesc,

3048  void* dx,

3049  miopenSoftmaxAlgorithm_t algorithm,

3050  miopenSoftmaxMode_t mode);

3051 

3053 // CLOSEOUT SOFTMAX DOXYGEN GROUP

3054 

3058 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);

3059 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);

3060 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);

3061 

3070 typedef enum

3071 {

3072  miopenVerticalFusion = 0,

3073  miopenHorizontalFusion = 1,

3074 } miopenFusionDirection_t;

3075 

3083 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,

3084  const miopenFusionDirection_t fuseDirection,

3085  const miopenTensorDescriptor_t inputDesc);

3086 

3092 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);

3093 

3100 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,

3101  miopenFusionPlanDescriptor_t fusePlanDesc);

3102 

3113 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,

3114  const int op_idx,

3115  miopenFusionOpDescriptor_t* op);

3116 

3124 MIOPEN_EXPORT miopenStatus_t

3125 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,

3126  miopenFusionPlanDescriptor_t fusePlanDesc,

3127  size_t* workSpaceSize,

3128  miopenConvFwdAlgorithm_t algo);

3129 

3147 MIOPEN_EXPORT miopenStatus_t

3148 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,

3149  const int requestAlgoCount,

3150  int* returnedAlgoCount,

3151  miopenConvFwdAlgorithm_t* returnedAlgos);

3152 

3162 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(

3163  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);

3164 

3173 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3174  miopenFusionOpDescriptor_t* convOp,

3175  miopenConvolutionDescriptor_t convDesc,

3176  const miopenTensorDescriptor_t wDesc);

3177 

3178 //---

3179 

3180 // Activation forward create ops ---

3188 MIOPEN_EXPORT miopenStatus_t

3189 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3190  miopenFusionOpDescriptor_t* activFwdOp,

3191  miopenActivationMode_t mode);

3192 

3193 // Activation backward create ops ---

3201 MIOPEN_EXPORT miopenStatus_t

3202 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3203  miopenFusionOpDescriptor_t* activBwdOp,

3204  miopenActivationMode_t mode);

3205 

3206 // Bias create ops ---

3214 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3215  miopenFusionOpDescriptor_t* biasOp,

3216  const miopenTensorDescriptor_t bDesc);

3217 

3218 // Batch normalization create ops ---

3227 MIOPEN_EXPORT miopenStatus_t

3228 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,

3229  miopenFusionOpDescriptor_t* bnOp,

3230  const miopenBatchNormMode_t bn_mode,

3231  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);

3232 

3242 MIOPEN_EXPORT miopenStatus_t

3243 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3244  miopenFusionOpDescriptor_t* bnFwdOp,

3245  const miopenBatchNormMode_t bn_mode,

3246  bool runningMeanVariance);

3247 

3255 MIOPEN_EXPORT miopenStatus_t

3256 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3257  miopenFusionOpDescriptor_t* bnBwdOp,

3258  const miopenBatchNormMode_t bn_mode);

3259 

3260 //---

3266 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);

3267 

3273 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);

3274 

3275 // Convolution set arguments ---

3285 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,

3286  const miopenFusionOpDescriptor_t convOp,

3287  const void* alpha,

3288  const void* beta,

3289  const void* w);

3290 // Activation set arguments ---

3302 MIOPEN_EXPORT miopenStatus_t

3303 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,

3304  const miopenFusionOpDescriptor_t activFwdOp,

3305  const void* alpha,

3306  const void* beta,

3307  double activAlpha,

3308  double activBeta,

3309  double activGamma);

3310 

3324 MIOPEN_EXPORT miopenStatus_t

3325 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,

3326  const miopenFusionOpDescriptor_t activBwdOp,

3327  const void* alpha,

3328  const void* beta,

3329  const void* y,

3330  const void* reserved,

3331  double activAlpha,

3332  double activBeta,

3333  double activGamma);

3334 

3335 // Batch Normalization set arguments ---

3349 MIOPEN_EXPORT miopenStatus_t

3350 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,

3351  const miopenFusionOpDescriptor_t bnOp,

3352  const void* alpha,

3353  const void* beta,

3354  const void* bnScale,

3355  const void* bnBias,

3356  const void* estimatedMean,

3357  const void* estimatedVariance,

3358  double epsilon);

3359 

3376 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,

3377  const miopenFusionOpDescriptor_t bnOp,

3378  const void* alpha,

3379  const void* beta,

3380  const void* bnScale,

3381  const void* bnBias,

3382  void* savedMean,

3383  void* savedInvVariance,

3384  void* runningMean,

3385  void* runningVariance,

3386  double expAvgFactor,

3387  double epsilon);

3388 

3404 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,

3405  const miopenFusionOpDescriptor_t bnOp,

3406  const void* alpha,

3407  const void* beta,

3408  const void* x,

3409  const void* bnScale,

3410  const void* bnBias,

3411  void* resultBnScaleDiff,

3412  void* resultBnBiasDiff,

3413  const void* savedMean,

3414  const void* savedInvVariance);

3415 

3416 // Bias forward set arguments ---

3426 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,

3427  const miopenFusionOpDescriptor_t biasOp,

3428  const void* alpha,

3429  const void* beta,

3430  const void* bias);

3443 MIOPEN_EXPORT miopenStatus_t

3444 miopenExecuteFusionPlan(const miopenHandle_t handle,

3445  const miopenFusionPlanDescriptor_t fusePlanDesc,

3446  const miopenTensorDescriptor_t inputDesc,

3447  const void* input,

3448  const miopenTensorDescriptor_t outputDesc,

3449  void* output,

3450  miopenOperatorArgs_t args);

3451 

3475 MIOPEN_EXPORT miopenStatus_t

3476 miopenConvolutionBiasActivationForward(miopenHandle_t handle,

3477  const void* alpha1,

3478  const miopenTensorDescriptor_t xDesc,

3479  const void* x,

3480  const miopenTensorDescriptor_t wDesc,

3481  const void* w,

3482  const miopenConvolutionDescriptor_t convDesc,

3483  miopenConvFwdAlgorithm_t algo,

3484  void* workspace,

3485  size_t workspaceSizeInBytes,

3486  const void* alpha2,

3487  const miopenTensorDescriptor_t zDesc,

3488  const void* z,

3489  const miopenTensorDescriptor_t biasDesc,

3490  const void* bias,

3491  const miopenActivationDescriptor_t activationDesc,

3492  const miopenTensorDescriptor_t yDesc,

3493  void* y);

3495 // CLOSEOUT FUSION DOXYGEN GROUP

3496 

3505 typedef enum

3506 {

3507  miopenRNNRELU = 0,

3508  miopenRNNTANH = 1,

3509  miopenLSTM = 2,

3510  miopenGRU = 3,

3511 } miopenRNNMode_t;

3512 

3516 typedef enum

3517 {

3518  miopenRNNlinear = 0,

3519  miopenRNNskip = 1,

3520 } miopenRNNInputMode_t;

3521 

3525 typedef enum

3526 {

3527  miopenRNNdefault = 0,

3529  miopenRNNfundamental =

3530  1,

3531 } miopenRNNAlgo_t;

3532 

3536 typedef enum

3537 {

3538  miopenRNNunidirection = 0,

3539  miopenRNNbidirection = 1,

3540 } miopenRNNDirectionMode_t;

3541 

3545 typedef enum

3546 {

3547  miopenRNNNoBias = 0,

3548  miopenRNNwithBias = 1,

3549 } miopenRNNBiasMode_t;

3550 

3554 typedef enum

3555 {

3556  miopenRNNAlgoGEMM = 0,

3557 } miopenRNNGEMMalgoMode_t;

3558 

3562 typedef enum

3563 {

3564  miopenRNNIONotPadded = 0,

3565  miopenRNNIOWithPadding = 1,

3566 } miopenRNNPaddingMode_t;

3567 

3571 typedef enum

3572 {

3573  miopenRNNTraining = 0,

3574  miopenRNNInference = 1,

3575 } miopenRNNFWDMode_t;

3576 

3580 typedef enum

3581 {

3582  miopenRNNDataUnknownLayout = 0,

3583  miopenRNNDataSeqMajorNotPadded = 1,

3584  miopenRNNDataSeqMajorPadded = 2,

3585  miopenRNNDataBatchMajorPadded = 3,

3586 } miopenRNNBaseLayout_t;

3587 

3594 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);

3595 

3608 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

3609  miopenRNNMode_t* rnnMode,

3610  miopenRNNAlgo_t* algoMode,

3611  miopenRNNInputMode_t* inputMode,

3612  miopenRNNDirectionMode_t* dirMode,

3613  miopenRNNBiasMode_t* biasMode,

3614  int* hiddenSize,

3615  int* layer);

3616 

3633 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

3634  int* hiddenSize,

3635  int* layer,

3636  miopenDropoutDescriptor_t* dropoutDesc,

3637  miopenRNNInputMode_t* inputMode,

3638  miopenRNNDirectionMode_t* dirMode,

3639  miopenRNNMode_t* rnnMode,

3640  miopenRNNBiasMode_t* biasMode,

3641  miopenRNNAlgo_t* algoMode,

3642  miopenDataType_t* dataType);

3643 

3649 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);

3650 

3666 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

3667  const int hsize,

3668  const int nlayers,

3669  miopenRNNInputMode_t inMode,

3670  miopenRNNDirectionMode_t direction,

3671  miopenRNNMode_t rnnMode,

3672  miopenRNNBiasMode_t biasMode,

3673  miopenRNNAlgo_t algo,

3674  miopenDataType_t dataType);

3675 

3694 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

3695  const int hsize,

3696  const int nlayers,

3697  miopenDropoutDescriptor_t dropoutDesc,

3698  miopenRNNInputMode_t inMode,

3699  miopenRNNDirectionMode_t direction,

3700  miopenRNNMode_t rnnMode,

3701  miopenRNNBiasMode_t biasMode,

3702  miopenRNNAlgo_t algo,

3703  miopenDataType_t dataType);

3704 

3719 MIOPEN_EXPORT miopenStatus_t

3720 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

3721  miopenDataType_t dataType,

3722  miopenRNNBaseLayout_t layout,

3723  int maxSequenceLen,

3724  int batchSize,

3725  int vectorSize,

3726  const int* sequenceLenArray,

3727  void* paddingMarker);

3728 

3747 MIOPEN_EXPORT miopenStatus_t

3748 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

3749  miopenDataType_t* dataType,

3750  miopenRNNBaseLayout_t* layout,

3751  int* maxSequenceLen,

3752  int* batchSize,

3753  int* vectorSize,

3754  int sequenceLenArrayLimit,

3755  int* sequenceLenArray,

3756  void* paddingMarker);

3757 

3774 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,

3775  const miopenRNNDescriptor_t rnnDesc,

3776  const int sequenceLen,

3777  const miopenTensorDescriptor_t* xDesc,

3778  size_t* numBytes);

3779 

3796 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,

3797  miopenRNNDescriptor_t rnnDesc,

3798  const int sequenceLen,

3799  const miopenTensorDescriptor_t* xDesc,

3800  size_t* numBytes);

3801 

3818 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,

3819  miopenRNNDescriptor_t rnnDesc,

3820  miopenSeqTensorDescriptor_t xDesc,

3821  miopenRNNFWDMode_t fwdMode,

3822  size_t* workSpaceSize,

3823  size_t* reserveSpaceSize);

3824 

3837 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,

3838  miopenRNNDescriptor_t rnnDesc,

3839  miopenTensorDescriptor_t xDesc,

3840  size_t* numBytes,

3841  miopenDataType_t dtype);

3842 

3855 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,

3856  miopenRNNDescriptor_t rnnDesc,

3857  miopenTensorDescriptor_t xDesc,

3858  miopenTensorDescriptor_t wDesc,

3859  miopenDataType_t dtype);

3860 

3878 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,

3879  miopenRNNDescriptor_t rnnDesc,

3880  const int seqLen,

3881  miopenTensorDescriptor_t* xDesc,

3882  size_t* numBytes);

3883 

3896 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,

3897  miopenRNNDescriptor_t rnnDesc,

3898  const int seqLen,

3899  miopenTensorDescriptor_t* xDesc,

3900  size_t* numBytes);

3901 

3942 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,

3943  miopenRNNDescriptor_t rnnDesc,

3944  const int layer,

3945  miopenTensorDescriptor_t xDesc,

3946  const int paramID,

3947  size_t* numBytes);

3948 

3986 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,

3987  miopenRNNDescriptor_t rnnDesc,

3988  const int layer,

3989  const int biasID,

3990  size_t* numBytes);

3991 

4050 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,

4051  miopenRNNDescriptor_t rnnDesc,

4052  const int layer,

4053  miopenTensorDescriptor_t xDesc,

4054  miopenTensorDescriptor_t wDesc,

4055  const void* w,

4056  const int paramID,

4057  miopenTensorDescriptor_t paramDesc,

4058  void* layerParam);

4059 

4117 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,

4118  miopenRNNDescriptor_t rnnDesc,

4119  const int layer,

4120  miopenTensorDescriptor_t xDesc,

4121  miopenTensorDescriptor_t wDesc,

4122  const void* w,

4123  const int biasID,

4124  miopenTensorDescriptor_t biasDesc,

4125  void* layerBias);

4126 

4181 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,

4182  const int layer,

4183  miopenTensorDescriptor_t xDesc,

4184  const int paramID,

4185  miopenTensorDescriptor_t paramDesc,

4186  size_t* layerParamOffset);

4187 

4238 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,

4239  const int layer,

4240  miopenTensorDescriptor_t xDesc,

4241  const int biasID,

4242  miopenTensorDescriptor_t biasDesc,

4243  size_t* layerBiasOffset);

4244 

4297 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,

4298  miopenRNNDescriptor_t rnnDesc,

4299  const int layer,

4300  miopenTensorDescriptor_t xDesc,

4301  miopenTensorDescriptor_t wDesc,

4302  void* w,

4303  const int paramID,

4304  miopenTensorDescriptor_t paramDesc,

4305  const void* layerParam);

4306 

4357 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,

4358  miopenRNNDescriptor_t rnnDesc,

4359  const int layer,

4360  miopenTensorDescriptor_t xDesc,

4361  miopenTensorDescriptor_t wDesc,

4362  void* w,

4363  const int biasID,

4364  miopenTensorDescriptor_t biasDesc,

4365  const void* layerBias);

4366 

4378 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

4379  miopenRNNPaddingMode_t paddingMode);

4380 

4388 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

4389  miopenRNNPaddingMode_t* paddingMode);

4390 

4441 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,

4442  const miopenRNNDescriptor_t rnnDesc,

4443  miopenRNNFWDMode_t fwdMode,

4444  const miopenSeqTensorDescriptor_t xDesc,

4445  const void* x,

4446  const miopenTensorDescriptor_t hDesc,

4447  const void* hx,

4448  void* hy,

4449  const miopenTensorDescriptor_t cDesc,

4450  const void* cx,

4451  void* cy,

4452  const miopenSeqTensorDescriptor_t yDesc,

4453  void* y,

4454  const void* w,

4455  size_t weightSpaceSize,

4456  void* workSpace,

4457  size_t workSpaceNumBytes,

4458  void* reserveSpace,

4459  size_t reserveSpaceNumBytes);

4460 

4510 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,

4511  const miopenRNNDescriptor_t rnnDesc,

4512  const miopenSeqTensorDescriptor_t yDesc,

4513  const void* y,

4514  const void* dy,

4515  const miopenTensorDescriptor_t hDesc,

4516  const void* hx,

4517  const void* dhy,

4518  void* dhx,

4519  const miopenTensorDescriptor_t cDesc,

4520  const void* cx,

4521  const void* dcy,

4522  void* dcx,

4523  const miopenSeqTensorDescriptor_t xDesc,

4524  void* dx,

4525  const void* w,

4526  size_t weightSpaceSize,

4527  void* workSpace,

4528  size_t workSpaceNumBytes,

4529  void* reserveSpace,

4530  size_t reserveSpaceNumBytes);

4531 

4565 MIOPEN_EXPORT miopenStatus_t

4566 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,

4567  const miopenRNNDescriptor_t rnnDesc,

4568  const miopenSeqTensorDescriptor_t xDesc,

4569  const void* x,

4570  const miopenTensorDescriptor_t hDesc,

4571  const void* hx,

4572  const miopenSeqTensorDescriptor_t yDesc,

4573  const void* y,

4574  void* dw,

4575  size_t weightSpaceSize,

4576  void* workSpace,

4577  size_t workSpaceNumBytes,

4578  const void* reserveSpace,

4579  size_t reserveSpaceNumBytes);

4580 

4638 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,

4639  const miopenRNNDescriptor_t rnnDesc,

4640  const int sequenceLen,

4641  const miopenTensorDescriptor_t* xDesc,

4642  const void* x,

4643  const miopenTensorDescriptor_t hxDesc,

4644  const void* hx,

4645  const miopenTensorDescriptor_t cxDesc,

4646  const void* cx,

4647  const miopenTensorDescriptor_t wDesc,

4648  const void* w,

4649  const miopenTensorDescriptor_t* yDesc,

4650  void* y,

4651  const miopenTensorDescriptor_t hyDesc,

4652  void* hy,

4653  const miopenTensorDescriptor_t cyDesc,

4654  void* cy,

4655  void* workSpace,

4656  size_t workSpaceNumBytes,

4657  void* reserveSpace,

4658  size_t reserveSpaceNumBytes);

4659 

4732 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,

4733  const miopenRNNDescriptor_t rnnDesc,

4734  const int sequenceLen,

4735  const miopenTensorDescriptor_t* yDesc,

4736  const void* y,

4737  const miopenTensorDescriptor_t* dyDesc,

4738  const void* dy,

4739  const miopenTensorDescriptor_t dhyDesc,

4740  const void* dhy,

4741  const miopenTensorDescriptor_t dcyDesc,

4742  const void* dcy,

4743  const miopenTensorDescriptor_t wDesc,

4744  const void* w,

4745  const miopenTensorDescriptor_t hxDesc,

4746  const void* hx,

4747  const miopenTensorDescriptor_t cxDesc,

4748  const void* cx,

4749  const miopenTensorDescriptor_t* dxDesc,

4750  void* dx,

4751  const miopenTensorDescriptor_t dhxDesc,

4752  void* dhx,

4753  const miopenTensorDescriptor_t dcxDesc,

4754  void* dcx,

4755  void* workSpace,

4756  size_t workSpaceNumBytes,

4757  void* reserveSpace,

4758  size_t reserveSpaceNumBytes);

4759 

4796 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,

4797  const miopenRNNDescriptor_t rnnDesc,

4798  const int sequenceLen,

4799  const miopenTensorDescriptor_t* xDesc,

4800  const void* x,

4801  const miopenTensorDescriptor_t hxDesc,

4802  const void* hx,

4803  const miopenTensorDescriptor_t* yDesc,

4804  const void* y,

4805  const miopenTensorDescriptor_t dwDesc,

4806  void* dw,

4807  void* workSpace,

4808  size_t workSpaceNumBytes,

4809  const void* reserveSpace,

4810  size_t reserveSpaceNumBytes);

4811 

4867 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,

4868  miopenRNNDescriptor_t rnnDesc,

4869  const int sequenceLen,

4870  const miopenTensorDescriptor_t* xDesc,

4871  const void* x,

4872  const miopenTensorDescriptor_t hxDesc,

4873  const void* hx,

4874  const miopenTensorDescriptor_t cxDesc,

4875  const void* cx,

4876  const miopenTensorDescriptor_t wDesc,

4877  const void* w,

4878  const miopenTensorDescriptor_t* yDesc,

4879  void* y,

4880  const miopenTensorDescriptor_t hyDesc,

4881  void* hy,

4882  const miopenTensorDescriptor_t cyDesc,

4883  void* cy,

4884  void* workSpace,

4885  size_t workSpaceNumBytes);

4886 

4888 // CLOSEOUT RNN DOXYGEN GROUP

4889 

4898 typedef enum

4899 {

4900  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,

4901 } miopenCTCLossAlgo_t;

4902 

4909 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);

4910 

4920 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

4921  miopenDataType_t* dataType,

4922  int* blank_label_id,

4923  bool* apply_softmax_layer);

4924 

4930 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);

4931 

4941 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

4942  miopenDataType_t dataType,

4943  const int blank_label_id,

4944  bool apply_softmax_layer);

4945 

4962 MIOPEN_EXPORT miopenStatus_t

4963 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,

4964  const miopenTensorDescriptor_t probsDesc,

4965  const miopenTensorDescriptor_t gradientsDesc,

4966  const int* labels,

4967  const int* labelLengths,

4968  const int* inputLengths,

4969  miopenCTCLossAlgo_t algo,

4970  const miopenCTCLossDescriptor_t ctcLossDesc,

4971  size_t* workSpaceSize);

4972 

4992 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,

4993  const miopenTensorDescriptor_t probsDesc,

4994  const void* probs,

4995  const int* labels,

4996  const int* labelLengths,

4997  const int* inputLengths,

4998  void* losses,

4999  const miopenTensorDescriptor_t gradientsDesc,

5000  void* gradients,

5001  miopenCTCLossAlgo_t algo,

5002  const miopenCTCLossDescriptor_t ctcLossDesc,

5003  void* workSpace,

5004  size_t workSpaceSize);

5005 

5007 // CLOSEOUT LossFunction DOXYGEN GROUP

5008 

5009 // Dropout APIs

5018 typedef enum

5019 {

5020  MIOPEN_RNG_PSEUDO_XORWOW = 0,

5021 } miopenRNGType_t;

5022 

5028 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);

5029 

5035 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);

5036 

5045 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,

5046  size_t* reserveSpaceSizeInBytes);

5047 

5056 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,

5057  size_t* stateSizeInBytes);

5058 

5075 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5076  miopenHandle_t handle,

5077  float* dropout,

5078  void** states,

5079  unsigned long long* seed,

5080  bool* use_mask,

5081  bool* state_evo,

5082  miopenRNGType_t* rng_mode);

5083 

5106 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5107  miopenHandle_t handle,

5108  float dropout,

5109  void* states,

5110  size_t stateSizeInBytes,

5111  unsigned long long seed,

5112  bool use_mask,

5113  bool state_evo,

5114  miopenRNGType_t rng_mode);

5115 

5135 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5136  miopenHandle_t handle,

5137  float dropout,

5138  void* states,

5139  size_t stateSizeInBytes,

5140  unsigned long long seed,

5141  bool use_mask,

5142  bool state_evo,

5143  miopenRNGType_t rng_mode);

5144 

5162 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,

5163  const miopenDropoutDescriptor_t dropoutDesc,

5164  const miopenTensorDescriptor_t noise_shape,

5165  const miopenTensorDescriptor_t xDesc,

5166  const void* x,

5167  const miopenTensorDescriptor_t yDesc,

5168  void* y,

5169  void* reserveSpace,

5170  size_t reserveSpaceSizeInBytes);

5171 

5189 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,

5190  const miopenDropoutDescriptor_t dropoutDesc,

5191  const miopenTensorDescriptor_t noise_shape,

5192  const miopenTensorDescriptor_t dyDesc,

5193  const void* dy,

5194  const miopenTensorDescriptor_t dxDesc,

5195  void* dx,

5196  void* reserveSpace,

5197  size_t reserveSpaceSizeInBytes);

5198 

5200 // CLOSEOUT DROPOUT DOXYGEN GROUP

5201 

5202 // TensorReduce APIs

5213 MIOPEN_EXPORT miopenStatus_t

5214 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);

5215 

5221 MIOPEN_EXPORT miopenStatus_t

5222 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);

5223 

5236 MIOPEN_EXPORT miopenStatus_t

5237 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,

5238  miopenReduceTensorOp_t reduceTensorOp,

5239  miopenDataType_t reduceTensorCompType,

5240  miopenNanPropagation_t reduceTensorNanOpt,

5241  miopenReduceTensorIndices_t reduceTensorIndices,

5242  miopenIndicesType_t reduceTensorIndicesType);

5243 

5259 MIOPEN_EXPORT miopenStatus_t

5260 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,

5261  miopenReduceTensorOp_t* reduceTensorOp,

5262  miopenDataType_t* reduceTensorCompType,

5263  miopenNanPropagation_t* reduceTensorNanOpt,

5264  miopenReduceTensorIndices_t* reduceTensorIndices,

5265  miopenIndicesType_t* reduceTensorIndicesType);

5266 

5276 MIOPEN_EXPORT miopenStatus_t

5277 miopenGetReductionIndicesSize(miopenHandle_t handle,

5278  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5279  const miopenTensorDescriptor_t aDesc,

5280  const miopenTensorDescriptor_t cDesc,

5281  size_t* sizeInBytes);

5282 

5292 MIOPEN_EXPORT miopenStatus_t

5293 miopenGetReductionWorkspaceSize(miopenHandle_t handle,

5294  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5295  const miopenTensorDescriptor_t aDesc,

5296  const miopenTensorDescriptor_t cDesc,

5297  size_t* sizeInBytes);

5298 

5322 MIOPEN_EXPORT miopenStatus_t

5323 miopenReduceTensor(miopenHandle_t handle,

5324  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5325  void* indices,

5326  size_t indicesSizeInBytes,

5327  void* workspace,

5328  size_t workspaceSizeInBytes,

5329  const void* alpha,

5330  const miopenTensorDescriptor_t aDesc,

5331  const void* A,

5332  const void* beta,

5333  const miopenTensorDescriptor_t cDesc,

5334  void* C);

5335 

5337 // CLOSEOUT TensorReduce DOXYGEN GROUP

5338 

5339 // Find 2.0 API

5350 MIOPEN_DECLARE_OBJECT(miopenProblem);

5351 

5355 typedef enum

5356 {

5357  miopenProblemDirectionForward = 0,

5358  miopenProblemDirectionBackward = 1,

5359  miopenProblemDirectionBackwardWeights = 2,

5360 #ifdef MIOPEN_BETA_API

5361  miopenProblemDirectionInference = 4,

5362 #endif

5363 } miopenProblemDirection_t;

5364 

5368 typedef enum

5369 {

5370  miopenTensorArgumentIdInvalid = 0,

5371  miopenTensorConvolutionX = 1,

5372  miopenTensorConvolutionW = 2,

5373  miopenTensorConvolutionY = 3,

5374 

5375  miopenTensorMhaK = 4,

5376  miopenTensorMhaQ = 5,

5377  miopenTensorMhaV = 6,

5378  miopenTensorMhaDescaleK = 7,

5379  miopenTensorMhaDescaleQ = 8,

5380  miopenTensorMhaDescaleV = 9,

5381  miopenTensorMhaDescaleS = 10,

5382  miopenTensorMhaScaleS = 11,

5383  miopenTensorMhaScaleO = 12,

5384  miopenTensorMhaDropoutProbability = 13,

5385  miopenTensorMhaDropoutSeed = 14,

5386  miopenTensorMhaDropoutOffset = 15,

5387  miopenTensorMhaO = 16,

5388  miopenTensorMhaAmaxO = 17,

5389  miopenTensorMhaAmaxS = 18,

5390  miopenTensorMhaM = 19,

5391  miopenTensorMhaZInv = 20,

5392  miopenTensorMhaDO = 21,

5393  miopenTensorMhaDescaleO = 22,

5394  miopenTensorMhaDescaleDO = 23,

5395  miopenTensorMhaDescaleDS = 24,

5396  miopenTensorMhaScaleDS = 25,

5397  miopenTensorMhaScaleDQ = 26,

5398  miopenTensorMhaScaleDK = 27,

5399  miopenTensorMhaScaleDV = 28,

5400  miopenTensorMhaDQ = 29,

5401  miopenTensorMhaDK = 30,

5402  miopenTensorMhaDV = 31,

5403  miopenTensorMhaAmaxDQ = 32,

5404  miopenTensorMhaAmaxDK = 33,

5405  miopenTensorMhaAmaxDV = 34,

5406  miopenTensorMhaAmaxDS = 35,

5407 

5408 #ifdef MIOPEN_BETA_API

5409  miopenTensorActivationX = 36,

5410  miopenTensorActivationY = 37,

5411  miopenTensorActivationDX = 38,

5412  miopenTensorActivationDY = 39,

5413  miopenTensorBiasX = 40,

5414  miopenTensorBiasY = 41,

5415  miopenTensorBias = 42,

5416  miopenTensorSoftmaxX = 43,

5417  miopenTensorSoftmaxY = 44,

5418  miopenTensorSoftmaxDX = 45,

5419  miopenTensorSoftmaxDY = 46,

5420  miopenTensorBatchnormX = 47,

5421  miopenTensorBatchnormY = 48,

5422  miopenTensorBatchnormRunningMean = 49,

5423  miopenTensorBatchnormRunningVariance = 50,

5424  miopenTensorBatchnormSavedMean = 51,

5425  miopenTensorBatchnormSavedVariance = 52,

5426  miopenTensorBatchnormScale = 53,

5427  miopenTensorBatchnormScaleDiff = 54,

5428  miopenTensorBatchnormEstimatedMean = 55,

5429  miopenTensorBatchnormEstimatedVariance = 56,

5430  miopenTensorBatchnormBias = 57,

5431  miopenTensorBatchnormBiasDiff = 58,

5432  miopenTensorBatchnormDX = 59,

5433  miopenTensorBatchnormDY = 60,

5434 #endif

5435 

5436  miopenTensorArgumentIsScalar = 1U << 31,

5437 

5438 #ifdef MIOPEN_BETA_API

5439  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 1,

5440  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 2,

5441 #endif

5442 } miopenTensorArgumentId_t;

5443 

5447 typedef enum

5448 {

5449  miopenFindResultsOrderByTime = 0,

5450  miopenFindResultsOrderByWorkspaceSize = 1,

5451 } miopenFindResultsOrder_t;

5452 

5460 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,

5461  miopenConvolutionDescriptor_t operatorDesc,

5462  miopenProblemDirection_t direction);

5463 

5472 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,

5473  miopenMhaDescriptor_t operatorDesc,

5474  miopenProblemDirection_t direction);

5475 

5482 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);

5483 

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

5494 

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

5505 

5512 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);

5513 

5525 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,

5526  float alpha,

5527  float beta,

5528  miopenSoftmaxAlgorithm_t algorithm,

5529  miopenSoftmaxMode_t mode);

5530 

5542 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,

5543  float* alpha,

5544  float* beta,

5545  miopenSoftmaxAlgorithm_t* algorithm,

5546  miopenSoftmaxMode_t* mode);

5547 

5553 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);

5554 

5562 MIOPEN_EXPORT miopenStatus_t

5563 miopenSetProblemTensorDescriptor(miopenProblem_t problem,

5564  miopenTensorArgumentId_t id,

5565  const miopenTensorDescriptor_t descriptor);

5566 

5569 MIOPEN_DECLARE_OBJECT(miopenFindOptions);

5570 

5576 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);

5577 

5583 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);

5584 

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

5592 

5599 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,

5600  miopenFindResultsOrder_t value);

5601 

5609 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,

5610  size_t value);

5611 

5619 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,

5620  void* buffer,

5621  size_t size);

5622 

5631 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,

5632  miopenTensorArgumentId_t id,

5633  void* buffer);

5634 

5637 MIOPEN_DECLARE_OBJECT(miopenSolution);

5638 

5650 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,

5651  miopenProblem_t problem,

5652  miopenFindOptions_t options,

5653  miopenSolution_t* solutions,

5654  size_t* numSolutions,

5655  size_t maxSolutions);

5656 

5659 struct miopenTensorArgument_t

5660 {

5661  /* @brief Identifier of the tensor argument.

5662  */

5663  miopenTensorArgumentId_t id;

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

5665  *

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

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

5668  */

5669  miopenTensorDescriptor_t* descriptor;

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

5671  * the value is scalar.

5672  */

5673  void* buffer;

5674 };

5675 

5687 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,

5688  miopenSolution_t solution,

5689  size_t nInputs,

5690  const miopenTensorArgument_t* tensors,

5691  void* workspace,

5692  size_t workspaceSize);

5693 

5699 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);

5700 

5708 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,

5709  const char* data,

5710  size_t size);

5711 

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

5719 

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

5727 

5734 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,

5735  size_t* workspaceSize);

5736 

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

5744 

5751 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,

5752  uint64_t* solverId);

5753 

5760 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,

5761  miopenConvAlgorithm_t* result);

5762 

5763 #ifdef MIOPEN_BETA_API

5764 

5773 MIOPEN_EXPORT miopenStatus_t

5774 miopenCreateActivationProblem(miopenProblem_t* problem,

5775  miopenActivationDescriptor_t operatorDesc,

5776  miopenProblemDirection_t direction);

5777 

5786 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,

5787  miopenBatchNormMode_t mode,

5788  bool runningMeanVariance,

5789  miopenProblemDirection_t direction);

5790 

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

5811 

5819 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,

5820  miopenProblemDirection_t direction);

5821 

5830 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,

5831  miopenSoftmaxDescriptor_t operatorDesc,

5832  miopenProblemDirection_t direction);

5833 

5834 #endif

5835 

5837 // CLOSEOUT find2 DOXYGEN GROUP

5838 

5839 #ifdef MIOPEN_BETA_API

5840 

5845 typedef enum

5846 {

5847  MIOPEN_SUM_NOT_PROPAGATE_NAN = 0,

5848  MIOPEN_SUM_PROPAGATE_NAN = 1,

5849 } miopenSumNanPropagation_t;

5850 

5851 // Sum APIs

5866 MIOPEN_EXPORT miopenStatus_t miopenGetSumWorkspaceSize(miopenHandle_t handle,

5867  const miopenTensorDescriptor_t xDesc,

5868  const int32_t dim,

5869  const miopenTensorDescriptor_t yDesc,

5870  size_t* sizeInBytes);

5871 

5885 MIOPEN_EXPORT miopenStatus_t miopenSumForward(miopenHandle_t handle,

5886  miopenSumNanPropagation_t nanPropagation,

5887  void* workspace,

5888  size_t workspaceSizeInBytes,

5889  const miopenTensorDescriptor_t xDesc,

5890  const void* x,

5891  const int32_t dim,

5892  const miopenTensorDescriptor_t yDesc,

5893  void* y);

5894 

5896 // CLOSEOUT SUM DOXYGEN GROUP

5897 #endif

5898 

5899 #ifdef MIOPEN_BETA_API

5900 

5905 typedef enum

5906 {

5907  MIOPEN_REDUCE_EXTREME_ARGMIN =

5908  1,

5909  MIOPEN_REDUCE_EXTREME_ARGMAX =

5910  2,

5911  MIOPEN_REDUCE_EXTREME_MIN =

5912  3,

5913  MIOPEN_REDUCE_EXTREME_MAX =

5914  4,

5915 } miopenReduceExtremeOp_t;

5916 

5917 // ReduceExtreme APIs

5937 MIOPEN_EXPORT miopenStatus_t

5938 miopenReduceExtremeForward(miopenHandle_t handle,

5939  const miopenTensorDescriptor_t xDesc,

5940  const void* x,

5941  const int32_t dim,

5942  const miopenReduceExtremeOp_t reduceExtremeOp,

5943  const miopenTensorDescriptor_t yDesc,

5944  void* y,

5945  const miopenTensorDescriptor_t indiceDesc,

5946  void* indice);

5947 

5949 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP

5950 #endif

5951 

5952 #ifdef MIOPEN_BETA_API

5953 // GroupNorm APIs

5978 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,

5979  miopenNormMode_t mode,

5980  const miopenTensorDescriptor_t xDesc,

5981  const void* x,

5982  const miopenTensorDescriptor_t weightDesc,

5983  const void* weight,

5984  const miopenTensorDescriptor_t biasDesc,

5985  const void* bias,

5986  const uint64_t num_groups,

5987  const float epsilon,

5988  const miopenTensorDescriptor_t yDesc,

5989  void* y,

5990  const miopenTensorDescriptor_t meanDesc,

5991  void* mean,

5992  const miopenTensorDescriptor_t rstdDesc,

5993  void* rstd);

5994 

5996 // CLOSEOUT groupnorm DOXYGEN GROUP

5997 #endif

5998 

5999 #ifdef MIOPEN_BETA_API

6000 // LayerNorm APIs

6027 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,

6028  miopenNormMode_t mode,

6029  const miopenTensorDescriptor_t xDesc,

6030  const void* x,

6031  const miopenTensorDescriptor_t x2Desc,

6032  const void* x2,

6033  const miopenTensorDescriptor_t weightDesc,

6034  const void* weight,

6035  const miopenTensorDescriptor_t biasDesc,

6036  const void* bias,

6037  const float epsilon,

6038  const int32_t normalized_dim,

6039  const miopenTensorDescriptor_t yDesc,

6040  void* y,

6041  const miopenTensorDescriptor_t meanDesc,

6042  void* mean,

6043  const miopenTensorDescriptor_t rstdDesc,

6044  void* rstd);

6045 

6047 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6048 #endif

6049 

6050 #ifdef MIOPEN_BETA_API

6051 // LayerNorm APIs

6071 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,

6072  miopenNormMode_t mode,

6073  const miopenTensorDescriptor_t xDesc,

6074  const void* x,

6075  const miopenTensorDescriptor_t weightDesc,

6076  const void* weight,

6077  const float epsilon,

6078  const miopenTensorDescriptor_t yDesc,

6079  void* y,

6080  const miopenTensorDescriptor_t rstdDesc,

6081  void* rstd);

6082 

6097 MIOPEN_EXPORT miopenStatus_t

6098 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,

6099  miopenNormMode_t mode,

6100  const miopenTensorDescriptor_t dyDesc,

6101  const miopenTensorDescriptor_t xDesc,

6102  const miopenTensorDescriptor_t weightDesc,

6103  const miopenTensorDescriptor_t rstdDesc,

6104  const miopenTensorDescriptor_t dxDesc,

6105  const miopenTensorDescriptor_t dwDesc,

6106  size_t* sizeInBytes);

6107 

6128 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,

6129  miopenNormMode_t mode,

6130  void* workspace,

6131  size_t workspaceSizeInBytes,

6132  const miopenTensorDescriptor_t dyDesc,

6133  const void* dy,

6134  const miopenTensorDescriptor_t xDesc,

6135  const void* x,

6136  const miopenTensorDescriptor_t weightDesc,

6137  const void* weight,

6138  const miopenTensorDescriptor_t rstdDesc,

6139  const void* rstd,

6140  const miopenTensorDescriptor_t dxDesc,

6141  void* dx,

6142  const miopenTensorDescriptor_t dwDesc,

6143  void* dw);

6145 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6146 #endif

6147 

6148 #ifdef MIOPEN_BETA_API

6149 // Graph API

6161 typedef enum

6162 {

6163  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,

6164  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,

6165  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,

6166  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,

6167  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,

6168  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,

6169  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,

6170  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,

6171  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,

6172  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,

6173  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,

6174  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,

6175  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,

6176  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,

6177  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,

6178  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,

6179  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,

6180  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,

6181  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,

6182  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,

6183  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,

6184  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,

6185  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,

6186  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,

6187  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,

6188  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,

6189  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,

6190  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,

6191  MIOPEN_BACKEND_RNG_DESCRIPTOR,

6192  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,

6193  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,

6194 } miopenBackendDescriptorType_t;

6195 

6203 typedef enum

6204 {

6205  MIOPEN_ATTR_POINTWISE_MODE = 0,

6206  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,

6207  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,

6208  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,

6209  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,

6210  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,

6211  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,

6212  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,

6213  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,

6214  MIOPEN_ATTR_POINTWISE_AXIS = 9,

6215 

6216  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,

6217  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,

6218  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,

6219  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,

6220  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,

6221  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,

6222  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,

6223 

6224  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,

6225  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,

6226  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,

6227  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,

6228 

6229  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,

6230  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,

6231  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,

6232 

6233  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,

6234  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,

6235  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,

6236  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,

6237  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,

6238  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,

6239 

6240  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,

6241  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,

6242  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,

6243  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,

6244 

6245  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,

6246  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,

6247 

6248  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,

6249  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,

6250  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,

6251  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,

6252  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,

6253  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,

6254  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,

6255  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,

6256  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,

6257  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,

6258  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,

6259  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,

6260  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,

6261  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,

6262  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,

6263  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,

6264  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,

6265  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,

6266  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,

6267  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,

6268  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,

6269  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,

6270  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,

6271  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,

6272  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,

6273  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,

6274  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,

6275 

6276  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,

6277  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,

6278  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,

6279  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,

6280  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,

6281 

6282  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,

6283  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,

6284  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,

6285  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,

6286  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,

6287  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,

6288  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,

6289  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,

6290  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,

6291  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,

6292  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,

6293  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,

6294  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,

6295  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,

6296  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,

6297  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,

6298  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,

6299 

6300  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,

6301  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,

6302  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,

6303 

6304  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,

6305  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,

6306  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,

6307  MIOPEN_ATTR_TENSOR_STRIDES = 903,

6308  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,

6309  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,

6310  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,

6311  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,

6312  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,

6313  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,

6314  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,

6315 

6316  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,

6317  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,

6318  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,

6319  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,

6320 

6321  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,

6322  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,

6323 

6324  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,

6325  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,

6326  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,

6327  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,

6328 

6329  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,

6330  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,

6331  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,

6332  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,

6333  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,

6334  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,

6335  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,

6336 

6337  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,

6338  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,

6339 

6340  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,

6341  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,

6342  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,

6343  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,

6344  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,

6345  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,

6346  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,

6347  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,

6348 

6349  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,

6350  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,

6351 

6352  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,

6353  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,

6354  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,

6355 

6356  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,

6357  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,

6358  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,

6359  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,

6360  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,

6361  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,

6362  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,

6363  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,

6364  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,

6365  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,

6366  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,

6367 

6368  MIOPEN_ATTR_RESAMPLE_MODE = 1700,

6369  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,

6370  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,

6371  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,

6372  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,

6373  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,

6374  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,

6375  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,

6376  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,

6377 

6378  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,

6379  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,

6380  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,

6381  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,

6382  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,

6383  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,

6384 

6385  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,

6386  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,

6387  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,

6388  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,

6389  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,

6390  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,

6391  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,

6392  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,

6393 

6394  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,

6395  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,

6396  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,

6397  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,

6398 

6399  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,

6400  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,

6401  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,

6402  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,

6403  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,

6404 

6405  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,

6406  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,

6407  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,

6408  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,

6409  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,

6410  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,

6411  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,

6412  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,

6413  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,

6414  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,

6415  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,

6416  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,

6417  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,

6418  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,

6419  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,

6420 

6421  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,

6422  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,

6423  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,

6424  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,

6425  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,

6426  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,

6427  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,

6428  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,

6429  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,

6430  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,

6431  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,

6432 

6433  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,

6434  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,

6435 

6436  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,

6437  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,

6438  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,

6439  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,

6440  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,

6441  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,

6442 

6443  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,

6444  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,

6445  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,

6446  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,

6447 

6448 } miopenBackendAttributeName_t;

6449 

6457 typedef enum

6458 {

6459  MIOPEN_TYPE_HANDLE = 0,

6460  MIOPEN_TYPE_DATA_TYPE,

6461  MIOPEN_TYPE_BOOLEAN,

6462  MIOPEN_TYPE_INT64,

6463  MIOPEN_TYPE_FLOAT,

6464  MIOPEN_TYPE_DOUBLE,

6465  MIOPEN_TYPE_VOID_PTR,

6466  MIOPEN_TYPE_CONVOLUTION_MODE,

6467  MIOPEN_TYPE_HEUR_MODE,

6468  MIOPEN_TYPE_KNOB_TYPE,

6469  MIOPEN_TYPE_NAN_PROPOGATION,

6470  MIOPEN_TYPE_NUMERICAL_NOTE,

6471  MIOPEN_TYPE_LAYOUT_TYPE,

6472  MIOPEN_TYPE_ATTRIB_NAME,

6473  MIOPEN_TYPE_POINTWISE_MODE,

6474  MIOPEN_TYPE_BACKEND_DESCRIPTOR,

6475  MIOPEN_TYPE_GENSTATS_MODE,

6476  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,

6477  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,

6478  MIOPEN_TYPE_BEHAVIOR_NOTE,

6479  MIOPEN_TYPE_TENSOR_REORDERING_MODE,

6480  MIOPEN_TYPE_RESAMPLE_MODE,

6481  MIOPEN_TYPE_PADDING_MODE,

6482  MIOPEN_TYPE_INT32,

6483  MIOPEN_TYPE_CHAR,

6484  MIOPEN_TYPE_SIGNAL_MODE,

6485  MIOPEN_TYPE_FRACTION,

6486  MIOPEN_TYPE_NORM_MODE,

6487  MIOPEN_TYPE_NORM_FWD_PHASE,

6488  MIOPEN_TYPE_RNG_DISTRIBUTION

6489 } miopenBackendAttributeType_t;

6490 

6496 typedef enum

6497 {

6499  MIOPEN_POINTWISE_ADD,

6500 

6503  MIOPEN_POINTWISE_ADD_SQUARE,

6504 

6506  MIOPEN_POINTWISE_DIV,

6507 

6509  MIOPEN_POINTWISE_MAX,

6510 

6512  MIOPEN_POINTWISE_MIN,

6513 

6516  MIOPEN_POINTWISE_MOD,

6517 

6519  MIOPEN_POINTWISE_MUL,

6520 

6522  MIOPEN_POINTWISE_POW,

6523 

6525  MIOPEN_POINTWISE_SUB,

6526 

6528  MIOPEN_POINTWISE_ABS,

6529 

6531  MIOPEN_POINTWISE_CEIL,

6532 

6534  MIOPEN_POINTWISE_COS,

6535 

6537  MIOPEN_POINTWISE_EXP,

6538 

6540  MIOPEN_POINTWISE_FLOOR,

6541 

6543  MIOPEN_POINTWISE_LOG,

6544 

6546  MIOPEN_POINTWISE_NEG,

6547 

6549  MIOPEN_POINTWISE_RSQRT,

6550 

6552  MIOPEN_POINTWISE_SIN,

6553 

6555  MIOPEN_POINTWISE_SQRT,

6556 

6558  MIOPEN_POINTWISE_TAN,

6559 

6561  MIOPEN_POINTWISE_ERF,

6562 

6566  MIOPEN_POINTWISE_IDENTITY,

6567 

6569  MIOPEN_POINTWISE_RELU_FWD,

6570 

6572  MIOPEN_POINTWISE_TANH_FWD,

6573 

6575  MIOPEN_POINTWISE_SIGMOID_FWD,

6576 

6578  MIOPEN_POINTWISE_ELU_FWD,

6579 

6582  MIOPEN_POINTWISE_GELU_FWD,

6583 

6585  MIOPEN_POINTWISE_SOFTPLUS_FWD,

6586 

6588  MIOPEN_POINTWISE_SWISH_FWD,

6589 

6593  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,

6594 

6597  MIOPEN_POINTWISE_RELU_BWD,

6598 

6600  MIOPEN_POINTWISE_TANH_BWD,

6601 

6603  MIOPEN_POINTWISE_SIGMOID_BWD,

6604 

6607  MIOPEN_POINTWISE_ELU_BWD,

6608 

6611  MIOPEN_POINTWISE_GELU_BWD,

6612 

6614  MIOPEN_POINTWISE_SOFTPLUS_BWD,

6615 

6617  MIOPEN_POINTWISE_SWISH_BWD,

6618 

6624  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,

6625 

6627  MIOPEN_POINTWISE_CMP_EQ,

6628 

6630  MIOPEN_POINTWISE_CMP_NEQ,

6631 

6633  MIOPEN_POINTWISE_CMP_GT,

6634 

6637  MIOPEN_POINTWISE_CMP_GE,

6638 

6640  MIOPEN_POINTWISE_CMP_LT,

6641 

6644  MIOPEN_POINTWISE_CMP_LE,

6645 

6647  MIOPEN_POINTWISE_LOGICAL_AND,

6648 

6650  MIOPEN_POINTWISE_LOGICAL_OR,

6651 

6653  MIOPEN_POINTWISE_LOGICAL_NOT,

6654 

6656  MIOPEN_POINTWISE_GEN_INDEX,

6657 

6660  MIOPEN_POINTWISE_BINARY_SELECT,

6661 

6664  MIOPEN_POINTWISE_RECIPROCAL

6665 } miopenPointwiseMode_t;

6666 

6672 typedef enum

6673 {

6674  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,

6675  MIOPEN_RNG_DISTRIBUTION_UNIFORM,

6676  MIOPEN_RNG_DISTRIBUTION_NORMAL,

6677 } miopenRngDistribution_t;

6678 

6679 typedef enum

6680 {

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

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

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

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

6685 

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

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

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

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

6690  But used to check for errors.*/

6691 } miopenAlphaBetaCase_t;

6696 typedef enum

6697 {

6698  MIOPEN_HEUR_MODE_INSTANT = 0,

6699  MIOPEN_HEUR_MODE_B = 1,

6700  MIOPEN_HEUR_MODE_FALLBACK = 2,

6701  MIOPEN_HEUR_MODE_A = 3,

6702  MIOPEN_HEUR_MODES_COUNT = 4,

6703 } miopenBackendHeurMode_t;

6704 

6717 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)

6718 

6719 

6732 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(

6733  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);

6734 

6764 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,

6765  miopenBackendAttributeName_t attributeName,

6766  miopenBackendAttributeType_t attributeType,

6767  int64_t elementCount,

6768  void* arrayOfElements);

6769 

6786 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);

6787 

6822 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,

6823  miopenBackendAttributeName_t attributeName,

6824  miopenBackendAttributeType_t attributeType,

6825  int64_t requestedElementCount,

6826  int64_t* elementCount,

6827  void* arrayOfElements);

6828 

6848 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,

6849  miopenBackendDescriptor_t executionPlan,

6850  miopenBackendDescriptor_t variantPack);

6851 

6868 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);

6869 

6887 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,

6888  miopenBackendDescriptorType_t descriptorType,

6889  size_t sizeInBytes);

6890 

6892 // CLOSEOUT BackendAPI DOXYGEN GROUP

6893 #endif // MIOPEN_BETA_API

6894 

6895 #ifdef MIOPEN_BETA_API

6896 // FusedAdam APIs

7003 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,

7004  const miopenTensorDescriptor_t paramDesc,

7005  void* param,

7006  const miopenTensorDescriptor_t gradDesc,

7007  const void* grad,

7008  const miopenTensorDescriptor_t expAvgDesc,

7009  void* expAvg,

7010  const miopenTensorDescriptor_t expAvgSqDesc,

7011  void* expAvgSq,

7012  const miopenTensorDescriptor_t maxExpAvgSqDesc,

7013  void* maxExpAvgSq,

7014  const miopenTensorDescriptor_t stateStepDesc,

7015  void* stateStep,

7016  const unsigned int state_step,

7017  const float lr,

7018  const float beta1,

7019  const float beta2,

7020  const float weight_decay,

7021  const float eps,

7022  const bool amsgrad,

7023  const bool maximize,

7024  const bool adamw,

7025  const miopenTensorDescriptor_t gradScaleDesc,

7026  const void* gradScale,

7027  const miopenTensorDescriptor_t foundInfDesc,

7028  const void* foundInf);

7029 

7170 MIOPEN_EXPORT miopenStatus_t

7171 miopenFusedAdamWithOutput(miopenHandle_t handle,

7172  const miopenTensorDescriptor_t paramInDesc,

7173  void* paramIn,

7174  const miopenTensorDescriptor_t paramOutDesc,

7175  void* paramOut,

7176  const miopenTensorDescriptor_t paramOutFloat16Desc,

7177  void* paramOutFloat16,

7178  const miopenTensorDescriptor_t gradInDesc,

7179  const void* gradIn,

7180  const miopenTensorDescriptor_t expAvgInDesc,

7181  void* expAvgIn,

7182  const miopenTensorDescriptor_t expAvgOutDesc,

7183  void* expAvgOut,

7184  const miopenTensorDescriptor_t expAvgSqInDesc,

7185  void* expAvgSqIn,

7186  const miopenTensorDescriptor_t expAvgSqOutDesc,

7187  void* expAvgSqOut,

7188  const miopenTensorDescriptor_t maxExpAvgSqInDesc,

7189  void* maxExpAvgSqIn,

7190  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,

7191  void* maxExpAvgSqOut,

7192  const miopenTensorDescriptor_t stateStepInDesc,

7193  void* stateStepIn,

7194  const miopenTensorDescriptor_t stateStepOutDesc,

7195  void* stateStepOut,

7196  const unsigned int state_step,

7197  const float lr,

7198  const float beta1,

7199  const float beta2,

7200  const float weight_decay,

7201  const float eps,

7202  const bool amsgrad,

7203  const bool maximize,

7204  const bool adamw,

7205  const miopenTensorDescriptor_t gradScaleDesc,

7206  const void* gradScale,

7207  const miopenTensorDescriptor_t foundInfDesc,

7208  const void* foundInf);

7209 

7211 // CLOSEOUT SGD DOXYGEN GROUP

7212 #endif // MIOPEN_BETA_API

7213 

7214 #ifdef __cplusplus

7215 }

7216 #endif

7217 

7218 #ifdef __clang__

7219 #pragma clang diagnostic pop

7220 #endif

7221 

7222 #endif // MIOPEN_GUARD_MIOPEN_H_

miopenCreateOpActivationBackward

miopenStatus_t miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *activBwdOp, miopenActivationMode_t mode)

Creates a backward activation operator.

miopenCreateOpBatchNormForward

miopenStatus_t miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnFwdOp, const miopenBatchNormMode_t bn_mode, bool runningMeanVariance)

Creates a forward training batch normalization operator.

miopenFusionPlanConvolutionGetAlgo

miopenStatus_t miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, const int requestAlgoCount, int *returnedAlgoCount, miopenConvFwdAlgorithm_t *returnedAlgos)

Returns the supported algorithms for the convolution operator in the Fusion Plan.

miopenFusionPlanGetWorkSpaceSize

miopenStatus_t miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle, miopenFusionPlanDescriptor_t fusePlanDesc, size_t *workSpaceSize, miopenConvFwdAlgorithm_t algo)

Query the workspace size required for the fusion plan.

miopenFusionPlanConvolutionSetAlgo

miopenStatus_t miopenFusionPlanConvolutionSetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo)

Requests the fusion runtime to choose a particular algorithm for the added convolution operation.

miopenCreateOpBatchNormInference

miopenStatus_t miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnOp, const miopenBatchNormMode_t bn_mode, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc)

Creates a forward inference batch normalization operator.

miopenSetOpArgsBiasForward

miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t biasOp, const void *alpha, const void *beta, const void *bias)

Sets the arguments for forward bias op.

miopenCreateOpConvForward

miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *convOp, miopenConvolutionDescriptor_t convDesc, const miopenTensorDescriptor_t wDesc)

Creates forward convolution operator.

miopenSetOpArgsBatchNormInference

miopenStatus_t miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *bnScale, const void *bnBias, const void *estimatedMean, const void *estimatedVariance, double epsilon)

Sets the arguments for inference batch normalization op.

miopenSetOpArgsBatchNormForward

miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *bnScale, const void *bnBias, void *savedMean, void *savedInvVariance, void *runningMean, void *runningVariance, double expAvgFactor, double epsilon)

Sets the arguments for forward batch normalization op.

miopenExecuteFusionPlan

miopenStatus_t miopenExecuteFusionPlan(const miopenHandle_t handle, const miopenFusionPlanDescriptor_t fusePlanDesc, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, miopenOperatorArgs_t args)

Executes the fusion plan.

miopenFusionPlanGetOp

miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc, const int op_idx, miopenFusionOpDescriptor_t *op)

Allows access to the operators in a fusion plan.

miopenDestroyFusionPlan

miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc)

Destroy the fusion plan descriptor object.

miopenCreateOpActivationForward

miopenStatus_t miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *activFwdOp, miopenActivationMode_t mode)

Creates a forward activation operator.

miopenFusionDirection_t

miopenFusionDirection_t

Kernel fusion direction in the network.

Definition: miopen.h:3071

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

miopenVerticalFusion

@ miopenVerticalFusion

Definition: miopen.h:3072

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

miopenPointwiseMode_t

miopenPointwiseMode_t

Intended poinwise math operation for a pointwise operation descriptor.

Definition: miopen.h:6497

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

miopenRngDistribution_t

miopenRngDistribution_t

Distribution for random number generation.

Definition: miopen.h:6673

miopenBackendDescriptorType_t

miopenBackendDescriptorType_t

Descriptor type.

Definition: miopen.h:6162

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

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

MIOPEN_HEUR_MODE_INSTANT

@ MIOPEN_HEUR_MODE_INSTANT

Definition: miopen.h:6698

MIOPEN_HEUR_MODE_A

@ MIOPEN_HEUR_MODE_A

Definition: miopen.h:6701

MIOPEN_HEUR_MODE_B

@ MIOPEN_HEUR_MODE_B

Definition: miopen.h:6699

MIOPEN_HEUR_MODES_COUNT

@ MIOPEN_HEUR_MODES_COUNT

Definition: miopen.h:6702

MIOPEN_HEUR_MODE_FALLBACK

@ MIOPEN_HEUR_MODE_FALLBACK

Definition: miopen.h:6700

MIOPEN_POINTWISE_SOFTPLUS_FWD

@ MIOPEN_POINTWISE_SOFTPLUS_FWD

Definition: miopen.h:6585

MIOPEN_POINTWISE_ELU_FWD

@ MIOPEN_POINTWISE_ELU_FWD

Definition: miopen.h:6578

MIOPEN_POINTWISE_RELU_FWD

@ MIOPEN_POINTWISE_RELU_FWD

Definition: miopen.h:6569

MIOPEN_POINTWISE_DIV

@ MIOPEN_POINTWISE_DIV

Definition: miopen.h:6506

MIOPEN_POINTWISE_SIGMOID_BWD

@ MIOPEN_POINTWISE_SIGMOID_BWD

Definition: miopen.h:6603

MIOPEN_POINTWISE_POW

@ MIOPEN_POINTWISE_POW

Definition: miopen.h:6522

MIOPEN_POINTWISE_MOD

@ MIOPEN_POINTWISE_MOD

Definition: miopen.h:6516

MIOPEN_POINTWISE_SQRT

@ MIOPEN_POINTWISE_SQRT

Definition: miopen.h:6555

MIOPEN_POINTWISE_BINARY_SELECT

@ MIOPEN_POINTWISE_BINARY_SELECT

Definition: miopen.h:6660

MIOPEN_POINTWISE_GELU_BWD

@ MIOPEN_POINTWISE_GELU_BWD

Definition: miopen.h:6611

MIOPEN_POINTWISE_MIN

@ MIOPEN_POINTWISE_MIN

Definition: miopen.h:6512

MIOPEN_POINTWISE_CMP_NEQ

@ MIOPEN_POINTWISE_CMP_NEQ

Definition: miopen.h:6630

MIOPEN_POINTWISE_FLOOR

@ MIOPEN_POINTWISE_FLOOR

Definition: miopen.h:6540

MIOPEN_POINTWISE_RSQRT

@ MIOPEN_POINTWISE_RSQRT

Definition: miopen.h:6549

MIOPEN_POINTWISE_CMP_EQ

@ MIOPEN_POINTWISE_CMP_EQ

Definition: miopen.h:6627

MIOPEN_POINTWISE_CMP_GE

@ MIOPEN_POINTWISE_CMP_GE

Definition: miopen.h:6637

MIOPEN_POINTWISE_ADD_SQUARE

@ MIOPEN_POINTWISE_ADD_SQUARE

Definition: miopen.h:6503

MIOPEN_POINTWISE_ERF

@ MIOPEN_POINTWISE_ERF

Definition: miopen.h:6561

MIOPEN_POINTWISE_SWISH_FWD

@ MIOPEN_POINTWISE_SWISH_FWD

Definition: miopen.h:6588

MIOPEN_POINTWISE_LOG

@ MIOPEN_POINTWISE_LOG

Definition: miopen.h:6543

MIOPEN_POINTWISE_SUB

@ MIOPEN_POINTWISE_SUB

Definition: miopen.h:6525

MIOPEN_POINTWISE_NEG

@ MIOPEN_POINTWISE_NEG

Definition: miopen.h:6546

MIOPEN_POINTWISE_LOGICAL_AND

@ MIOPEN_POINTWISE_LOGICAL_AND

Definition: miopen.h:6647

MIOPEN_POINTWISE_SWISH_BWD

@ MIOPEN_POINTWISE_SWISH_BWD

Definition: miopen.h:6617

MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

Definition: miopen.h:6593

MIOPEN_POINTWISE_SIN

@ MIOPEN_POINTWISE_SIN

Definition: miopen.h:6552

MIOPEN_POINTWISE_RECIPROCAL

@ MIOPEN_POINTWISE_RECIPROCAL

Definition: miopen.h:6664

MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

Definition: miopen.h:6624

MIOPEN_POINTWISE_GELU_FWD

@ MIOPEN_POINTWISE_GELU_FWD

Definition: miopen.h:6582

MIOPEN_POINTWISE_ABS

@ MIOPEN_POINTWISE_ABS

Definition: miopen.h:6528

MIOPEN_POINTWISE_CMP_LT

@ MIOPEN_POINTWISE_CMP_LT

Definition: miopen.h:6640

MIOPEN_POINTWISE_EXP

@ MIOPEN_POINTWISE_EXP

Definition: miopen.h:6537

MIOPEN_POINTWISE_GEN_INDEX

@ MIOPEN_POINTWISE_GEN_INDEX

Definition: miopen.h:6656

MIOPEN_POINTWISE_CEIL

@ MIOPEN_POINTWISE_CEIL

Definition: miopen.h:6531

MIOPEN_POINTWISE_LOGICAL_NOT

@ MIOPEN_POINTWISE_LOGICAL_NOT

Definition: miopen.h:6653

MIOPEN_POINTWISE_SIGMOID_FWD

@ MIOPEN_POINTWISE_SIGMOID_FWD

Definition: miopen.h:6575

MIOPEN_POINTWISE_SOFTPLUS_BWD

@ MIOPEN_POINTWISE_SOFTPLUS_BWD

Definition: miopen.h:6614

MIOPEN_POINTWISE_LOGICAL_OR

@ MIOPEN_POINTWISE_LOGICAL_OR

Definition: miopen.h:6650

MIOPEN_POINTWISE_TAN

@ MIOPEN_POINTWISE_TAN

Definition: miopen.h:6558

MIOPEN_POINTWISE_ELU_BWD

@ MIOPEN_POINTWISE_ELU_BWD

Definition: miopen.h:6607

MIOPEN_POINTWISE_IDENTITY

@ MIOPEN_POINTWISE_IDENTITY

Definition: miopen.h:6566

MIOPEN_POINTWISE_CMP_LE

@ MIOPEN_POINTWISE_CMP_LE

Definition: miopen.h:6644

MIOPEN_POINTWISE_COS

@ MIOPEN_POINTWISE_COS

Definition: miopen.h:6534

MIOPEN_POINTWISE_TANH_BWD

@ MIOPEN_POINTWISE_TANH_BWD

Definition: miopen.h:6600

MIOPEN_POINTWISE_MUL

@ MIOPEN_POINTWISE_MUL

Definition: miopen.h:6519

MIOPEN_POINTWISE_TANH_FWD

@ MIOPEN_POINTWISE_TANH_FWD

Definition: miopen.h:6572

MIOPEN_POINTWISE_RELU_BWD

@ MIOPEN_POINTWISE_RELU_BWD

Definition: miopen.h:6597

MIOPEN_POINTWISE_ADD

@ MIOPEN_POINTWISE_ADD

Definition: miopen.h:6499

MIOPEN_POINTWISE_MAX

@ MIOPEN_POINTWISE_MAX

Definition: miopen.h:6509

MIOPEN_POINTWISE_CMP_GT

@ MIOPEN_POINTWISE_CMP_GT

Definition: miopen.h:6633

MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

Definition: miopen.h:6421

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

Definition: miopen.h:6251

MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

Definition: miopen.h:6375

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

Definition: miopen.h:6378

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

Definition: miopen.h:6257

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

Definition: miopen.h:6248

MIOPEN_ATTR_OPERATION_SIGNAL_MODE

@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE

Definition: miopen.h:6399

MIOPEN_ATTR_OPERATION_RNG_DESC

@ MIOPEN_ATTR_OPERATION_RNG_DESC

Definition: miopen.h:6445

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

Definition: miopen.h:6249

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

Definition: miopen.h:6362

MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

Definition: miopen.h:6424

MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

Definition: miopen.h:6412

MIOPEN_ATTR_OPERATIONGRAPH_OPS

@ MIOPEN_ATTR_OPERATIONGRAPH_OPS

Definition: miopen.h:6301

MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

Definition: miopen.h:6325

MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

Definition: miopen.h:6220

MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

Definition: miopen.h:6403

MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

Definition: miopen.h:6428

MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

Definition: miopen.h:6431

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

Definition: miopen.h:6392

MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

Definition: miopen.h:6221

MIOPEN_ATTR_REDUCTION_OPERATOR

@ MIOPEN_ATTR_REDUCTION_OPERATOR

Definition: miopen.h:6349

MIOPEN_ATTR_OPERATION_MATMUL_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_DESC

Definition: miopen.h:6343

MIOPEN_ATTR_CONVOLUTION_DILATIONS

@ MIOPEN_ATTR_CONVOLUTION_DILATIONS

Definition: miopen.h:6218

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

Definition: miopen.h:6386

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

Definition: miopen.h:6270

MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

Definition: miopen.h:6370

MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

Definition: miopen.h:6236

MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

Definition: miopen.h:6408

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

Definition: miopen.h:6290

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

Definition: miopen.h:6358

MIOPEN_ATTR_KNOB_INFO_TYPE

@ MIOPEN_ATTR_KNOB_INFO_TYPE

Definition: miopen.h:6324

MIOPEN_ATTR_LAYOUT_INFO_TYPES

@ MIOPEN_ATTR_LAYOUT_INFO_TYPES

Definition: miopen.h:6322

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

Definition: miopen.h:6284

MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

Definition: miopen.h:6300

MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

Definition: miopen.h:6425

MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

Definition: miopen.h:6440

MIOPEN_ATTR_POINTWISE_MATH_PREC

@ MIOPEN_ATTR_POINTWISE_MATH_PREC

Definition: miopen.h:6206

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

Definition: miopen.h:6346

MIOPEN_ATTR_OPERATION_GENSTATS_MODE

@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE

Definition: miopen.h:6276

MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

Definition: miopen.h:6246

MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

Definition: miopen.h:6318

MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

Definition: miopen.h:6353

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

Definition: miopen.h:6261

MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

Definition: miopen.h:6319

MIOPEN_ATTR_TENSOR_IS_BY_VALUE

@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE

Definition: miopen.h:6312

MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

Definition: miopen.h:6405

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

Definition: miopen.h:6250

MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

Definition: miopen.h:6282

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

Definition: miopen.h:6415

MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

Definition: miopen.h:6433

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

Definition: miopen.h:6391

MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

Definition: miopen.h:6267

MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

Definition: miopen.h:6316

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

Definition: miopen.h:6361

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

Definition: miopen.h:6381

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

Definition: miopen.h:6286

MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

Definition: miopen.h:6401

MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

Definition: miopen.h:6400

MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

Definition: miopen.h:6274

MIOPEN_ATTR_ENGINEHEUR_RESULTS

@ MIOPEN_ATTR_ENGINEHEUR_RESULTS

Definition: miopen.h:6226

MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

Definition: miopen.h:6304

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

Definition: miopen.h:6264

MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

Definition: miopen.h:6296

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

Definition: miopen.h:6366

MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

Definition: miopen.h:6277

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

Definition: miopen.h:6414

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

Definition: miopen.h:6294

MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

Definition: miopen.h:6233

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

Definition: miopen.h:6360

MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

Definition: miopen.h:6397

MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

Definition: miopen.h:6427

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

Definition: miopen.h:6255

MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

Definition: miopen.h:6235

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

Definition: miopen.h:6258

MIOPEN_ATTR_TENSOR_VECTOR_COUNT

@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT

Definition: miopen.h:6308

MIOPEN_ATTR_OPERATION_MATMUL_CDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC

Definition: miopen.h:6342

MIOPEN_ATTR_REDUCTION_COMP_TYPE

@ MIOPEN_ATTR_REDUCTION_COMP_TYPE

Definition: miopen.h:6350

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

Definition: miopen.h:6389

MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

Definition: miopen.h:6309

MIOPEN_ATTR_TENSOR_DIMENSIONS

@ MIOPEN_ATTR_TENSOR_DIMENSIONS

Definition: miopen.h:6306

MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

Definition: miopen.h:6279

MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

Definition: miopen.h:6396

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

Definition: miopen.h:6271

MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

Definition: miopen.h:6332

MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

Definition: miopen.h:6334

MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

Definition: miopen.h:6238

MIOPEN_ATTR_RESAMPLE_STRIDES

@ MIOPEN_ATTR_RESAMPLE_STRIDES

Definition: miopen.h:6373

MIOPEN_ATTR_POINTWISE_ELU_ALPHA

@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA

Definition: miopen.h:6211

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

Definition: miopen.h:6417

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

Definition: miopen.h:6387

MIOPEN_ATTR_OPERATION_RNG_SEED

@ MIOPEN_ATTR_OPERATION_RNG_SEED

Definition: miopen.h:6444

MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

Definition: miopen.h:6422

MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

Definition: miopen.h:6272

MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

Definition: miopen.h:6395

MIOPEN_ATTR_RESAMPLE_MODE

@ MIOPEN_ATTR_RESAMPLE_MODE

Definition: miopen.h:6368

MIOPEN_ATTR_RNG_DISTRIBUTION

@ MIOPEN_ATTR_RNG_DISTRIBUTION

Definition: miopen.h:6436

MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

Definition: miopen.h:6423

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

Definition: miopen.h:6345

MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

Definition: miopen.h:6406

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

Definition: miopen.h:6210

MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

Definition: miopen.h:6434

MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

Definition: miopen.h:6317

MIOPEN_ATTR_POINTWISE_AXIS

@ MIOPEN_ATTR_POINTWISE_AXIS

Definition: miopen.h:6214

MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

Definition: miopen.h:6418

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

Definition: miopen.h:6208

MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

Definition: miopen.h:6329

MIOPEN_ATTR_OPERATION_MATMUL_BDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC

Definition: miopen.h:6341

MIOPEN_ATTR_TENSOR_DATA_TYPE

@ MIOPEN_ATTR_TENSOR_DATA_TYPE

Definition: miopen.h:6305

MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

Definition: miopen.h:6402

MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

Definition: miopen.h:6326

MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

Definition: miopen.h:6411

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

Definition: miopen.h:6383

MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

Definition: miopen.h:6372

MIOPEN_ATTR_MATMUL_COMP_TYPE

@ MIOPEN_ATTR_MATMUL_COMP_TYPE

Definition: miopen.h:6337

MIOPEN_ATTR_TENSOR_UNIQUE_ID

@ MIOPEN_ATTR_TENSOR_UNIQUE_ID

Definition: miopen.h:6310

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

Definition: miopen.h:6364

MIOPEN_ATTR_OPERATION_CONCAT_AXIS

@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS

Definition: miopen.h:6394

MIOPEN_ATTR_OPERATION_RNG_YDESC

@ MIOPEN_ATTR_OPERATION_RNG_YDESC

Definition: miopen.h:6443

MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

Definition: miopen.h:6330

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

Definition: miopen.h:6256

MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

Definition: miopen.h:6225

MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

Definition: miopen.h:6314

MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

Definition: miopen.h:6212

MIOPEN_ATTR_TENSOR_IS_VIRTUAL

@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL

Definition: miopen.h:6311

MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

Definition: miopen.h:6231

MIOPEN_ATTR_MATMUL_PADDING_VALUE

@ MIOPEN_ATTR_MATMUL_PADDING_VALUE

Definition: miopen.h:6338

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

Definition: miopen.h:6298

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

Definition: miopen.h:6293

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

Definition: miopen.h:6252

MIOPEN_ATTR_KNOB_INFO_STRIDE

@ MIOPEN_ATTR_KNOB_INFO_STRIDE

Definition: miopen.h:6327

MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

Definition: miopen.h:6374

MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

Definition: miopen.h:6269

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

Definition: miopen.h:6379

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

Definition: miopen.h:6359

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

Definition: miopen.h:6259

MIOPEN_ATTR_CONVOLUTION_CONV_MODE

@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE

Definition: miopen.h:6217

MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

Definition: miopen.h:6352

MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

Definition: miopen.h:6237

MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

Definition: miopen.h:6283

MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

Definition: miopen.h:6335

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

Definition: miopen.h:6295

MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

Definition: miopen.h:6245

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

Definition: miopen.h:6385

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

Definition: miopen.h:6288

MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

Definition: miopen.h:6273

MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

Definition: miopen.h:6413

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

Definition: miopen.h:6365

MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

Definition: miopen.h:6446

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

Definition: miopen.h:6253

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

Definition: miopen.h:6289

MIOPEN_ATTR_ENGINE_LAYOUT_INFO

@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO

Definition: miopen.h:6333

MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

Definition: miopen.h:6240

MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

Definition: miopen.h:6216

MIOPEN_ATTR_RESAMPLE_COMP_TYPE

@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE

Definition: miopen.h:6369

MIOPEN_ATTR_ENGINECFG_ENGINE

@ MIOPEN_ATTR_ENGINECFG_ENGINE

Definition: miopen.h:6229

MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

Definition: miopen.h:6371

MIOPEN_ATTR_RESAMPLE_PADDING_MODE

@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE

Definition: miopen.h:6376

MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

Definition: miopen.h:6222

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

Definition: miopen.h:6416

MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

Definition: miopen.h:6278

MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

Definition: miopen.h:6409

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

Definition: miopen.h:6285

MIOPEN_ATTR_ENGINE_KNOB_INFO

@ MIOPEN_ATTR_ENGINE_KNOB_INFO

Definition: miopen.h:6331

MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

Definition: miopen.h:6344

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

Definition: miopen.h:6263

MIOPEN_ATTR_TENSOR_REORDERING_MODE

@ MIOPEN_ATTR_TENSOR_REORDERING_MODE

Definition: miopen.h:6313

MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

Definition: miopen.h:6241

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

Definition: miopen.h:6347

MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

Definition: miopen.h:6266

MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

Definition: miopen.h:6438

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

Definition: miopen.h:6242

MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

Definition: miopen.h:6321

MIOPEN_ATTR_ENGINEHEUR_MODE

@ MIOPEN_ATTR_ENGINEHEUR_MODE

Definition: miopen.h:6224

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

Definition: miopen.h:6388

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

Definition: miopen.h:6390

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

Definition: miopen.h:6297

MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

Definition: miopen.h:6268

MIOPEN_ATTR_POINTWISE_MODE

@ MIOPEN_ATTR_POINTWISE_MODE

Definition: miopen.h:6205

MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

Definition: miopen.h:6230

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

Definition: miopen.h:6265

MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

Definition: miopen.h:6430

MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

Definition: miopen.h:6207

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

Definition: miopen.h:6243

MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

Definition: miopen.h:6209

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

Definition: miopen.h:6363

MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

Definition: miopen.h:6441

MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

Definition: miopen.h:6227

MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

Definition: miopen.h:6287

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

Definition: miopen.h:6291

MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

Definition: miopen.h:6437

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

Definition: miopen.h:6356

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

Definition: miopen.h:6357

MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

Definition: miopen.h:6419

MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

Definition: miopen.h:6410

MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

Definition: miopen.h:6280

MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

Definition: miopen.h:6234

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

Definition: miopen.h:6382

MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

Definition: miopen.h:6429

MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

Definition: miopen.h:6426

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

Definition: miopen.h:6254

MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

Definition: miopen.h:6439

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

Definition: miopen.h:6262

MIOPEN_ATTR_TENSOR_STRIDES

@ MIOPEN_ATTR_TENSOR_STRIDES

Definition: miopen.h:6307

MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

Definition: miopen.h:6219

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

Definition: miopen.h:6260

MIOPEN_ATTR_POINTWISE_SWISH_BETA

@ MIOPEN_ATTR_POINTWISE_SWISH_BETA

Definition: miopen.h:6213

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

Definition: miopen.h:6380

MIOPEN_ATTR_OPERATION_REDUCTION_DESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC

Definition: miopen.h:6354

MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

Definition: miopen.h:6407

MIOPEN_ATTR_OPERATION_MATMUL_ADESC

@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC

Definition: miopen.h:6340

MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

Definition: miopen.h:6302

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

Definition: miopen.h:6292

MIOPEN_RNG_DISTRIBUTION_BERNOULLI

@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI

Definition: miopen.h:6674

MIOPEN_RNG_DISTRIBUTION_UNIFORM

@ MIOPEN_RNG_DISTRIBUTION_UNIFORM

Definition: miopen.h:6675

MIOPEN_RNG_DISTRIBUTION_NORMAL

@ MIOPEN_RNG_DISTRIBUTION_NORMAL

Definition: miopen.h:6676

MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

Definition: miopen.h:6173

MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

Definition: miopen.h:6190

MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

Definition: miopen.h:6165

MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

Definition: miopen.h:6188

MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

Definition: miopen.h:6184

MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

Definition: miopen.h:6163

MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

Definition: miopen.h:6185

MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

Definition: miopen.h:6170

MIOPEN_BACKEND_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_RNG_DESCRIPTOR

Definition: miopen.h:6191

MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

Definition: miopen.h:6181

MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

Definition: miopen.h:6180

MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

Definition: miopen.h:6166

MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

Definition: miopen.h:6171

MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

Definition: miopen.h:6182

MIOPEN_BACKEND_TENSOR_DESCRIPTOR

@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR

Definition: miopen.h:6192

MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

Definition: miopen.h:6183

MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

Definition: miopen.h:6187

MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

Definition: miopen.h:6176

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

Definition: miopen.h:6175

MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

Definition: miopen.h:6168

MIOPEN_BACKEND_ENGINE_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR

Definition: miopen.h:6164

MIOPEN_BACKEND_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR

Definition: miopen.h:6172

MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

Definition: miopen.h:6177

MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

Definition: miopen.h:6193

MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

Definition: miopen.h:6189

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

Definition: miopen.h:6174

MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

Definition: miopen.h:6178

MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

Definition: miopen.h:6179

MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

Definition: miopen.h:6186

MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

Definition: miopen.h:6167

MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

Definition: miopen.h:6169

SCALE

@ SCALE

Definition: miopen.h:6687

BILINEAR

@ BILINEAR

Definition: miopen.h:6688

DEFAULT

@ DEFAULT

Definition: miopen.h:6686

ERROR_STATE

@ ERROR_STATE

Definition: miopen.h:6689

MIOPEN_TYPE_RNG_DISTRIBUTION

@ MIOPEN_TYPE_RNG_DISTRIBUTION

Definition: miopen.h:6488

MIOPEN_TYPE_FLOAT

@ MIOPEN_TYPE_FLOAT

Definition: miopen.h:6463

MIOPEN_TYPE_NUMERICAL_NOTE

@ MIOPEN_TYPE_NUMERICAL_NOTE

Definition: miopen.h:6470

MIOPEN_TYPE_RESAMPLE_MODE

@ MIOPEN_TYPE_RESAMPLE_MODE

Definition: miopen.h:6480

MIOPEN_TYPE_INT32

@ MIOPEN_TYPE_INT32

Definition: miopen.h:6482

MIOPEN_TYPE_POINTWISE_MODE

@ MIOPEN_TYPE_POINTWISE_MODE

Definition: miopen.h:6473

MIOPEN_TYPE_HANDLE

@ MIOPEN_TYPE_HANDLE

Definition: miopen.h:6459

MIOPEN_TYPE_HEUR_MODE

@ MIOPEN_TYPE_HEUR_MODE

Definition: miopen.h:6467

MIOPEN_TYPE_CONVOLUTION_MODE

@ MIOPEN_TYPE_CONVOLUTION_MODE

Definition: miopen.h:6466

MIOPEN_TYPE_TENSOR_REORDERING_MODE

@ MIOPEN_TYPE_TENSOR_REORDERING_MODE

Definition: miopen.h:6479

MIOPEN_TYPE_BOOLEAN

@ MIOPEN_TYPE_BOOLEAN

Definition: miopen.h:6461

MIOPEN_TYPE_NORM_MODE

@ MIOPEN_TYPE_NORM_MODE

Definition: miopen.h:6486

MIOPEN_TYPE_FRACTION

@ MIOPEN_TYPE_FRACTION

Definition: miopen.h:6485

MIOPEN_TYPE_BACKEND_DESCRIPTOR

@ MIOPEN_TYPE_BACKEND_DESCRIPTOR

Definition: miopen.h:6474

MIOPEN_TYPE_ATTRIB_NAME

@ MIOPEN_TYPE_ATTRIB_NAME

Definition: miopen.h:6472

MIOPEN_TYPE_BEHAVIOR_NOTE

@ MIOPEN_TYPE_BEHAVIOR_NOTE

Definition: miopen.h:6478

MIOPEN_TYPE_DATA_TYPE

@ MIOPEN_TYPE_DATA_TYPE

Definition: miopen.h:6460

MIOPEN_TYPE_NAN_PROPOGATION

@ MIOPEN_TYPE_NAN_PROPOGATION

Definition: miopen.h:6469

MIOPEN_TYPE_DOUBLE

@ MIOPEN_TYPE_DOUBLE

Definition: miopen.h:6464

MIOPEN_TYPE_SIGNAL_MODE

@ MIOPEN_TYPE_SIGNAL_MODE

Definition: miopen.h:6484

MIOPEN_TYPE_CHAR

@ MIOPEN_TYPE_CHAR

Definition: miopen.h:6483

MIOPEN_TYPE_PADDING_MODE

@ MIOPEN_TYPE_PADDING_MODE

Definition: miopen.h:6481

MIOPEN_TYPE_INT64

@ MIOPEN_TYPE_INT64

Definition: miopen.h:6462

MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

Definition: miopen.h:6477

MIOPEN_TYPE_LAYOUT_TYPE

@ MIOPEN_TYPE_LAYOUT_TYPE

Definition: miopen.h:6471

MIOPEN_TYPE_GENSTATS_MODE

@ MIOPEN_TYPE_GENSTATS_MODE

Definition: miopen.h:6475

MIOPEN_TYPE_VOID_PTR

@ MIOPEN_TYPE_VOID_PTR

Definition: miopen.h:6465

MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

Definition: miopen.h:6476

MIOPEN_TYPE_KNOB_TYPE

@ MIOPEN_TYPE_KNOB_TYPE

Definition: miopen.h:6468

MIOPEN_TYPE_NORM_FWD_PHASE

@ MIOPEN_TYPE_NORM_FWD_PHASE

Definition: miopen.h:6487

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

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.

miopenCTCLossAlgo_t

miopenCTCLossAlgo_t

Definition: miopen.h:4899

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.

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

miopenRNNMode_t

miopenRNNMode_t

Definition: miopen.h:3506

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

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

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

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

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

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

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

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

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

miopenLSTM

@ miopenLSTM

Definition: miopen.h:3509

miopenGRU

@ miopenGRU

Definition: miopen.h:3510

miopenRNNRELU

@ miopenRNNRELU

Definition: miopen.h:3507

miopenRNNlinear

@ miopenRNNlinear

Definition: miopen.h:3518

miopenRNNskip

@ miopenRNNskip

Definition: miopen.h:3519

miopenRNNbidirection

@ miopenRNNbidirection

Definition: miopen.h:3539

miopenRNNunidirection

@ miopenRNNunidirection

Definition: miopen.h:3538

miopenRNNwithBias

@ miopenRNNwithBias

Definition: miopen.h:3548

miopenRNNNoBias

@ miopenRNNNoBias

Definition: miopen.h:3547

miopenRNNDataSeqMajorPadded

@ miopenRNNDataSeqMajorPadded

Definition: miopen.h:3584

miopenRNNDataSeqMajorNotPadded

@ miopenRNNDataSeqMajorNotPadded

Definition: miopen.h:3583

miopenRNNDataBatchMajorPadded

@ miopenRNNDataBatchMajorPadded

Definition: miopen.h:3585

miopenRNNDataUnknownLayout

@ miopenRNNDataUnknownLayout

Definition: miopen.h:3582

miopenRNNfundamental

@ miopenRNNfundamental

Definition: miopen.h:3529

miopenRNNdefault

@ miopenRNNdefault

Definition: miopen.h:3527

miopenRNNTraining

@ miopenRNNTraining

Definition: miopen.h:3573

miopenRNNInference

@ miopenRNNInference

Definition: miopen.h:3574

miopenRNNAlgoGEMM

@ miopenRNNAlgoGEMM

Definition: miopen.h:3556

miopenRNNIOWithPadding

@ miopenRNNIOWithPadding

Definition: miopen.h:3565

miopenRNNIONotPadded

@ miopenRNNIONotPadded

Definition: miopen.h:3564

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

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).

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.

miopenReduceTensorIndices_t

miopenReduceTensorIndices_t

Definition: miopen.h:604

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

miopenIndicesType_t

miopenIndicesType_t

Definition: miopen.h:614

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.

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

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.

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.

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.

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

miopenDeriveBNTensorDescriptor

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

Derive tensor for gamma and beta from input tensor descriptor.

miopenCatForward

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

Execute a cat forward layer.

miopenInitConvolutionNdDescriptor

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

Creates a N-dimensional convolution layer descriptor.

miopenConvolutionForwardImmediate

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

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

miopenConvolutionBackwardDataCompileSolution

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

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

miopenConvolutionForwardGetSolutionWorkspaceSize

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

Returns the workspace size required for a particular solution id.

miopenConvolutionForward

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

Execute a forward convolution layer.

miopenGetConvolutionGroupCount

miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)

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

miopenInitConvolutionDescriptor

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

Creates a 2-D convolution layer descriptor.

miopenConvAlgorithm_t

miopenConvAlgorithm_t

Definition: miopen.h:1211

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

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

miopenConvolutionAttrib_t

miopenConvolutionAttrib_t

Definition: miopen.h:626

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

miopenSetConvolutionAttribute

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

Set the attribute of the convolution descriptor.

miopenConvolutionBackwardDataImmediate

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

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

miopenSetTransposeConvNdOutputPadding

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

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

miopenSetTransposeConvOutputPadding

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

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

miopenGetConvolutionSpatialDim

miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc, int *spatialDim)

Retrieves the spatial dimension of a convolution layer descriptor.

miopenConvBwdWeightsAlgorithm_t

miopenConvBwdWeightsAlgorithm_t

Definition: miopen.h:1186

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

miopenConvolutionAlgoWinograd

@ miopenConvolutionAlgoWinograd

Definition: miopen.h:1215

miopenConvolutionAlgoFFT

@ miopenConvolutionAlgoFFT

Definition: miopen.h:1214

miopenConvolutionAlgoImplicitGEMM

@ miopenConvolutionAlgoImplicitGEMM

Definition: miopen.h:1216

miopenConvolutionAlgoGEMM

@ miopenConvolutionAlgoGEMM

Definition: miopen.h:1212

miopenConvolutionFwdAlgoFFT

@ miopenConvolutionFwdAlgoFFT

Definition: miopen.h:1177

miopenConvolutionFwdAlgoImplicitGEMM

@ miopenConvolutionFwdAlgoImplicitGEMM

Definition: miopen.h:1179

miopenConvolutionFwdAlgoGEMM

@ miopenConvolutionFwdAlgoGEMM

Definition: miopen.h:1175

miopenConvolutionFwdAlgoWinograd

@ miopenConvolutionFwdAlgoWinograd

Definition: miopen.h:1178

miopenConvolutionFwdAlgoDirect

@ miopenConvolutionFwdAlgoDirect

Definition: miopen.h:1176

miopenTransposeBwdDataAlgoGEMM

@ miopenTransposeBwdDataAlgoGEMM

Definition: miopen.h:1202

miopenConvolutionBwdDataAlgoDirect

@ miopenConvolutionBwdDataAlgoDirect

Definition: miopen.h:1199

miopenConvolutionBwdDataAlgoGEMM

@ miopenConvolutionBwdDataAlgoGEMM

Definition: miopen.h:1198

miopenConvolutionBwdDataAlgoFFT

@ miopenConvolutionBwdDataAlgoFFT

Definition: miopen.h:1200

miopenConvolutionBwdDataAlgoWinograd

@ miopenConvolutionBwdDataAlgoWinograd

Definition: miopen.h:1201

miopenConvolutionBwdDataAlgoImplicitGEMM

@ miopenConvolutionBwdDataAlgoImplicitGEMM

Definition: miopen.h:1204

miopenConvolutionBwdWeightsAlgoGEMM

@ miopenConvolutionBwdWeightsAlgoGEMM

Definition: miopen.h:1187

miopenConvolutionBwdWeightsAlgoWinograd

@ miopenConvolutionBwdWeightsAlgoWinograd

Definition: miopen.h:1189

miopenConvolutionBwdWeightsAlgoDirect

@ miopenConvolutionBwdWeightsAlgoDirect

Definition: miopen.h:1188

miopenConvolutionBwdWeightsAlgoImplicitGEMM

@ miopenConvolutionBwdWeightsAlgoImplicitGEMM

Definition: miopen.h:1190

miopenDestroyDropoutDescriptor

miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)

Destroys the dropout descriptor object.

miopenRNGType_t

miopenRNGType_t

Definition: miopen.h:5019

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

miopenFindResultsOrder_t

miopenFindResultsOrder_t

Definition: miopen.h:5448

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.

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.

miopenFuseProblems

miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2)

miopenGetSolutionSize

miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t *size)

Reads the expected size of a solution.

miopenTensorArgumentId_t

miopenTensorArgumentId_t

Definition: miopen.h:5369

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)

Initializes a problem object describing a Mha operation.

miopenProblemDirection_t

miopenProblemDirection_t

Definition: miopen.h:5356

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

miopenFindResultsOrderByTime

@ miopenFindResultsOrderByTime

Definition: miopen.h:5449

miopenTensorMhaDescaleS

@ miopenTensorMhaDescaleS

Definition: miopen.h:5381

miopenTensorMhaO

@ miopenTensorMhaO

Definition: miopen.h:5387

miopenTensorMhaAmaxDV

@ miopenTensorMhaAmaxDV

Definition: miopen.h:5405

miopenTensorBatchnormScaleDiff

@ miopenTensorBatchnormScaleDiff

Definition: miopen.h:5427

miopenTensorMhaDescaleDS

@ miopenTensorMhaDescaleDS

Definition: miopen.h:5395

miopenTensorMhaDropoutSeed

@ miopenTensorMhaDropoutSeed

Definition: miopen.h:5385

miopenTensorBatchnormSavedMean

@ miopenTensorBatchnormSavedMean

Definition: miopen.h:5424

miopenTensorActivationDY

@ miopenTensorActivationDY

Definition: miopen.h:5412

miopenTensorBatchnormDX

@ miopenTensorBatchnormDX

Definition: miopen.h:5432

miopenTensorMhaDescaleV

@ miopenTensorMhaDescaleV

Definition: miopen.h:5380

miopenTensorMhaK

@ miopenTensorMhaK

Definition: miopen.h:5375

miopenTensorConvolutionX

@ miopenTensorConvolutionX

Definition: miopen.h:5371

miopenTensorMhaAmaxDK

@ miopenTensorMhaAmaxDK

Definition: miopen.h:5404

miopenTensorMhaScaleDS

@ miopenTensorMhaScaleDS

Definition: miopen.h:5396

miopenTensorBatchnormBias

@ miopenTensorBatchnormBias

Definition: miopen.h:5430

miopenTensorMhaM

@ miopenTensorMhaM

Definition: miopen.h:5390

miopenTensorBatchnormRunningMean

@ miopenTensorBatchnormRunningMean

Definition: miopen.h:5422

miopenTensorMhaDropoutProbability

@ miopenTensorMhaDropoutProbability

Definition: miopen.h:5384

miopenTensorSoftmaxY

@ miopenTensorSoftmaxY

Definition: miopen.h:5417

miopenTensorSoftmaxDY

@ miopenTensorSoftmaxDY

Definition: miopen.h:5419

miopenTensorMhaDescaleO

@ miopenTensorMhaDescaleO

Definition: miopen.h:5393

miopenTensorMhaScaleO

@ miopenTensorMhaScaleO

Definition: miopen.h:5383

miopenScalarBatchnormExpAvgFactor

@ miopenScalarBatchnormExpAvgFactor

Definition: miopen.h:5439

miopenTensorBatchnormScale

@ miopenTensorBatchnormScale

Definition: miopen.h:5426

miopenTensorBatchnormRunningVariance

@ miopenTensorBatchnormRunningVariance

Definition: miopen.h:5423

miopenTensorActivationDX

@ miopenTensorActivationDX

Definition: miopen.h:5411

miopenTensorMhaScaleDK

@ miopenTensorMhaScaleDK

Definition: miopen.h:5398

miopenTensorMhaV

@ miopenTensorMhaV

Definition: miopen.h:5377

miopenTensorMhaAmaxS

@ miopenTensorMhaAmaxS

Definition: miopen.h:5389

miopenTensorBatchnormBiasDiff

@ miopenTensorBatchnormBiasDiff

Definition: miopen.h:5431

miopenTensorBatchnormSavedVariance

@ miopenTensorBatchnormSavedVariance

Definition: miopen.h:5425

miopenTensorActivationX

@ miopenTensorActivationX

Definition: miopen.h:5409

miopenTensorMhaScaleDV

@ miopenTensorMhaScaleDV

Definition: miopen.h:5399

miopenTensorMhaAmaxO

@ miopenTensorMhaAmaxO

Definition: miopen.h:5388

miopenScalarBatchnormEpsilon

@ miopenScalarBatchnormEpsilon

Definition: miopen.h:5440

miopenTensorMhaScaleDQ

@ miopenTensorMhaScaleDQ

Definition: miopen.h:5397

miopenTensorSoftmaxDX

@ miopenTensorSoftmaxDX

Definition: miopen.h:5418

miopenTensorMhaAmaxDS

@ miopenTensorMhaAmaxDS

Definition: miopen.h:5406

miopenTensorMhaDV

@ miopenTensorMhaDV

Definition: miopen.h:5402

miopenTensorMhaQ

@ miopenTensorMhaQ

Definition: miopen.h:5376

miopenTensorMhaAmaxDQ

@ miopenTensorMhaAmaxDQ

Definition: miopen.h:5403

miopenTensorConvolutionY

@ miopenTensorConvolutionY

Definition: miopen.h:5373

miopenTensorBatchnormEstimatedMean

@ miopenTensorBatchnormEstimatedMean

Definition: miopen.h:5428

miopenTensorBatchnormDY

@ miopenTensorBatchnormDY

Definition: miopen.h:5433

miopenTensorMhaZInv

@ miopenTensorMhaZInv

Definition: miopen.h:5391

miopenTensorMhaDescaleQ

@ miopenTensorMhaDescaleQ

Definition: miopen.h:5379

miopenTensorBatchnormEstimatedVariance

@ miopenTensorBatchnormEstimatedVariance

Definition: miopen.h:5429

miopenTensorArgumentIsScalar

@ miopenTensorArgumentIsScalar

Definition: miopen.h:5436

miopenTensorArgumentIdInvalid

@ miopenTensorArgumentIdInvalid

Definition: miopen.h:5370

miopenTensorMhaDO

@ miopenTensorMhaDO

Definition: miopen.h:5392

miopenTensorMhaDescaleDO

@ miopenTensorMhaDescaleDO

Definition: miopen.h:5394

miopenTensorConvolutionW

@ miopenTensorConvolutionW

Definition: miopen.h:5372

miopenTensorMhaDescaleK

@ miopenTensorMhaDescaleK

Definition: miopen.h:5378

miopenTensorMhaDropoutOffset

@ miopenTensorMhaDropoutOffset

Definition: miopen.h:5386

miopenTensorBiasY

@ miopenTensorBiasY

Definition: miopen.h:5414

miopenTensorMhaDQ

@ miopenTensorMhaDQ

Definition: miopen.h:5400

miopenTensorSoftmaxX

@ miopenTensorSoftmaxX

Definition: miopen.h:5416

miopenTensorBatchnormY

@ miopenTensorBatchnormY

Definition: miopen.h:5421

miopenTensorMhaScaleS

@ miopenTensorMhaScaleS

Definition: miopen.h:5382

miopenTensorBias

@ miopenTensorBias

Definition: miopen.h:5415

miopenTensorActivationY

@ miopenTensorActivationY

Definition: miopen.h:5410

miopenTensorBatchnormX

@ miopenTensorBatchnormX

Definition: miopen.h:5420

miopenTensorBiasX

@ miopenTensorBiasX

Definition: miopen.h:5413

miopenTensorMhaDK

@ miopenTensorMhaDK

Definition: miopen.h:5401

miopenProblemDirectionBackwardWeights

@ miopenProblemDirectionBackwardWeights

Definition: miopen.h:5359

miopenProblemDirectionInference

@ miopenProblemDirectionInference

Definition: miopen.h:5361

miopenProblemDirectionForward

@ miopenProblemDirectionForward

Definition: miopen.h:5357

miopenProblemDirectionBackward

@ miopenProblemDirectionBackward

Definition: miopen.h:5358

miopenGroupNormForward

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

Execute a groupnorm forward layer.

miopenCreateWithStream

miopenStatus_t miopenCreateWithStream(miopenHandle_t *handle, miopenAcceleratorQueue_t stream)

Create a MIOpen handle with an accelerator stream.

miopenDestroy

miopenStatus_t miopenDestroy(miopenHandle_t handle)

Destroys the MIOpen handle.

miopenDeallocatorFunction

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

Custom deallocator function.

Definition: miopen.h:155

miopenGetStream

miopenStatus_t miopenGetStream(miopenHandle_t handle, miopenAcceleratorQueue_t *streamID)

Get the previously created accelerator command queue.

miopenEnableProfiling

miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable)

Enable profiling to retrieve kernel time.

miopenGetVersion

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

Method to return version of MIOpen.

miopenStatus_t

miopenStatus_t

Definition: miopen.h:106

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

miopenAllocatorFunction

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

Custom allocator function.

Definition: miopen.h:145

miopenGetErrorString

const char * miopenGetErrorString(miopenStatus_t error)

Get character string for an error code.

miopenCreate

miopenStatus_t miopenCreate(miopenHandle_t *handle)

Method to create the MIOpen handle object.

miopenGetKernelTime

miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float *time)

Get time for last kernel launched.

miopenSetStream

miopenStatus_t miopenSetStream(miopenHandle_t handle, miopenAcceleratorQueue_t streamID)

Set accelerator command queue previously created.

miopenStatusUnsupportedOp

@ miopenStatusUnsupportedOp

Definition: miopen.h:115

miopenStatusGpuOperationsSkipped

@ miopenStatusGpuOperationsSkipped

Definition: miopen.h:116

miopenStatusUnknownError

@ miopenStatusUnknownError

Definition: miopen.h:114

miopenStatusSuccess

@ miopenStatusSuccess

Definition: miopen.h:107

miopenStatusVersionMismatch

@ miopenStatusVersionMismatch

Definition: miopen.h:117

miopenStatusAllocFailed

@ miopenStatusAllocFailed

Definition: miopen.h:111

miopenStatusNotImplemented

@ miopenStatusNotImplemented

Definition: miopen.h:113

miopenStatusBadParm

@ miopenStatusBadParm

Definition: miopen.h:110

miopenStatusNotInitialized

@ miopenStatusNotInitialized

Definition: miopen.h:108

miopenStatusInternalError

@ miopenStatusInternalError

Definition: miopen.h:112

miopenStatusInvalidValue

@ miopenStatusInvalidValue

Definition: miopen.h:109

miopenF8RoundingModeStandard

@ miopenF8RoundingModeStandard

Definition: miopen.h:123

miopenF8RoundingModeStochastic

@ miopenF8RoundingModeStochastic

Definition: miopen.h:124

miopenLayerNormForward

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

Execute a layernorm forward layer.

miopenT5LayerNormBackward

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

Execute a T5layernorm backward layer.

miopenT5LayerNormForward

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

Execute a T5layernorm forward layer.

miopenNormMode_t

miopenNormMode_t

Definition: miopen.h:487

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

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

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

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.

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

miopenSoftmaxAlgorithm_t

miopenSoftmaxAlgorithm_t

Definition: miopen.h:538

miopenSumForward

miopenStatus_t miopenSumForward(miopenHandle_t handle, miopenSumNanPropagation_t nanPropagation, void *workspace, size_t workspaceSizeInBytes, const miopenTensorDescriptor_t xDesc, const void *x, const int32_t dim, const miopenTensorDescriptor_t yDesc, void *y)

Execute a sum forward layer.

miopenSumNanPropagation_t

miopenSumNanPropagation_t

Definition: miopen.h:5846

miopenGetSumWorkspaceSize

miopenStatus_t miopenGetSumWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const int32_t dim, const miopenTensorDescriptor_t yDesc, size_t *sizeInBytes)

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

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

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

miopenCreateSeqTensorDescriptor

miopenStatus_t miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t *tensorDesc)

Create a Tensor Descriptor for sequence data.

miopenTensorOp_t

miopenTensorOp_t

Definition: miopen.h:419

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

miopenPaddingDefault

@ miopenPaddingDefault

Definition: miopen.h:444

miopenPaddingSame

@ miopenPaddingSame

Definition: miopen.h:445

miopenPaddingValid

@ miopenPaddingValid

Definition: miopen.h:446

MIOPEN_DECLARE_OBJECT

#define MIOPEN_DECLARE_OBJECT(name)

Definition: miopen.h:76

miopenNanPropagation_t

miopenNanPropagation_t

Definition: miopen.h:594

MIOPEN_PROPAGATE_NAN

@ MIOPEN_PROPAGATE_NAN

Definition: miopen.h:596

MIOPEN_NOT_PROPAGATE_NAN

@ MIOPEN_NOT_PROPAGATE_NAN

Definition: miopen.h:595

miopenPoolingAverage

@ miopenPoolingAverage

Definition: miopen.h:456

miopenPoolingAverageInclusive

@ miopenPoolingAverageInclusive

Definition: miopen.h:457

miopenPoolingMax

@ miopenPoolingMax

Definition: miopen.h:455

miopenTensorCHWN

@ miopenTensorCHWN

Definition: miopen.h:393

miopenTensorNHWC

@ miopenTensorNHWC

Definition: miopen.h:392

miopenTensorNDHWC

@ miopenTensorNDHWC

Definition: miopen.h:399

miopenTensorNCHW

@ miopenTensorNCHW

Definition: miopen.h:391

miopenTensorCHWNc4

@ miopenTensorCHWNc4

Definition: miopen.h:396

miopenTensorNCHWc8

@ miopenTensorNCHWc8

Definition: miopen.h:395

miopenTensorNCDHW

@ miopenTensorNCDHW

Definition: miopen.h:398

miopenTensorCHWNc8

@ miopenTensorCHWNc8

Definition: miopen.h:397

miopenTensorNCHWc4

@ miopenTensorNCHWc4

Definition: miopen.h:394

MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

Definition: miopen.h:606

MIOPEN_REDUCE_TENSOR_NO_INDICES

@ MIOPEN_REDUCE_TENSOR_NO_INDICES

Definition: miopen.h:605

miopenActivationLEAKYRELU

@ miopenActivationLEAKYRELU

Definition: miopen.h:526

miopenActivationPASTHRU

@ miopenActivationPASTHRU

Definition: miopen.h:517

miopenActivationABS

@ miopenActivationABS

Definition: miopen.h:522

miopenActivationLOGISTIC

@ miopenActivationLOGISTIC

Definition: miopen.h:518

miopenActivationCLIPPEDRELU

@ miopenActivationCLIPPEDRELU

Definition: miopen.h:524

miopenActivationRELU

@ miopenActivationRELU

Definition: miopen.h:520

miopenActivationPOWER

@ miopenActivationPOWER

Definition: miopen.h:523

miopenActivationELU

@ miopenActivationELU

Definition: miopen.h:528

miopenActivationSOFTRELU

@ miopenActivationSOFTRELU

Definition: miopen.h:521

miopenActivationTANH

@ miopenActivationTANH

Definition: miopen.h:519

MIOPEN_REDUCE_TENSOR_MUL

@ MIOPEN_REDUCE_TENSOR_MUL

Definition: miopen.h:571

MIOPEN_REDUCE_TENSOR_MAX

@ MIOPEN_REDUCE_TENSOR_MAX

Definition: miopen.h:575

MIOPEN_REDUCE_TENSOR_AVG

@ MIOPEN_REDUCE_TENSOR_AVG

Definition: miopen.h:579

MIOPEN_REDUCE_TENSOR_NORM1

@ MIOPEN_REDUCE_TENSOR_NORM1

Definition: miopen.h:581

MIOPEN_REDUCE_TENSOR_AMAX

@ MIOPEN_REDUCE_TENSOR_AMAX

Definition: miopen.h:577

MIOPEN_REDUCE_TENSOR_MIN

@ MIOPEN_REDUCE_TENSOR_MIN

Definition: miopen.h:573

MIOPEN_REDUCE_TENSOR_ADD

@ MIOPEN_REDUCE_TENSOR_ADD

Definition: miopen.h:570

MIOPEN_REDUCE_TENSOR_NORM2

@ MIOPEN_REDUCE_TENSOR_NORM2

Definition: miopen.h:583

MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

Definition: miopen.h:631

MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

Definition: miopen.h:635

MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

Definition: miopen.h:627

miopenIndexUint16

@ miopenIndexUint16

Definition: miopen.h:409

miopenIndexUint64

@ miopenIndexUint64

Definition: miopen.h:411

miopenIndexUint32

@ miopenIndexUint32

Definition: miopen.h:410

miopenIndexUint8

@ miopenIndexUint8

Definition: miopen.h:408

miopenFloat

@ miopenFloat

Definition: miopen.h:367

miopenBFloat16

@ miopenBFloat16

Definition: miopen.h:371

miopenInt8

@ miopenInt8

Definition: miopen.h:369

miopenInt32

@ miopenInt32

Definition: miopen.h:368

miopenHalf

@ miopenHalf

Definition: miopen.h:366

miopenBFloat8

@ miopenBFloat8

Definition: miopen.h:376

miopenInt64

@ miopenInt64

Definition: miopen.h:381

miopenDouble

@ miopenDouble

Definition: miopen.h:373

miopenFloat8

@ miopenFloat8

Definition: miopen.h:375

MIOPEN_8BIT_INDICES

@ MIOPEN_8BIT_INDICES

Definition: miopen.h:618

MIOPEN_32BIT_INDICES

@ MIOPEN_32BIT_INDICES

Definition: miopen.h:615

MIOPEN_16BIT_INDICES

@ MIOPEN_16BIT_INDICES

Definition: miopen.h:617

MIOPEN_64BIT_INDICES

@ MIOPEN_64BIT_INDICES

Definition: miopen.h:616

miopenPoolingWorkspaceIndexImage

@ miopenPoolingWorkspaceIndexImage

Definition: miopen.h:469

miopenPoolingWorkspaceIndexMask

@ miopenPoolingWorkspaceIndexMask

Definition: miopen.h:468

miopenDepthwise

@ miopenDepthwise

Definition: miopen.h:435

miopenGroupConv

@ miopenGroupConv

Definition: miopen.h:434

miopenTranspose

@ miopenTranspose

Definition: miopen.h:433

miopenConvolution

@ miopenConvolution

Definition: miopen.h:432

MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

Definition: miopen.h:491

MIOPEN_WEIGHT_BIAS

@ MIOPEN_WEIGHT_BIAS

Definition: miopen.h:489

MIOPEN_ELEMENTWISE_AFFINE

@ MIOPEN_ELEMENTWISE_AFFINE

Definition: miopen.h:488

MIOPEN_WEIGHT_BIAS_T5

@ MIOPEN_WEIGHT_BIAS_T5

Definition: miopen.h:497

MIOPEN_ELEMENTWISE_AFFINE_T5

@ MIOPEN_ELEMENTWISE_AFFINE_T5

Definition: miopen.h:495

MIOPEN_WEIGHT_BIAS_FUSED_ADD

@ MIOPEN_WEIGHT_BIAS_FUSED_ADD

Definition: miopen.h:493

MIOPEN_SUM_NOT_PROPAGATE_NAN

@ MIOPEN_SUM_NOT_PROPAGATE_NAN

Definition: miopen.h:5847

MIOPEN_SUM_PROPAGATE_NAN

@ MIOPEN_SUM_PROPAGATE_NAN

Definition: miopen.h:5848

MIOPEN_REDUCE_EXTREME_ARGMAX

@ MIOPEN_REDUCE_EXTREME_ARGMAX

Definition: miopen.h:5909

MIOPEN_REDUCE_EXTREME_MIN

@ MIOPEN_REDUCE_EXTREME_MIN

Definition: miopen.h:5911

MIOPEN_REDUCE_EXTREME_MAX

@ MIOPEN_REDUCE_EXTREME_MAX

Definition: miopen.h:5913

MIOPEN_REDUCE_EXTREME_ARGMIN

@ MIOPEN_REDUCE_EXTREME_ARGMIN

Definition: miopen.h:5907

miopenTensorOpMin

@ miopenTensorOpMin

Definition: miopen.h:422

miopenTensorOpAdd

@ miopenTensorOpAdd

Definition: miopen.h:420

miopenTensorOpMul

@ miopenTensorOpMul

Definition: miopen.h:421

miopenTensorOpMax

@ miopenTensorOpMax

Definition: miopen.h:423

miopenBNSpatial

@ miopenBNSpatial

Definition: miopen.h:508

miopenBNPerActivation

@ miopenBNPerActivation

Definition: miopen.h:507

miopenLRNWithinChannel

@ miopenLRNWithinChannel

Definition: miopen.h:478

miopenLRNCrossChannel

@ miopenLRNCrossChannel

Definition: miopen.h:479

MIOPEN_SOFTMAX_MODE_INSTANCE

@ MIOPEN_SOFTMAX_MODE_INSTANCE

Definition: miopen.h:550

MIOPEN_SOFTMAX_MODE_CHANNEL

@ MIOPEN_SOFTMAX_MODE_CHANNEL

Definition: miopen.h:551

MIOPEN_SOFTMAX_FAST

@ MIOPEN_SOFTMAX_FAST

Definition: miopen.h:539

MIOPEN_SOFTMAX_ACCURATE

@ MIOPEN_SOFTMAX_ACCURATE

Definition: miopen.h:540

MIOPEN_SOFTMAX_LOG

@ MIOPEN_SOFTMAX_LOG

Definition: miopen.h:541

miopenConvAlgoPerf_t

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

Definition: miopen.h:1226

miopenConvAlgoPerf_t::fwd_algo

miopenConvFwdAlgorithm_t fwd_algo

Definition: miopen.h:1229

miopenConvAlgoPerf_t::bwd_data_algo

miopenConvBwdDataAlgorithm_t bwd_data_algo

Definition: miopen.h:1233

miopenConvAlgoPerf_t::memory

size_t memory

Definition: miopen.h:1237

miopenConvAlgoPerf_t::bwd_weights_algo

miopenConvBwdWeightsAlgorithm_t bwd_weights_algo

Definition: miopen.h:1230

miopenConvAlgoPerf_t::time

float time

Definition: miopen.h:1236

miopenConvSolution_t

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

Definition: miopen.h:1250

miopenConvSolution_t::algorithm

miopenConvAlgorithm_t algorithm

Definition: miopen.h:1257

miopenConvSolution_t::solution_id

uint64_t solution_id

Definition: miopen.h:1256

miopenConvSolution_t::workspace_size

size_t workspace_size

Definition: miopen.h:1254

miopenConvSolution_t::time

float time

Definition: miopen.h:1251

miopenTensorArgument_t

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

Definition: miopen.h:5660

miopenTensorArgument_t::id

miopenTensorArgumentId_t id

Definition: miopen.h:5663

miopenTensorArgument_t::buffer

void * buffer

Definition: miopen.h:5673

miopenTensorArgument_t::descriptor

miopenTensorDescriptor_t * descriptor

Definition: miopen.h:5669