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

• include
• miopen

miopen.h

Go to the documentation of this file.

1 // Copyright (c) Advanced Micro Devices, Inc., or its affiliates.

2 // SPDX-License-Identifier: MIT

3 

4 #ifndef MIOPEN_GUARD_MIOPEN_H_

5 #define MIOPEN_GUARD_MIOPEN_H_

6 

7 #ifdef __clang__

8 #pragma clang diagnostic push

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

10 #endif

11 

12 #include <stddef.h>

13 #include <stdbool.h>

14 #include <miopen/config.h>

15 #include <miopen/export.h>

16 

17 #include <hip/hip_runtime_api.h>

18 

19 /*

20  * @defgroup convolutions

21  * @defgroup pooling

22  * @defgroup handle

23  * @defgroup layernorm

24  * @defgroup LRN

25  * @defgroup batchnorm

26  * @defgroup activation

27  * @defgroup tensor

28  * @defgroup softmax

29  * @defgroup RNN

30  * @defgroup fusion

31  * @defgroup LossFunction

32  * @defgroup TensorReduce

33  * @defgroup find2

34  * @defgroup ReduceExtreme

35  * @defgroup groupnorm

36  * @defgroup cat

37  * @defgroup SGD

38  * @defgroup getitem

39  * @defgroup ReduceCalculation

40  * @defgroup RotaryPositionalEmbeddings

41  * @defgroup ReLU

42  *

43  */

44 

46 #define MIOPEN_DECLARE_OBJECT(name) \

47  struct name \

48  { \

49  }; \

50  typedef struct name* name##_t;

51 

52 #ifdef __cplusplus

53 extern "C" {

54 #endif

55 

56 typedef hipStream_t miopenAcceleratorQueue_t;

57 

61 MIOPEN_DECLARE_OBJECT(miopenHandle);

62 

71 typedef enum

72 {

73  miopenStatusSuccess = 0,

74  miopenStatusNotInitialized = 1,

75  miopenStatusInvalidValue = 2,

76  miopenStatusBadParm = 3,

77  miopenStatusAllocFailed = 4,

78  miopenStatusInternalError = 5,

79  miopenStatusNotImplemented = 6,

80  miopenStatusUnknownError = 7,

81  miopenStatusUnsupportedOp = 8,

82  miopenStatusGpuOperationsSkipped = 9,

83  miopenStatusVersionMismatch = 10,

84 } miopenStatus_t;

85 

86 typedef enum

87 {

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

89  miopenMathDefault = 0,

90  miopenMathPedantic =

91  1,

92 } miopenMathType_t;

93 

94 #ifdef MIOPEN_BETA_API

95 typedef enum

96 {

97  miopenF8RoundingModeStandard = 0,

98  miopenF8RoundingModeStochastic = 1,

99 } miopenF8RoundingMode_t;

100 #endif

101 

109 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);

110 

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

120 

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

130 

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

145 

158 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);

159 

174 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,

175  miopenAcceleratorQueue_t stream);

176 

183 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);

184 

192 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,

193  miopenAcceleratorQueue_t streamID);

194 

202 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,

203  miopenAcceleratorQueue_t* streamID);

204 

221 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,

222  miopenAllocatorFunction allocator,

223  miopenDeallocatorFunction deallocator,

224  void* allocatorContext);

225 

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

238 

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

248 // CLOSEOUT HANDLE DOXYGEN GROUP

249 

257 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);

258 

266 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);

267 

274 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);

275 

283 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);

284 

292 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);

293 

301 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);

302 

309 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);

310 

314 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);

315 

319 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);

320 

324 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);

325 

329 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);

330 

334 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);

335 

339 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);

340 

345 typedef enum

346 {

347  miopenHalf = 0,

348  miopenFloat = 1,

349  miopenInt32 = 2,

350  miopenInt8 = 3,

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

352  miopenBFloat16 = 5,

354  miopenDouble = 6,

355  miopenFloat8_fnuz = 7,

356  miopenBFloat8_fnuz = 8,

357  miopenInt64 = 9,

358 } miopenDataType_t;

359 

365 typedef enum

366 {

367  miopenTensorNCHW = 0,

368  miopenTensorNHWC = 1,

369  miopenTensorCHWN = 2,

370  miopenTensorNCHWc4 = 3,

371  miopenTensorNCHWc8 = 4,

372  miopenTensorCHWNc4 = 5,

373  miopenTensorCHWNc8 = 6,

374  miopenTensorNCDHW = 7,

375  miopenTensorNDHWC = 8,

376 } miopenTensorLayout_t;

377 

382 typedef enum

383 {

384  miopenIndexUint8 = 0,

385  miopenIndexUint16 = 1,

386  miopenIndexUint32 = 2,

387  miopenIndexUint64 = 3,

388 } miopenIndexType_t;

389 

394 typedef enum

395 {

396  miopenTensorOpAdd = 0,

397  miopenTensorOpMul = 1,

398  miopenTensorOpMin = 2,

399  miopenTensorOpMax = 3,

400 } miopenTensorOp_t;

401 

406 typedef enum

407 {

408  miopenConvolution = 0,

409  miopenTranspose = 1,

410  miopenGroupConv = 2,

411  miopenDepthwise = 3,

412 } miopenConvolutionMode_t;

413 

418 typedef enum

419 {

420  miopenPaddingDefault = 0,

421  miopenPaddingSame = 1,

422  miopenPaddingValid = 2,

423 } miopenPaddingMode_t;

424 

429 typedef enum

430 {

431  miopenPoolingMax = 0,

432  miopenPoolingAverage = 1,

433  miopenPoolingAverageInclusive = 2,

434 } miopenPoolingMode_t;

435 

442 typedef enum

443 {

444  miopenPoolingWorkspaceIndexMask = 0,

445  miopenPoolingWorkspaceIndexImage = 1,

446 } miopenPoolingWorkspaceIndexMode_t;

447 

452 typedef enum

453 {

454  miopenLRNWithinChannel = 0,

455  miopenLRNCrossChannel = 1,

456 } miopenLRNMode_t;

457 #ifdef MIOPEN_BETA_API

462 typedef enum

463 {

464  MIOPEN_ELEMENTWISE_AFFINE = 0,

465  MIOPEN_WEIGHT_BIAS =

466  1,

467  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =

468  2,

469  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,

471  MIOPEN_ELEMENTWISE_AFFINE_T5 =

472  4,

473  MIOPEN_WEIGHT_BIAS_T5 = 5,

475 } miopenNormMode_t;

476 #endif

481 typedef enum

482 {

483  miopenBNPerActivation = 0,

484  miopenBNSpatial = 1,

485 } miopenBatchNormMode_t;

486 

491 typedef enum

492 {

493  miopenActivationPASTHRU = 0,

494  miopenActivationLOGISTIC = 1,

495  miopenActivationTANH = 2,

496  miopenActivationRELU = 3,

497  miopenActivationSOFTRELU = 4,

498  miopenActivationABS = 5,

499  miopenActivationPOWER = 6,

500  miopenActivationCLIPPEDRELU =

501  7,

502  miopenActivationLEAKYRELU =

503  8,

504  miopenActivationELU =

505  9,

507  miopenActivationCLAMP = 10,

508 } miopenActivationMode_t;

509 

514 typedef enum

515 {

516  MIOPEN_SOFTMAX_FAST = 0,

517  MIOPEN_SOFTMAX_ACCURATE = 1,

518  MIOPEN_SOFTMAX_LOG = 2,

519 } miopenSoftmaxAlgorithm_t;

520 

525 typedef enum

526 {

527  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,

528  MIOPEN_SOFTMAX_MODE_CHANNEL =

529  1,

530 } miopenSoftmaxMode_t;

531 

539 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1

540 

545 typedef enum

546 {

547  MIOPEN_REDUCE_TENSOR_ADD = 0,

548  MIOPEN_REDUCE_TENSOR_MUL =

549  1,

550  MIOPEN_REDUCE_TENSOR_MIN =

551  2,

552  MIOPEN_REDUCE_TENSOR_MAX =

553  3,

554  MIOPEN_REDUCE_TENSOR_AMAX =

555  4,

556  MIOPEN_REDUCE_TENSOR_AVG =

557  5,

558  MIOPEN_REDUCE_TENSOR_NORM1 =

559  6,

560  MIOPEN_REDUCE_TENSOR_NORM2 = 7,

562  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =

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

564 } miopenReduceTensorOp_t;

565 

570 typedef enum

571 {

572  MIOPEN_NOT_PROPAGATE_NAN = 0,

573  MIOPEN_PROPAGATE_NAN = 1,

574 } miopenNanPropagation_t;

575 

580 typedef enum

581 {

582  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,

583  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,

584 } miopenReduceTensorIndices_t;

585 

590 typedef enum

591 {

592  MIOPEN_32BIT_INDICES = 0,

593  MIOPEN_64BIT_INDICES = 1,

594  MIOPEN_16BIT_INDICES = 2,

595  MIOPEN_8BIT_INDICES = 3,

596 } miopenIndicesType_t;

597 

602 typedef enum

603 {

604  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =

605  0,

608  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =

609  1,

611 #ifdef MIOPEN_BETA_API

612  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =

613  2,

617 #else

618 // miopenReserved1 = 2,

619 #endif

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

621  MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE =

622  3,

623 } miopenConvolutionAttrib_t;

624 

631 typedef enum

632 {

633  miopenConvolutionFindModeNormal =

634  1,

635  miopenConvolutionFindModeFast =

636  2,

639  miopenConvolutionFindModeHybrid =

640  3,

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

644  miopenConvolutionFindModeDynamicHybrid =

645  5,

649  miopenConvolutionFindModeTrustVerify = 6,

650  miopenConvolutionFindModeTrustVerifyFull = 7,

651  miopenConvolutionFindModeDefault =

652  miopenConvolutionFindModeDynamicHybrid

653 } miopenConvolutionFindMode_t;

654 

666 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);

667 

680 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(

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

682 

693 MIOPEN_EXPORT miopenStatus_t

694 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,

695  miopenDataType_t dataType,

696  miopenTensorLayout_t tensorLayout,

697  const int* lens,

698  int num_lens);

718 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,

719  miopenDataType_t dataType,

720  int n,

721  int c,

722  int h,

723  int w,

724  int nStride,

725  int cStride,

726  int hStride,

727  int wStride);

728 

745 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

746  miopenDataType_t* dataType,

747  int* n,

748  int* c,

749  int* h,

750  int* w,

751  int* nStride,

752  int* cStride,

753  int* hStride,

754  int* wStride);

755 

766 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

767  miopenDataType_t dataType,

768  int nbDims,

769  const int* dimsA,

770  const int* stridesA);

771 

772 #ifdef MIOPEN_BETA_API

775 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,

776  miopenDataType_t dataType,

777  int nbDims,

778  const size_t* dimsA,

779  const size_t* stridesA);

780 #endif

781 

782 #ifdef MIOPEN_BETA_API

792 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,

793  miopenDataType_t cast_type);

794 #endif

795 

804 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,

805  int* size);

806 

815 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

816  miopenDataType_t* dataType,

817  int* dimsA,

818  int* stridesA);

819 

825 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);

826 

833 MIOPEN_EXPORT miopenStatus_t

834 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);

835 

841 MIOPEN_EXPORT miopenStatus_t

842 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);

843 

863 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,

864  miopenTensorOp_t tensorOp,

865  const void* alpha1,

866  const miopenTensorDescriptor_t aDesc,

867  const void* A,

868  const void* alpha2,

869  const miopenTensorDescriptor_t bDesc,

870  const void* B,

871  const void* beta,

872  const miopenTensorDescriptor_t cDesc,

873  void* C);

874 

885 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,

886  const miopenTensorDescriptor_t yDesc,

887  void* y,

888  const void* alpha);

889 

900 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,

901  const miopenTensorDescriptor_t yDesc,

902  void* y,

903  const void* alpha);

904 

911 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,

912  size_t* numBytes);

913 

931 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,

932  const void* alpha,

933  const miopenTensorDescriptor_t xDesc,

934  const void* x,

935  const void* beta,

936  const miopenTensorDescriptor_t yDesc,

937  void* y);

938 

940 // CLOSEOUT TENSOR DOXYGEN GROUP

941 

952 MIOPEN_EXPORT miopenStatus_t

953 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);

954 

970 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

971  miopenConvolutionMode_t c_mode,

972  int pad_h,

973  int pad_w,

974  int stride_h,

975  int stride_w,

976  int dilation_h,

977  int dilation_w);

978 

989 MIOPEN_EXPORT miopenStatus_t

990 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

991  int spatialDim,

992  const int* padA,

993  const int* strideA,

994  const int* dilationA,

995  miopenConvolutionMode_t c_mode);

996 

1003 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,

1004  int* spatialDim);

1005 

1021 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

1022  miopenConvolutionMode_t* c_mode,

1023  int* pad_h,

1024  int* pad_w,

1025  int* stride_h,

1026  int* stride_w,

1027  int* dilation_h,

1028  int* dilation_w);

1029 

1041 MIOPEN_EXPORT miopenStatus_t

1042 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1043  int requestedSpatialDim,

1044  int* spatialDim,

1045  int* padA,

1046  int* strideA,

1047  int* dilationA,

1048  miopenConvolutionMode_t* c_mode);

1049 

1056 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1057  int* groupCount);

1058 

1072 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1073  int groupCount);

1074 

1087 MIOPEN_EXPORT miopenStatus_t

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

1089 

1102 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(

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

1104 

1122 MIOPEN_EXPORT miopenStatus_t

1123 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1124  const miopenTensorDescriptor_t inputTensorDesc,

1125  const miopenTensorDescriptor_t filterDesc,

1126  int* n,

1127  int* c,

1128  int* h,

1129  int* w);

1130 

1144 MIOPEN_EXPORT miopenStatus_t

1145 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1146  const miopenTensorDescriptor_t inputTensorDesc,

1147  const miopenTensorDescriptor_t filterDesc,

1148  int* nDim,

1149  int* outputTensorDimA);

1150 

1156 MIOPEN_EXPORT miopenStatus_t

1157 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);

1158 

1165 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1166  const miopenConvolutionAttrib_t attr,

1167  int value);

1168 

1175 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1176  const miopenConvolutionAttrib_t attr,

1177  int* value);

1178 

1192 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,

1193  miopenConvolutionFindMode_t findMode);

1194 

1201 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(

1202  const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);

1203 

1208 typedef enum

1209 {

1210  miopenConvolutionFwdAlgoGEMM = 0,

1211  miopenConvolutionFwdAlgoDirect = 1,

1212  miopenConvolutionFwdAlgoFFT = 2,

1213  miopenConvolutionFwdAlgoWinograd = 3,

1214  miopenConvolutionFwdAlgoImplicitGEMM = 5,

1215 } miopenConvFwdAlgorithm_t;

1216 

1220 typedef enum

1221 {

1222  miopenConvolutionBwdWeightsAlgoGEMM = 0,

1223  miopenConvolutionBwdWeightsAlgoDirect = 1,

1224  miopenConvolutionBwdWeightsAlgoWinograd = 3,

1225  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,

1226 } miopenConvBwdWeightsAlgorithm_t;

1227 

1231 typedef enum

1232 {

1233  miopenConvolutionBwdDataAlgoGEMM = 0,

1234  miopenConvolutionBwdDataAlgoDirect = 1,

1235  miopenConvolutionBwdDataAlgoFFT = 2,

1236  miopenConvolutionBwdDataAlgoWinograd = 3,

1237  miopenTransposeBwdDataAlgoGEMM =

1238  4,

1239  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,

1240 } miopenConvBwdDataAlgorithm_t;

1241 

1245 typedef enum

1246 {

1247  miopenConvolutionAlgoGEMM = 0,

1248  miopenConvolutionAlgoDirect = 1,

1249  miopenConvolutionAlgoFFT = 2,

1250  miopenConvolutionAlgoWinograd = 3,

1251  miopenConvolutionAlgoImplicitGEMM = 5,

1252 } miopenConvAlgorithm_t;

1253 

1260 typedef struct

1261 {

1262  union

1263  {

1264  miopenConvFwdAlgorithm_t fwd_algo;

1265  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;

1267  miopenConvBwdDataAlgorithm_t

1268  bwd_data_algo;

1269  };

1270 

1271  float time;

1272  size_t memory;

1274 } miopenConvAlgoPerf_t;

1275 

1284 typedef struct

1285 {

1286  float time;

1289  size_t workspace_size;

1291  uint64_t solution_id;

1292  miopenConvAlgorithm_t algorithm;

1294 } miopenConvSolution_t;

1295 

1311 MIOPEN_EXPORT miopenStatus_t

1312 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,

1313  const miopenTensorDescriptor_t wDesc,

1314  const miopenTensorDescriptor_t xDesc,

1315  const miopenConvolutionDescriptor_t convDesc,

1316  const miopenTensorDescriptor_t yDesc,

1317  size_t* solutionCount);

1318 

1342 MIOPEN_EXPORT miopenStatus_t

1343 miopenConvolutionForwardGetSolution(miopenHandle_t handle,

1344  const miopenTensorDescriptor_t wDesc,

1345  const miopenTensorDescriptor_t xDesc,

1346  const miopenConvolutionDescriptor_t convDesc,

1347  const miopenTensorDescriptor_t yDesc,

1348  const size_t maxSolutionCount,

1349  size_t* solutionCount,

1350  miopenConvSolution_t* solutions);

1351 

1369 MIOPEN_EXPORT miopenStatus_t

1370 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,

1371  const miopenTensorDescriptor_t wDesc,

1372  const miopenTensorDescriptor_t xDesc,

1373  const miopenConvolutionDescriptor_t convDesc,

1374  const miopenTensorDescriptor_t yDesc,

1375  const uint64_t solution_id,

1376  size_t* workSpaceSize);

1377 

1395 MIOPEN_EXPORT miopenStatus_t

1396 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,

1397  const miopenTensorDescriptor_t wDesc,

1398  const miopenTensorDescriptor_t xDesc,

1399  const miopenConvolutionDescriptor_t convDesc,

1400  const miopenTensorDescriptor_t yDesc,

1401  const uint64_t solution_id);

1402 

1420 MIOPEN_EXPORT miopenStatus_t

1421 miopenConvolutionForwardImmediate(miopenHandle_t handle,

1422  const miopenTensorDescriptor_t wDesc,

1423  const void* w,

1424  const miopenTensorDescriptor_t xDesc,

1425  const void* x,

1426  const miopenConvolutionDescriptor_t convDesc,

1427  const miopenTensorDescriptor_t yDesc,

1428  void* y,

1429  void* workSpace,

1430  size_t workSpaceSize,

1431  const uint64_t solution_id);

1432 

1450 MIOPEN_EXPORT miopenStatus_t

1451 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,

1452  const miopenTensorDescriptor_t dyDesc,

1453  const miopenTensorDescriptor_t wDesc,

1454  const miopenConvolutionDescriptor_t convDesc,

1455  const miopenTensorDescriptor_t dxDesc,

1456  size_t* solutionCount);

1457 

1482 MIOPEN_EXPORT miopenStatus_t

1483 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,

1484  const miopenTensorDescriptor_t dyDesc,

1485  const miopenTensorDescriptor_t wDesc,

1486  const miopenConvolutionDescriptor_t convDesc,

1487  const miopenTensorDescriptor_t dxDesc,

1488  const size_t maxSolutionCount,

1489  size_t* solutionCount,

1490  miopenConvSolution_t* solutions);

1491 

1509 MIOPEN_EXPORT miopenStatus_t

1510 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,

1511  const miopenTensorDescriptor_t dyDesc,

1512  const miopenTensorDescriptor_t wDesc,

1513  const miopenConvolutionDescriptor_t convDesc,

1514  const miopenTensorDescriptor_t dxDesc,

1515  const uint64_t solution_id,

1516  size_t* workSpaceSize);

1517 

1536 MIOPEN_EXPORT miopenStatus_t

1537 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,

1538  const miopenTensorDescriptor_t dyDesc,

1539  const miopenTensorDescriptor_t wDesc,

1540  const miopenConvolutionDescriptor_t convDesc,

1541  const miopenTensorDescriptor_t dxDesc,

1542  const uint64_t solution_id);

1543 

1561 MIOPEN_EXPORT miopenStatus_t

1562 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,

1563  const miopenTensorDescriptor_t dyDesc,

1564  const void* dy,

1565  const miopenTensorDescriptor_t wDesc,

1566  const void* w,

1567  const miopenConvolutionDescriptor_t convDesc,

1568  const miopenTensorDescriptor_t dxDesc,

1569  void* dx,

1570  void* workSpace,

1571  size_t workSpaceSize,

1572  const uint64_t solution_id);

1573 

1591 MIOPEN_EXPORT miopenStatus_t

1592 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,

1593  const miopenTensorDescriptor_t dyDesc,

1594  const miopenTensorDescriptor_t xDesc,

1595  const miopenConvolutionDescriptor_t convDesc,

1596  const miopenTensorDescriptor_t dwDesc,

1597  size_t* solutionCount);

1598 

1622 MIOPEN_EXPORT miopenStatus_t

1623 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,

1624  const miopenTensorDescriptor_t dyDesc,

1625  const miopenTensorDescriptor_t xDesc,

1626  const miopenConvolutionDescriptor_t convDesc,

1627  const miopenTensorDescriptor_t dwDesc,

1628  const size_t maxSolutionCount,

1629  size_t* solutionCount,

1630  miopenConvSolution_t* solutions);

1631 

1649 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(

1650  miopenHandle_t handle,

1651  const miopenTensorDescriptor_t dyDesc,

1652  const miopenTensorDescriptor_t xDesc,

1653  const miopenConvolutionDescriptor_t convDesc,

1654  const miopenTensorDescriptor_t dwDesc,

1655  const uint64_t solution_id,

1656  size_t* workSpaceSize);

1657 

1675 MIOPEN_EXPORT miopenStatus_t

1676 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,

1677  const miopenTensorDescriptor_t dyDesc,

1678  const miopenTensorDescriptor_t xDesc,

1679  const miopenConvolutionDescriptor_t convDesc,

1680  const miopenTensorDescriptor_t dwDesc,

1681  const uint64_t solution_id);

1682 

1701 MIOPEN_EXPORT miopenStatus_t

1702 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,

1703  const miopenTensorDescriptor_t dyDesc,

1704  const void* dy,

1705  const miopenTensorDescriptor_t xDesc,

1706  const void* x,

1707  const miopenConvolutionDescriptor_t convDesc,

1708  const miopenTensorDescriptor_t dwDesc,

1709  void* dw,

1710  void* workSpace,

1711  size_t workSpaceSize,

1712  const uint64_t solution_id);

1713 

1740 MIOPEN_EXPORT miopenStatus_t

1741 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,

1742  const miopenTensorDescriptor_t wDesc,

1743  const miopenTensorDescriptor_t xDesc,

1744  const miopenConvolutionDescriptor_t convDesc,

1745  const miopenTensorDescriptor_t yDesc,

1746  size_t* workSpaceSize);

1747 

1791 MIOPEN_EXPORT miopenStatus_t

1792 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,

1793  const miopenTensorDescriptor_t xDesc,

1794  const void* x,

1795  const miopenTensorDescriptor_t wDesc,

1796  const void* w,

1797  const miopenConvolutionDescriptor_t convDesc,

1798  const miopenTensorDescriptor_t yDesc,

1799  void* y,

1800  const int requestAlgoCount,

1801  int* returnedAlgoCount,

1802  miopenConvAlgoPerf_t* perfResults,

1803  void* workSpace,

1804  size_t workSpaceSize,

1805  bool exhaustiveSearch);

1806 

1841 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,

1842  const void* alpha,

1843  const miopenTensorDescriptor_t xDesc,

1844  const void* x,

1845  const miopenTensorDescriptor_t wDesc,

1846  const void* w,

1847  const miopenConvolutionDescriptor_t convDesc,

1848  miopenConvFwdAlgorithm_t algo,

1849  const void* beta,

1850  const miopenTensorDescriptor_t yDesc,

1851  void* y,

1852  void* workSpace,

1853  size_t workSpaceSize);

1854 

1870 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,

1871  const void* alpha,

1872  const miopenTensorDescriptor_t bDesc,

1873  const void* b,

1874  const void* beta,

1875  const miopenTensorDescriptor_t yDesc,

1876  void* y);

1877 

1905 MIOPEN_EXPORT miopenStatus_t

1906 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,

1907  const miopenTensorDescriptor_t dyDesc,

1908  const miopenTensorDescriptor_t wDesc,

1909  const miopenConvolutionDescriptor_t convDesc,

1910  const miopenTensorDescriptor_t dxDesc,

1911  size_t* workSpaceSize);

1912 

1956 MIOPEN_EXPORT miopenStatus_t

1957 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,

1958  const miopenTensorDescriptor_t dyDesc,

1959  const void* dy,

1960  const miopenTensorDescriptor_t wDesc,

1961  const void* w,

1962  const miopenConvolutionDescriptor_t convDesc,

1963  const miopenTensorDescriptor_t dxDesc,

1964  void* dx,

1965  const int requestAlgoCount,

1966  int* returnedAlgoCount,

1967  miopenConvAlgoPerf_t* perfResults,

1968  void* workSpace,

1969  size_t workSpaceSize,

1970  bool exhaustiveSearch);

1971 

2005 MIOPEN_EXPORT miopenStatus_t

2006 miopenConvolutionBackwardData(miopenHandle_t handle,

2007  const void* alpha,

2008  const miopenTensorDescriptor_t dyDesc,

2009  const void* dy,

2010  const miopenTensorDescriptor_t wDesc,

2011  const void* w,

2012  const miopenConvolutionDescriptor_t convDesc,

2013  miopenConvBwdDataAlgorithm_t algo,

2014  const void* beta,

2015  const miopenTensorDescriptor_t dxDesc,

2016  void* dx,

2017  void* workSpace,

2018  size_t workSpaceSize);

2019 

2047 MIOPEN_EXPORT miopenStatus_t

2048 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,

2049  const miopenTensorDescriptor_t dyDesc,

2050  const miopenTensorDescriptor_t xDesc,

2051  const miopenConvolutionDescriptor_t convDesc,

2052  const miopenTensorDescriptor_t dwDesc,

2053  size_t* workSpaceSize);

2054 

2098 MIOPEN_EXPORT miopenStatus_t

2099 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,

2100  const miopenTensorDescriptor_t dyDesc,

2101  const void* dy,

2102  const miopenTensorDescriptor_t xDesc,

2103  const void* x,

2104  const miopenConvolutionDescriptor_t convDesc,

2105  const miopenTensorDescriptor_t dwDesc,

2106  void* dw,

2107  const int requestAlgoCount,

2108  int* returnedAlgoCount,

2109  miopenConvAlgoPerf_t* perfResults,

2110  void* workSpace,

2111  size_t workSpaceSize,

2112  bool exhaustiveSearch);

2113 

2147 MIOPEN_EXPORT miopenStatus_t

2148 miopenConvolutionBackwardWeights(miopenHandle_t handle,

2149  const void* alpha,

2150  const miopenTensorDescriptor_t dyDesc,

2151  const void* dy,

2152  const miopenTensorDescriptor_t xDesc,

2153  const void* x,

2154  const miopenConvolutionDescriptor_t convDesc,

2155  miopenConvBwdWeightsAlgorithm_t algo,

2156  const void* beta,

2157  const miopenTensorDescriptor_t dwDesc,

2158  void* dw,

2159  void* workSpace,

2160  size_t workSpaceSize);

2161 

2180 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,

2181  const void* alpha,

2182  const miopenTensorDescriptor_t dyDesc,

2183  const void* dy,

2184  const void* beta,

2185  const miopenTensorDescriptor_t dbDesc,

2186  void* db);

2187 

2189 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP

2190 

2191 // Pooling APIs

2202 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);

2203 

2212 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2213  miopenIndexType_t index_type);

2214 

2222 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2223  miopenIndexType_t* index_type);

2224 

2232 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(

2233  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);

2234 

2241 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(

2242  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);

2243 

2258 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2259  miopenPoolingMode_t mode,

2260  int windowHeight,

2261  int windowWidth,

2262  int pad_h,

2263  int pad_w,

2264  int stride_h,

2265  int stride_w);

2266 

2281 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2282  miopenPoolingMode_t* mode,

2283  int* windowHeight,

2284  int* windowWidth,

2285  int* pad_h,

2286  int* pad_w,

2287  int* stride_h,

2288  int* stride_w);

2289 

2304 MIOPEN_EXPORT miopenStatus_t

2305 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2306  const miopenTensorDescriptor_t tensorDesc,

2307  int* n,

2308  int* c,

2309  int* h,

2310  int* w);

2311 

2327 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2328  const miopenPoolingMode_t mode,

2329  int nbDims,

2330  const int* windowDimA,

2331  const int* padA,

2332  const int* stridesA);

2333 

2350 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2351  int nbDimsRequested,

2352  miopenPoolingMode_t* mode,

2353  int* nbDims,

2354  int* windowDimA,

2355  int* padA,

2356  int* stridesA);

2357 

2370 MIOPEN_EXPORT miopenStatus_t

2371 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2372  const miopenTensorDescriptor_t tensorDesc,

2373  int dims,

2374  int* tensorDimArr);

2375 

2388 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2389  size_t* workSpaceSize);

2390 

2403 MIOPEN_EXPORT miopenStatus_t

2404 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,

2405  const miopenTensorDescriptor_t yDesc,

2406  size_t* workSpaceSize);

2407 

2428 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,

2429  const miopenPoolingDescriptor_t poolDesc,

2430  const void* alpha,

2431  const miopenTensorDescriptor_t xDesc,

2432  const void* x,

2433  const void* beta,

2434  const miopenTensorDescriptor_t yDesc,

2435  void* y,

2436  bool do_backward,

2437  void* workSpace,

2438  size_t workSpaceSize);

2439 

2460 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,

2461  const miopenPoolingDescriptor_t poolDesc,

2462  const void* alpha,

2463  const miopenTensorDescriptor_t yDesc,

2464  const void* y,

2465  const miopenTensorDescriptor_t dyDesc,

2466  const void* dy,

2467  const miopenTensorDescriptor_t xDesc,

2468  const void* x,

2469  const void* beta,

2470  const miopenTensorDescriptor_t dxDesc,

2471  void* dx,

2472  void* workSpace);

2473 

2479 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);

2480 

2482 // CLOSEOUT POOLING DOXYGEN GROUP

2483 

2484 // LRN APIs

2494 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);

2495 

2509 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2510  miopenLRNMode_t mode,

2511  unsigned int lrnN,

2512  double lrnAlpha,

2513  double lrnBeta,

2514  double lrnK);

2515 

2528 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2529  miopenLRNMode_t* mode,

2530  unsigned int* lrnN,

2531  double* lrnAlpha,

2532  double* lrnBeta,

2533  double* lrnK);

2534 

2544 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2545  size_t* workSpaceSize);

2546 

2565 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,

2566  const miopenLRNDescriptor_t lrnDesc,

2567  const void* alpha,

2568  const miopenTensorDescriptor_t xDesc,

2569  const void* x,

2570  const void* beta,

2571  const miopenTensorDescriptor_t yDesc,

2572  void* y,

2573  bool do_backward,

2574  void* workSpace);

2575 

2593 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,

2594  const miopenLRNDescriptor_t lrnDesc,

2595  const void* alpha,

2596  const miopenTensorDescriptor_t yDesc,

2597  const void* y,

2598  const miopenTensorDescriptor_t dyDesc,

2599  const void* dy,

2600  const miopenTensorDescriptor_t xDesc,

2601  const void* x,

2602  const void* beta,

2603  const miopenTensorDescriptor_t dxDesc,

2604  void* dx,

2605  const void* workSpace);

2606 

2612 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);

2613 

2615 // CLOSEOUT LRN DOXYGEN GROUP

2616 

2617 #ifdef MIOPEN_BETA_API

2618 // LayerNorm APIs

2643 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,

2644  miopenNormMode_t mode,

2645  const miopenTensorDescriptor_t xDesc,

2646  const void* x,

2647  const miopenTensorDescriptor_t weightDesc,

2648  const void* weight,

2649  const miopenTensorDescriptor_t biasDesc,

2650  const void* bias,

2651  const float epsilon,

2652  const int32_t normalized_dim,

2653  const miopenTensorDescriptor_t yDesc,

2654  void* y,

2655  const miopenTensorDescriptor_t meanDesc,

2656  void* mean,

2657  const miopenTensorDescriptor_t rstdDesc,

2658  void* rstd);

2659 

2677 MIOPEN_EXPORT miopenStatus_t

2678 miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle,

2679  miopenNormMode_t mode,

2680  const miopenTensorDescriptor_t dyDesc,

2681  const miopenTensorDescriptor_t xDesc,

2682  const miopenTensorDescriptor_t weightDesc,

2683  const miopenTensorDescriptor_t meanDesc,

2684  const miopenTensorDescriptor_t rstdDesc,

2685  const int32_t normalized_dim,

2686  const miopenTensorDescriptor_t dxDesc,

2687  const miopenTensorDescriptor_t dwDesc,

2688  const miopenTensorDescriptor_t dbDesc,

2689  size_t* sizeInBytes);

2690 

2716 MIOPEN_EXPORT miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle,

2717  miopenNormMode_t mode,

2718  void* workspace,

2719  size_t workspaceSizeInBytes,

2720  const miopenTensorDescriptor_t dyDesc,

2721  const void* dy,

2722  const miopenTensorDescriptor_t xDesc,

2723  const void* x,

2724  const miopenTensorDescriptor_t weightDesc,

2725  const void* weight,

2726  const miopenTensorDescriptor_t meanDesc,

2727  const void* mean,

2728  const miopenTensorDescriptor_t rstdDesc,

2729  const void* rstd,

2730  const int32_t normalized_dim,

2731  const miopenTensorDescriptor_t dxDesc,

2732  void* dx,

2733  const miopenTensorDescriptor_t dwDesc,

2734  void* dw,

2735  const miopenTensorDescriptor_t dbDesc,

2736  void* db);

2737 

2739 // CLOSEOUT LAYERNORM DOXYGEN GROUP

2740 #endif

2741 

2742 #ifdef MIOPEN_BETA_API

2743 // Cat APIs

2759 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,

2760  const int32_t xCount,

2761  const miopenTensorDescriptor_t* xDescs,

2762  const void* const* xs,

2763  const miopenTensorDescriptor_t yDesc,

2764  void* y,

2765  const int32_t dim);

2766 

2768 // CLOSEOUT CAT DOXYGEN GROUP

2769 #endif

2770 

2771 // Batch-Normalization APIs

2793 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,

2794  const miopenTensorDescriptor_t xDesc,

2795  miopenBatchNormMode_t bn_mode);

2796 

2835 MIOPEN_EXPORT miopenStatus_t

2836 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,

2837  miopenBatchNormMode_t bn_mode,

2838  void* alpha,

2839  void* beta,

2840  const miopenTensorDescriptor_t xDesc,

2841  const void* x,

2842  const miopenTensorDescriptor_t yDesc,

2843  void* y,

2844  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

2845  void* bnScale,

2846  void* bnBias,

2847  double expAvgFactor,

2848  void* resultRunningMean,

2849  void* resultRunningVariance,

2850  double epsilon,

2851  void* resultSaveMean,

2852  void* resultSaveInvVariance);

2893 MIOPEN_EXPORT miopenStatus_t

2894 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,

2895  miopenBatchNormMode_t bn_mode,

2896  void* alpha,

2897  void* beta,

2898  const miopenTensorDescriptor_t xDesc,

2899  const void* x,

2900  const miopenTensorDescriptor_t yDesc,

2901  void* y,

2902  const miopenTensorDescriptor_t scaleDesc,

2903  const miopenTensorDescriptor_t biasVarDesc,

2904  const miopenTensorDescriptor_t savedMeanDesc,

2905  const miopenTensorDescriptor_t savedVarDesc,

2906  void* bnScale,

2907  void* bnBias,

2908  double expAvgFactor,

2909  void* resultRunningMean,

2910  void* resultRunningVariance,

2911  double epsilon,

2912  void* resultSaveMean,

2913  void* resultSaveInvVariance);

2956 MIOPEN_EXPORT miopenStatus_t

2957 miopenBatchNormalizationForwardTraining_V3(miopenHandle_t handle,

2958  miopenBatchNormMode_t bn_mode,

2959  void* alpha,

2960  void* beta,

2961  const miopenTensorDescriptor_t xDesc,

2962  const void* x,

2963  const miopenTensorDescriptor_t yDesc,

2964  void* y,

2965  const miopenTensorDescriptor_t scaleDesc,

2966  const miopenTensorDescriptor_t biasVarDesc,

2967  const miopenTensorDescriptor_t savedMeanDesc,

2968  const miopenTensorDescriptor_t savedVarDesc,

2969  void* bnScale,

2970  void* bnBias,

2971  double expAvgFactor,

2972  const void* prevResultRunningMean,

2973  const void* prevResultRunningVariance,

2974  void* nextResultRunningMean,

2975  void* nextResultRunningVariance,

2976  double epsilon,

2977  void* resultSaveMean,

2978  void* resultSaveInvVariance);

3020 MIOPEN_EXPORT miopenStatus_t

3021 miopenBatchNormForwardTrainingActivation(miopenHandle_t handle,

3022  miopenBatchNormMode_t bn_mode,

3023  void* alpha,

3024  void* beta,

3025  const miopenTensorDescriptor_t xDesc,

3026  const void* x,

3027  const miopenTensorDescriptor_t yDesc,

3028  void* y,

3029  const miopenTensorDescriptor_t scaleDesc,

3030  const miopenTensorDescriptor_t biasVarDesc,

3031  const miopenTensorDescriptor_t savedMeanDesc,

3032  const miopenTensorDescriptor_t savedVarDesc,

3033  void* bnScale,

3034  void* bnBias,

3035  double expAvgFactor,

3036  void* resultRunningMean,

3037  void* resultRunningVariance,

3038  double epsilon,

3039  void* resultSaveMean,

3040  void* resultSaveInvVariance,

3041  const miopenActivationDescriptor_t activDesc);

3042 

3086 MIOPEN_EXPORT miopenStatus_t

3087 miopenBatchNormForwardTrainingActivation_V2(miopenHandle_t handle,

3088  miopenBatchNormMode_t bn_mode,

3089  void* alpha,

3090  void* beta,

3091  const miopenTensorDescriptor_t xDesc,

3092  const void* x,

3093  const miopenTensorDescriptor_t yDesc,

3094  void* y,

3095  const miopenTensorDescriptor_t scaleDesc,

3096  const miopenTensorDescriptor_t biasVarDesc,

3097  const miopenTensorDescriptor_t savedMeanDesc,

3098  const miopenTensorDescriptor_t savedVarDesc,

3099  void* bnScale,

3100  void* bnBias,

3101  double expAvgFactor,

3102  const void* prevResultRunningMean,

3103  const void* prevResultRunningVariance,

3104  void* nextResultRunningMean,

3105  void* nextResultRunningVariance,

3106  double epsilon,

3107  void* resultSaveMean,

3108  void* resultSaveInvVariance,

3109  const miopenActivationDescriptor_t activDesc);

3110 

3140 MIOPEN_EXPORT miopenStatus_t

3141 miopenBatchNormalizationForwardInference(miopenHandle_t handle,

3142  miopenBatchNormMode_t bn_mode,

3143  void* alpha,

3144  void* beta,

3145  const miopenTensorDescriptor_t xDesc,

3146  const void* x,

3147  const miopenTensorDescriptor_t yDesc,

3148  void* y,

3149  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

3150  void* bnScale,

3151  void* bnBias,

3152  void* estimatedMean,

3153  void* estimatedVariance,

3154  double epsilon);

3155 

3187 MIOPEN_EXPORT miopenStatus_t

3188 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,

3189  miopenBatchNormMode_t bn_mode,

3190  void* alpha,

3191  void* beta,

3192  const miopenTensorDescriptor_t xDesc,

3193  const void* x,

3194  const miopenTensorDescriptor_t yDesc,

3195  void* y,

3196  const miopenTensorDescriptor_t scaleDesc,

3197  const miopenTensorDescriptor_t biasDesc,

3198  const miopenTensorDescriptor_t estMeanDesc,

3199  const miopenTensorDescriptor_t estVarianceDesc,

3200  void* bnScale,

3201  void* bnBias,

3202  void* estimatedMean,

3203  void* estimatedVariance,

3204  double epsilon);

3205 

3234 MIOPEN_EXPORT miopenStatus_t miopenBatchNormalizationForwardInferenceInvVariance(

3235  miopenHandle_t handle,

3236  miopenBatchNormMode_t bn_mode,

3237  void* alpha,

3238  void* beta,

3239  const miopenTensorDescriptor_t xDesc,

3240  const void* x,

3241  const miopenTensorDescriptor_t yDesc,

3242  void* y,

3243  const miopenTensorDescriptor_t scaleDesc,

3244  const miopenTensorDescriptor_t biasDesc,

3245  const miopenTensorDescriptor_t estMeanDesc,

3246  const miopenTensorDescriptor_t estInvVarianceDesc,

3247  void* bnScale,

3248  void* bnBias,

3249  void* estimatedMean,

3250  void* estimatedInvVariance);

3251 

3282 MIOPEN_EXPORT miopenStatus_t miopenBatchNormForwardInferenceActivationInvVariance(

3283  miopenHandle_t handle,

3284  miopenBatchNormMode_t bn_mode,

3285  void* alpha,

3286  void* beta,

3287  const miopenTensorDescriptor_t xDesc,

3288  const void* x,

3289  const miopenTensorDescriptor_t yDesc,

3290  void* y,

3291  const miopenTensorDescriptor_t scaleDesc,

3292  const miopenTensorDescriptor_t biasDesc,

3293  const miopenTensorDescriptor_t estMeanDesc,

3294  const miopenTensorDescriptor_t estInvVarianceDesc,

3295  void* bnScale,

3296  void* bnBias,

3297  void* estimatedMean,

3298  void* estimatedInvVariance,

3299  const miopenActivationDescriptor_t activDesc);

3300 

3333 MIOPEN_EXPORT miopenStatus_t

3334 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,

3335  miopenBatchNormMode_t bn_mode,

3336  void* alpha,

3337  void* beta,

3338  const miopenTensorDescriptor_t xDesc,

3339  const void* x,

3340  const miopenTensorDescriptor_t yDesc,

3341  void* y,

3342  const miopenTensorDescriptor_t scaleDesc,

3343  const miopenTensorDescriptor_t biasDesc,

3344  const miopenTensorDescriptor_t estMeanDesc,

3345  const miopenTensorDescriptor_t estVarianceDesc,

3346  void* bnScale,

3347  void* bnBias,

3348  void* estimatedMean,

3349  void* estimatedVariance,

3350  double epsilon,

3351  const miopenActivationDescriptor_t activDesc);

3352 

3387 MIOPEN_EXPORT miopenStatus_t

3388 miopenBatchNormalizationBackward(miopenHandle_t handle,

3389  miopenBatchNormMode_t bn_mode,

3390  const void* alphaDataDiff,

3391  const void* betaDataDiff,

3392  const void* alphaParamDiff,

3393  const void* betaParamDiff,

3394  const miopenTensorDescriptor_t xDesc,

3395  const void* x,

3396  const miopenTensorDescriptor_t dyDesc,

3397  const void* dy,

3398  const miopenTensorDescriptor_t dxDesc,

3399  void* dx,

3400  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,

3401  const void* bnScale,

3402  void* resultBnScaleDiff,

3403  void* resultBnBiasDiff,

3404  double epsilon,

3405  const void* savedMean,

3406  const void* savedInvVariance);

3407 

3446 MIOPEN_EXPORT miopenStatus_t

3447 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,

3448  miopenBatchNormMode_t bn_mode,

3449  const void* alphaDataDiff,

3450  const void* betaDataDiff,

3451  const void* alphaParamDiff,

3452  const void* betaParamDiff,

3453  const miopenTensorDescriptor_t xDesc,

3454  const void* x,

3455  const miopenTensorDescriptor_t dyDesc,

3456  const void* dy,

3457  const miopenTensorDescriptor_t dxDesc,

3458  void* dx,

3459  const miopenTensorDescriptor_t scaleDesc,

3460  const miopenTensorDescriptor_t biasDesc,

3461  const miopenTensorDescriptor_t savedMeanDesc,

3462  const miopenTensorDescriptor_t savedVarDesc,

3463  const void* bnScale,

3464  void* resultBnScaleDiff,

3465  void* resultBnBiasDiff,

3466  double epsilon,

3467  const void* savedMean,

3468  const void* savedInvVariance);

3469 

3510 MIOPEN_EXPORT miopenStatus_t

3511 miopenBatchNormBackwardActivation(miopenHandle_t handle,

3512  miopenBatchNormMode_t bn_mode,

3513  const void* alphaDataDiff,

3514  const void* betaDataDiff,

3515  const void* alphaParamDiff,

3516  const void* betaParamDiff,

3517  const miopenTensorDescriptor_t xDesc,

3518  const void* x,

3519  const miopenTensorDescriptor_t dyDesc,

3520  const void* dy,

3521  const miopenTensorDescriptor_t dxDesc,

3522  void* dx,

3523  const miopenTensorDescriptor_t scaleDesc,

3524  const miopenTensorDescriptor_t biasDesc,

3525  const miopenTensorDescriptor_t savedMeanDesc,

3526  const miopenTensorDescriptor_t savedVarianceDesc,

3527  const void* bnScale,

3528  const void* bnBias,

3529  void* resultBnScaleDiff,

3530  void* resultBnBiasDiff,

3531  double epsilon,

3532  const void* savedMean,

3533  const void* savedInvVariance,

3534  const miopenActivationDescriptor_t activDesc);

3536 // CLOSEOUT BATCHNORM DOXYGEN GROUP

3537 

3538 // Activation APIs

3548 MIOPEN_EXPORT miopenStatus_t

3549 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);

3550 

3562 MIOPEN_EXPORT miopenStatus_t

3563 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3564  miopenActivationMode_t mode,

3565  double activAlpha,

3566  double activBeta,

3567  double activGamma);

3568 

3580 MIOPEN_EXPORT miopenStatus_t

3581 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3582  miopenActivationMode_t* mode,

3583  double* activAlpha,

3584  double* activBeta,

3585  double* activGamma);

3586 

3599 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,

3600  const miopenActivationDescriptor_t activDesc,

3601  const void* alpha,

3602  const miopenTensorDescriptor_t xDesc,

3603  const void* x,

3604  const void* beta,

3605  const miopenTensorDescriptor_t yDesc,

3606  void* y);

3607 

3624 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,

3625  const miopenActivationDescriptor_t activDesc,

3626  const void* alpha,

3627  const miopenTensorDescriptor_t yDesc,

3628  const void* y,

3629  const miopenTensorDescriptor_t dyDesc,

3630  const void* dy,

3631  const miopenTensorDescriptor_t xDesc,

3632  const void* x,

3633  const void* beta,

3634  const miopenTensorDescriptor_t dxDesc,

3635  void* dx);

3636 

3642 MIOPEN_EXPORT miopenStatus_t

3643 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);

3644 

3646 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3647 

3648 #ifdef MIOPEN_BETA_API

3664 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,

3665  const miopenTensorDescriptor_t inputDesc,

3666  const void* input,

3667  const miopenTensorDescriptor_t outputDesc,

3668  void* output,

3669  const uint32_t dim);

3670 

3683 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,

3684  const miopenTensorDescriptor_t inputDesc,

3685  const void* input,

3686  const miopenTensorDescriptor_t outputGradDesc,

3687  const void* outputGrad,

3688  const miopenTensorDescriptor_t inputGradDesc,

3689  void* inputGrad,

3690  const uint32_t dim);

3691 

3693 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3694 #endif // MIOPEN_BETA_API

3695 

3696 // Softmax APIs

3714 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,

3715  const void* alpha,

3716  const miopenTensorDescriptor_t xDesc,

3717  const void* x,

3718  const void* beta,

3719  const miopenTensorDescriptor_t yDesc,

3720  void* y);

3721 

3737 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,

3738  const void* alpha,

3739  const miopenTensorDescriptor_t yDesc,

3740  const void* y,

3741  const miopenTensorDescriptor_t dyDesc,

3742  const void* dy,

3743  const void* beta,

3744  const miopenTensorDescriptor_t dxDesc,

3745  void* dx);

3746 

3760 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,

3761  const void* alpha,

3762  const miopenTensorDescriptor_t xDesc,

3763  const void* x,

3764  const void* beta,

3765  const miopenTensorDescriptor_t yDesc,

3766  void* y,

3767  miopenSoftmaxAlgorithm_t algorithm,

3768  miopenSoftmaxMode_t mode);

3769 

3785 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,

3786  const void* alpha,

3787  const miopenTensorDescriptor_t yDesc,

3788  const void* y,

3789  const miopenTensorDescriptor_t dyDesc,

3790  const void* dy,

3791  const void* beta,

3792  const miopenTensorDescriptor_t dxDesc,

3793  void* dx,

3794  miopenSoftmaxAlgorithm_t algorithm,

3795  miopenSoftmaxMode_t mode);

3796 

3798 // CLOSEOUT SOFTMAX DOXYGEN GROUP

3799 

3803 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);

3804 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);

3805 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);

3806 

3815 typedef enum

3816 {

3817  miopenVerticalFusion = 0,

3818  miopenHorizontalFusion = 1,

3819 } miopenFusionDirection_t;

3820 

3828 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,

3829  const miopenFusionDirection_t fuseDirection,

3830  const miopenTensorDescriptor_t inputDesc);

3831 

3837 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);

3838 

3845 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,

3846  miopenFusionPlanDescriptor_t fusePlanDesc);

3847 

3858 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,

3859  const int op_idx,

3860  miopenFusionOpDescriptor_t* op);

3861 

3869 MIOPEN_EXPORT miopenStatus_t

3870 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,

3871  miopenFusionPlanDescriptor_t fusePlanDesc,

3872  size_t* workSpaceSize,

3873  miopenConvFwdAlgorithm_t algo);

3874 

3892 MIOPEN_EXPORT miopenStatus_t

3893 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,

3894  const int requestAlgoCount,

3895  int* returnedAlgoCount,

3896  miopenConvFwdAlgorithm_t* returnedAlgos);

3897 

3907 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(

3908  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);

3909 

3918 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3919  miopenFusionOpDescriptor_t* convOp,

3920  miopenConvolutionDescriptor_t convDesc,

3921  const miopenTensorDescriptor_t wDesc);

3922 

3923 //---

3924 

3925 // Activation forward create ops ---

3933 MIOPEN_EXPORT miopenStatus_t

3934 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3935  miopenFusionOpDescriptor_t* activFwdOp,

3936  miopenActivationMode_t mode);

3937 

3938 // Activation backward create ops ---

3946 MIOPEN_EXPORT miopenStatus_t

3947 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3948  miopenFusionOpDescriptor_t* activBwdOp,

3949  miopenActivationMode_t mode);

3950 

3951 // Bias create ops ---

3959 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3960  miopenFusionOpDescriptor_t* biasOp,

3961  const miopenTensorDescriptor_t bDesc);

3962 

3963 // Batch normalization create ops ---

3972 MIOPEN_EXPORT miopenStatus_t

3973 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,

3974  miopenFusionOpDescriptor_t* bnOp,

3975  const miopenBatchNormMode_t bn_mode,

3976  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);

3977 

3987 MIOPEN_EXPORT miopenStatus_t

3988 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3989  miopenFusionOpDescriptor_t* bnFwdOp,

3990  const miopenBatchNormMode_t bn_mode,

3991  bool runningMeanVariance);

3992 

4000 MIOPEN_EXPORT miopenStatus_t

4001 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

4002  miopenFusionOpDescriptor_t* bnBwdOp,

4003  const miopenBatchNormMode_t bn_mode);

4004 

4005 //---

4011 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);

4012 

4018 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);

4019 

4020 // Convolution set arguments ---

4030 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,

4031  const miopenFusionOpDescriptor_t convOp,

4032  const void* alpha,

4033  const void* beta,

4034  const void* w);

4035 // Activation set arguments ---

4047 MIOPEN_EXPORT miopenStatus_t

4048 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,

4049  const miopenFusionOpDescriptor_t activFwdOp,

4050  const void* alpha,

4051  const void* beta,

4052  double activAlpha,

4053  double activBeta,

4054  double activGamma);

4055 

4069 MIOPEN_EXPORT miopenStatus_t

4070 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,

4071  const miopenFusionOpDescriptor_t activBwdOp,

4072  const void* alpha,

4073  const void* beta,

4074  const void* y,

4075  const void* reserved,

4076  double activAlpha,

4077  double activBeta,

4078  double activGamma);

4079 

4080 // Batch Normalization set arguments ---

4094 MIOPEN_EXPORT miopenStatus_t

4095 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,

4096  const miopenFusionOpDescriptor_t bnOp,

4097  const void* alpha,

4098  const void* beta,

4099  const void* bnScale,

4100  const void* bnBias,

4101  const void* estimatedMean,

4102  const void* estimatedVariance,

4103  double epsilon);

4104 

4121 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,

4122  const miopenFusionOpDescriptor_t bnOp,

4123  const void* alpha,

4124  const void* beta,

4125  const void* bnScale,

4126  const void* bnBias,

4127  void* savedMean,

4128  void* savedInvVariance,

4129  void* runningMean,

4130  void* runningVariance,

4131  double expAvgFactor,

4132  double epsilon);

4133 

4149 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,

4150  const miopenFusionOpDescriptor_t bnOp,

4151  const void* alpha,

4152  const void* beta,

4153  const void* x,

4154  const void* bnScale,

4155  const void* bnBias,

4156  void* resultBnScaleDiff,

4157  void* resultBnBiasDiff,

4158  const void* savedMean,

4159  const void* savedInvVariance);

4160 

4161 // Bias forward set arguments ---

4171 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,

4172  const miopenFusionOpDescriptor_t biasOp,

4173  const void* alpha,

4174  const void* beta,

4175  const void* bias);

4176 

4191 MIOPEN_EXPORT miopenStatus_t

4192 miopenExecuteFusionPlan(const miopenHandle_t handle,

4193  const miopenFusionPlanDescriptor_t fusePlanDesc,

4194  const miopenTensorDescriptor_t inputDesc,

4195  const void* input,

4196  const miopenTensorDescriptor_t outputDesc,

4197  void* output,

4198  miopenOperatorArgs_t args);

4199 

4214 MIOPEN_EXPORT miopenStatus_t

4215 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,

4216  const miopenFusionPlanDescriptor_t fusePlanDesc,

4217  const miopenTensorDescriptor_t inputDesc,

4218  const void* input,

4219  const miopenTensorDescriptor_t outputDesc,

4220  void* output,

4221  miopenOperatorArgs_t args,

4222  void* workspace,

4223  size_t workspaceSize);

4224 

4248 MIOPEN_EXPORT miopenStatus_t

4249 miopenConvolutionBiasActivationForward(miopenHandle_t handle,

4250  const void* alpha1,

4251  const miopenTensorDescriptor_t xDesc,

4252  const void* x,

4253  const miopenTensorDescriptor_t wDesc,

4254  const void* w,

4255  const miopenConvolutionDescriptor_t convDesc,

4256  miopenConvFwdAlgorithm_t algo,

4257  void* workspace,

4258  size_t workspaceSizeInBytes,

4259  const void* alpha2,

4260  const miopenTensorDescriptor_t zDesc,

4261  const void* z,

4262  const miopenTensorDescriptor_t biasDesc,

4263  const void* bias,

4264  const miopenActivationDescriptor_t activationDesc,

4265  const miopenTensorDescriptor_t yDesc,

4266  void* y);

4268 // CLOSEOUT FUSION DOXYGEN GROUP

4269 

4278 typedef enum

4279 {

4280  miopenRNNRELU = 0,

4281  miopenRNNTANH = 1,

4282  miopenLSTM = 2,

4283  miopenGRU = 3,

4284 } miopenRNNMode_t;

4285 

4289 typedef enum

4290 {

4291  miopenRNNlinear = 0,

4292  miopenRNNskip = 1,

4293 } miopenRNNInputMode_t;

4294 

4298 typedef enum

4299 {

4300  miopenRNNdefault = 0,

4302  miopenRNNfundamental = 1,

4304  miopenRNNroundedDynamic = 2,

4306 } miopenRNNAlgo_t;

4307 

4311 typedef enum

4312 {

4313  miopenRNNunidirection = 0,

4314  miopenRNNbidirection = 1,

4315 } miopenRNNDirectionMode_t;

4316 

4320 typedef enum

4321 {

4322  miopenRNNNoBias = 0,

4323  miopenRNNwithBias = 1,

4324 } miopenRNNBiasMode_t;

4325 

4329 typedef enum

4330 {

4331  miopenRNNAlgoGEMM = 0,

4332 } miopenRNNGEMMalgoMode_t;

4333 

4337 typedef enum

4338 {

4339  miopenRNNIONotPadded = 0,

4340  miopenRNNIOWithPadding = 1,

4341 } miopenRNNPaddingMode_t;

4342 

4346 typedef enum

4347 {

4348  miopenRNNTraining = 0,

4349  miopenRNNInference = 1,

4350 } miopenRNNFWDMode_t;

4351 

4355 typedef enum

4356 {

4357  miopenRNNDataUnknownLayout = 0,

4358  miopenRNNDataSeqMajorNotPadded = 1,

4359  miopenRNNDataSeqMajorPadded = 2,

4360  miopenRNNDataBatchMajorPadded = 3,

4361 } miopenRNNBaseLayout_t;

4362 

4369 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);

4370 

4383 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4384  miopenRNNMode_t* rnnMode,

4385  miopenRNNAlgo_t* algoMode,

4386  miopenRNNInputMode_t* inputMode,

4387  miopenRNNDirectionMode_t* dirMode,

4388  miopenRNNBiasMode_t* biasMode,

4389  int* hiddenSize,

4390  int* layer);

4391 

4408 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4409  int* hiddenSize,

4410  int* layer,

4411  miopenDropoutDescriptor_t* dropoutDesc,

4412  miopenRNNInputMode_t* inputMode,

4413  miopenRNNDirectionMode_t* dirMode,

4414  miopenRNNMode_t* rnnMode,

4415  miopenRNNBiasMode_t* biasMode,

4416  miopenRNNAlgo_t* algoMode,

4417  miopenDataType_t* dataType);

4418 

4424 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);

4425 

4441 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4442  const int hsize,

4443  const int nlayers,

4444  miopenRNNInputMode_t inMode,

4445  miopenRNNDirectionMode_t direction,

4446  miopenRNNMode_t rnnMode,

4447  miopenRNNBiasMode_t biasMode,

4448  miopenRNNAlgo_t algo,

4449  miopenDataType_t dataType);

4450 

4469 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4470  const int hsize,

4471  const int nlayers,

4472  miopenDropoutDescriptor_t dropoutDesc,

4473  miopenRNNInputMode_t inMode,

4474  miopenRNNDirectionMode_t direction,

4475  miopenRNNMode_t rnnMode,

4476  miopenRNNBiasMode_t biasMode,

4477  miopenRNNAlgo_t algo,

4478  miopenDataType_t dataType);

4479 

4494 MIOPEN_EXPORT miopenStatus_t

4495 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4496  miopenDataType_t dataType,

4497  miopenRNNBaseLayout_t layout,

4498  int maxSequenceLen,

4499  int batchSize,

4500  int vectorSize,

4501  const int* sequenceLenArray,

4502  void* paddingMarker);

4503 

4522 MIOPEN_EXPORT miopenStatus_t

4523 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4524  miopenDataType_t* dataType,

4525  miopenRNNBaseLayout_t* layout,

4526  int* maxSequenceLen,

4527  int* batchSize,

4528  int* vectorSize,

4529  int sequenceLenArrayLimit,

4530  int* sequenceLenArray,

4531  void* paddingMarker);

4532 

4549 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,

4550  const miopenRNNDescriptor_t rnnDesc,

4551  const int sequenceLen,

4552  const miopenTensorDescriptor_t* xDesc,

4553  size_t* numBytes);

4554 

4571 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,

4572  miopenRNNDescriptor_t rnnDesc,

4573  const int sequenceLen,

4574  const miopenTensorDescriptor_t* xDesc,

4575  size_t* numBytes);

4576 

4593 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,

4594  miopenRNNDescriptor_t rnnDesc,

4595  miopenSeqTensorDescriptor_t xDesc,

4596  miopenRNNFWDMode_t fwdMode,

4597  size_t* workSpaceSize,

4598  size_t* reserveSpaceSize);

4599 

4612 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,

4613  miopenRNNDescriptor_t rnnDesc,

4614  miopenTensorDescriptor_t xDesc,

4615  size_t* numBytes,

4616  miopenDataType_t dtype);

4617 

4630 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,

4631  miopenRNNDescriptor_t rnnDesc,

4632  miopenTensorDescriptor_t xDesc,

4633  miopenTensorDescriptor_t wDesc,

4634  miopenDataType_t dtype);

4635 

4653 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,

4654  miopenRNNDescriptor_t rnnDesc,

4655  const int seqLen,

4656  miopenTensorDescriptor_t* xDesc,

4657  size_t* numBytes);

4658 

4671 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,

4672  miopenRNNDescriptor_t rnnDesc,

4673  const int seqLen,

4674  miopenTensorDescriptor_t* xDesc,

4675  size_t* numBytes);

4676 

4717 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,

4718  miopenRNNDescriptor_t rnnDesc,

4719  const int layer,

4720  miopenTensorDescriptor_t xDesc,

4721  const int paramID,

4722  size_t* numBytes);

4723 

4761 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,

4762  miopenRNNDescriptor_t rnnDesc,

4763  const int layer,

4764  const int biasID,

4765  size_t* numBytes);

4766 

4825 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,

4826  miopenRNNDescriptor_t rnnDesc,

4827  const int layer,

4828  miopenTensorDescriptor_t xDesc,

4829  miopenTensorDescriptor_t wDesc,

4830  const void* w,

4831  const int paramID,

4832  miopenTensorDescriptor_t paramDesc,

4833  void* layerParam);

4834 

4892 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,

4893  miopenRNNDescriptor_t rnnDesc,

4894  const int layer,

4895  miopenTensorDescriptor_t xDesc,

4896  miopenTensorDescriptor_t wDesc,

4897  const void* w,

4898  const int biasID,

4899  miopenTensorDescriptor_t biasDesc,

4900  void* layerBias);

4901 

4956 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,

4957  const int layer,

4958  miopenTensorDescriptor_t xDesc,

4959  const int paramID,

4960  miopenTensorDescriptor_t paramDesc,

4961  size_t* layerParamOffset);

4962 

5013 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,

5014  const int layer,

5015  miopenTensorDescriptor_t xDesc,

5016  const int biasID,

5017  miopenTensorDescriptor_t biasDesc,

5018  size_t* layerBiasOffset);

5019 

5072 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,

5073  miopenRNNDescriptor_t rnnDesc,

5074  const int layer,

5075  miopenTensorDescriptor_t xDesc,

5076  miopenTensorDescriptor_t wDesc,

5077  void* w,

5078  const int paramID,

5079  miopenTensorDescriptor_t paramDesc,

5080  const void* layerParam);

5081 

5132 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,

5133  miopenRNNDescriptor_t rnnDesc,

5134  const int layer,

5135  miopenTensorDescriptor_t xDesc,

5136  miopenTensorDescriptor_t wDesc,

5137  void* w,

5138  const int biasID,

5139  miopenTensorDescriptor_t biasDesc,

5140  const void* layerBias);

5141 

5153 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

5154  miopenRNNPaddingMode_t paddingMode);

5155 

5163 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

5164  miopenRNNPaddingMode_t* paddingMode);

5165 

5216 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,

5217  const miopenRNNDescriptor_t rnnDesc,

5218  miopenRNNFWDMode_t fwdMode,

5219  const miopenSeqTensorDescriptor_t xDesc,

5220  const void* x,

5221  const miopenTensorDescriptor_t hDesc,

5222  const void* hx,

5223  void* hy,

5224  const miopenTensorDescriptor_t cDesc,

5225  const void* cx,

5226  void* cy,

5227  const miopenSeqTensorDescriptor_t yDesc,

5228  void* y,

5229  const void* w,

5230  size_t weightSpaceSize,

5231  void* workSpace,

5232  size_t workSpaceNumBytes,

5233  void* reserveSpace,

5234  size_t reserveSpaceNumBytes);

5235 

5285 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,

5286  const miopenRNNDescriptor_t rnnDesc,

5287  const miopenSeqTensorDescriptor_t yDesc,

5288  const void* y,

5289  const void* dy,

5290  const miopenTensorDescriptor_t hDesc,

5291  const void* hx,

5292  const void* dhy,

5293  void* dhx,

5294  const miopenTensorDescriptor_t cDesc,

5295  const void* cx,

5296  const void* dcy,

5297  void* dcx,

5298  const miopenSeqTensorDescriptor_t xDesc,

5299  void* dx,

5300  const void* w,

5301  size_t weightSpaceSize,

5302  void* workSpace,

5303  size_t workSpaceNumBytes,

5304  void* reserveSpace,

5305  size_t reserveSpaceNumBytes);

5306 

5340 MIOPEN_EXPORT miopenStatus_t

5341 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,

5342  const miopenRNNDescriptor_t rnnDesc,

5343  const miopenSeqTensorDescriptor_t xDesc,

5344  const void* x,

5345  const miopenTensorDescriptor_t hDesc,

5346  const void* hx,

5347  const miopenSeqTensorDescriptor_t yDesc,

5348  const void* y,

5349  void* dw,

5350  size_t weightSpaceSize,

5351  void* workSpace,

5352  size_t workSpaceNumBytes,

5353  const void* reserveSpace,

5354  size_t reserveSpaceNumBytes);

5355 

5413 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,

5414  const miopenRNNDescriptor_t rnnDesc,

5415  const int sequenceLen,

5416  const miopenTensorDescriptor_t* xDesc,

5417  const void* x,

5418  const miopenTensorDescriptor_t hxDesc,

5419  const void* hx,

5420  const miopenTensorDescriptor_t cxDesc,

5421  const void* cx,

5422  const miopenTensorDescriptor_t wDesc,

5423  const void* w,

5424  const miopenTensorDescriptor_t* yDesc,

5425  void* y,

5426  const miopenTensorDescriptor_t hyDesc,

5427  void* hy,

5428  const miopenTensorDescriptor_t cyDesc,

5429  void* cy,

5430  void* workSpace,

5431  size_t workSpaceNumBytes,

5432  void* reserveSpace,

5433  size_t reserveSpaceNumBytes);

5434 

5507 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,

5508  const miopenRNNDescriptor_t rnnDesc,

5509  const int sequenceLen,

5510  const miopenTensorDescriptor_t* yDesc,

5511  const void* y,

5512  const miopenTensorDescriptor_t* dyDesc,

5513  const void* dy,

5514  const miopenTensorDescriptor_t dhyDesc,

5515  const void* dhy,

5516  const miopenTensorDescriptor_t dcyDesc,

5517  const void* dcy,

5518  const miopenTensorDescriptor_t wDesc,

5519  const void* w,

5520  const miopenTensorDescriptor_t hxDesc,

5521  const void* hx,

5522  const miopenTensorDescriptor_t cxDesc,

5523  const void* cx,

5524  const miopenTensorDescriptor_t* dxDesc,

5525  void* dx,

5526  const miopenTensorDescriptor_t dhxDesc,

5527  void* dhx,

5528  const miopenTensorDescriptor_t dcxDesc,

5529  void* dcx,

5530  void* workSpace,

5531  size_t workSpaceNumBytes,

5532  void* reserveSpace,

5533  size_t reserveSpaceNumBytes);

5534 

5571 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,

5572  const miopenRNNDescriptor_t rnnDesc,

5573  const int sequenceLen,

5574  const miopenTensorDescriptor_t* xDesc,

5575  const void* x,

5576  const miopenTensorDescriptor_t hxDesc,

5577  const void* hx,

5578  const miopenTensorDescriptor_t* yDesc,

5579  const void* y,

5580  const miopenTensorDescriptor_t dwDesc,

5581  void* dw,

5582  void* workSpace,

5583  size_t workSpaceNumBytes,

5584  const void* reserveSpace,

5585  size_t reserveSpaceNumBytes);

5586 

5642 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,

5643  miopenRNNDescriptor_t rnnDesc,

5644  const int sequenceLen,

5645  const miopenTensorDescriptor_t* xDesc,

5646  const void* x,

5647  const miopenTensorDescriptor_t hxDesc,

5648  const void* hx,

5649  const miopenTensorDescriptor_t cxDesc,

5650  const void* cx,

5651  const miopenTensorDescriptor_t wDesc,

5652  const void* w,

5653  const miopenTensorDescriptor_t* yDesc,

5654  void* y,

5655  const miopenTensorDescriptor_t hyDesc,

5656  void* hy,

5657  const miopenTensorDescriptor_t cyDesc,

5658  void* cy,

5659  void* workSpace,

5660  size_t workSpaceNumBytes);

5661 

5663 // CLOSEOUT RNN DOXYGEN GROUP

5664 

5673 typedef enum

5674 {

5675  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,

5676 } miopenCTCLossAlgo_t;

5677 

5684 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);

5685 

5695 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5696  miopenDataType_t* dataType,

5697  int* blank_label_id,

5698  bool* apply_softmax_layer);

5699 

5705 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);

5706 

5716 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5717  miopenDataType_t dataType,

5718  const int blank_label_id,

5719  bool apply_softmax_layer);

5720 

5737 MIOPEN_EXPORT miopenStatus_t

5738 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,

5739  const miopenTensorDescriptor_t probsDesc,

5740  const miopenTensorDescriptor_t gradientsDesc,

5741  const int* labels,

5742  const int* labelLengths,

5743  const int* inputLengths,

5744  miopenCTCLossAlgo_t algo,

5745  const miopenCTCLossDescriptor_t ctcLossDesc,

5746  size_t* workSpaceSize);

5747 

5767 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,

5768  const miopenTensorDescriptor_t probsDesc,

5769  const void* probs,

5770  const int* labels,

5771  const int* labelLengths,

5772  const int* inputLengths,

5773  void* losses,

5774  const miopenTensorDescriptor_t gradientsDesc,

5775  void* gradients,

5776  miopenCTCLossAlgo_t algo,

5777  const miopenCTCLossDescriptor_t ctcLossDesc,

5778  void* workSpace,

5779  size_t workSpaceSize);

5780 

5782 // CLOSEOUT LossFunction DOXYGEN GROUP

5783 

5784 // Dropout APIs

5793 typedef enum

5794 {

5795  MIOPEN_RNG_PSEUDO_XORWOW = 0,

5796 } miopenRNGType_t;

5797 

5803 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);

5804 

5810 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);

5811 

5820 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,

5821  size_t* reserveSpaceSizeInBytes);

5822 

5831 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,

5832  size_t* stateSizeInBytes);

5833 

5850 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5851  miopenHandle_t handle,

5852  float* dropout,

5853  void** states,

5854  unsigned long long* seed,

5855  bool* use_mask,

5856  bool* state_evo,

5857  miopenRNGType_t* rng_mode);

5858 

5881 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5882  miopenHandle_t handle,

5883  float dropout,

5884  void* states,

5885  size_t stateSizeInBytes,

5886  unsigned long long seed,

5887  bool use_mask,

5888  bool state_evo,

5889  miopenRNGType_t rng_mode);

5890 

5910 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5911  miopenHandle_t handle,

5912  float dropout,

5913  void* states,

5914  size_t stateSizeInBytes,

5915  unsigned long long seed,

5916  bool use_mask,

5917  bool state_evo,

5918  miopenRNGType_t rng_mode);

5919 

5937 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,

5938  const miopenDropoutDescriptor_t dropoutDesc,

5939  const miopenTensorDescriptor_t noise_shape,

5940  const miopenTensorDescriptor_t xDesc,

5941  const void* x,

5942  const miopenTensorDescriptor_t yDesc,

5943  void* y,

5944  void* reserveSpace,

5945  size_t reserveSpaceSizeInBytes);

5946 

5964 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,

5965  const miopenDropoutDescriptor_t dropoutDesc,

5966  const miopenTensorDescriptor_t noise_shape,

5967  const miopenTensorDescriptor_t dyDesc,

5968  const void* dy,

5969  const miopenTensorDescriptor_t dxDesc,

5970  void* dx,

5971  void* reserveSpace,

5972  size_t reserveSpaceSizeInBytes);

5973 

5975 // CLOSEOUT DROPOUT DOXYGEN GROUP

5976 

5977 // TensorReduce APIs

5988 MIOPEN_EXPORT miopenStatus_t

5989 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);

5990 

5996 MIOPEN_EXPORT miopenStatus_t

5997 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);

5998 

6011 MIOPEN_EXPORT miopenStatus_t

6012 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,

6013  miopenReduceTensorOp_t reduceTensorOp,

6014  miopenDataType_t reduceTensorCompType,

6015  miopenNanPropagation_t reduceTensorNanOpt,

6016  miopenReduceTensorIndices_t reduceTensorIndices,

6017  miopenIndicesType_t reduceTensorIndicesType);

6018 

6034 MIOPEN_EXPORT miopenStatus_t

6035 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,

6036  miopenReduceTensorOp_t* reduceTensorOp,

6037  miopenDataType_t* reduceTensorCompType,

6038  miopenNanPropagation_t* reduceTensorNanOpt,

6039  miopenReduceTensorIndices_t* reduceTensorIndices,

6040  miopenIndicesType_t* reduceTensorIndicesType);

6041 

6051 MIOPEN_EXPORT miopenStatus_t

6052 miopenGetReductionIndicesSize(miopenHandle_t handle,

6053  const miopenReduceTensorDescriptor_t reduceTensorDesc,

6054  const miopenTensorDescriptor_t aDesc,

6055  const miopenTensorDescriptor_t cDesc,

6056  size_t* sizeInBytes);

6057 

6067 MIOPEN_EXPORT miopenStatus_t

6068 miopenGetReductionWorkspaceSize(miopenHandle_t handle,

6069  const miopenReduceTensorDescriptor_t reduceTensorDesc,

6070  const miopenTensorDescriptor_t aDesc,

6071  const miopenTensorDescriptor_t cDesc,

6072  size_t* sizeInBytes);

6073 

6097 MIOPEN_EXPORT miopenStatus_t

6098 miopenReduceTensor(miopenHandle_t handle,

6099  const miopenReduceTensorDescriptor_t reduceTensorDesc,

6100  void* indices,

6101  size_t indicesSizeInBytes,

6102  void* workspace,

6103  size_t workspaceSizeInBytes,

6104  const void* alpha,

6105  const miopenTensorDescriptor_t aDesc,

6106  const void* A,

6107  const void* beta,

6108  const miopenTensorDescriptor_t cDesc,

6109  void* C);

6110 

6112 // CLOSEOUT TensorReduce DOXYGEN GROUP

6113 

6114 // Find 2.0 API

6125 MIOPEN_DECLARE_OBJECT(miopenProblem);

6126 

6130 typedef enum

6131 {

6132  miopenProblemDirectionForward = 0,

6133  miopenProblemDirectionBackward = 1,

6134  miopenProblemDirectionBackwardWeights = 2,

6135 #ifdef MIOPEN_BETA_API

6136  miopenProblemDirectionInference = 4,

6137 #endif

6138 } miopenProblemDirection_t;

6139 

6143 typedef enum

6144 {

6145  miopenTensorArgumentIdInvalid = 0,

6146  miopenTensorConvolutionX = 1,

6147  miopenTensorConvolutionW = 2,

6148  miopenTensorConvolutionY = 3,

6149 

6150  miopenTensorMhaK = 4,

6151  miopenTensorMhaQ = 5,

6152  miopenTensorMhaV = 6,

6153  miopenTensorMhaDescaleK = 7,

6154  miopenTensorMhaDescaleQ = 8,

6155  miopenTensorMhaDescaleV = 9,

6156  miopenTensorMhaDescaleS = 10,

6157  miopenTensorMhaScaleS = 11,

6158  miopenTensorMhaScaleO = 12,

6159  miopenTensorMhaDropoutProbability = 13,

6160  miopenTensorMhaDropoutSeed = 14,

6161  miopenTensorMhaDropoutOffset = 15,

6162  miopenTensorMhaO = 16,

6163  miopenTensorMhaAmaxO = 17,

6164  miopenTensorMhaAmaxS = 18,

6165  miopenTensorMhaM = 19,

6166  miopenTensorMhaZInv = 20,

6167  miopenTensorMhaDO = 21,

6168  miopenTensorMhaDescaleO = 22,

6169  miopenTensorMhaDescaleDO = 23,

6170  miopenTensorMhaDescaleDS = 24,

6171  miopenTensorMhaScaleDS = 25,

6172  miopenTensorMhaScaleDQ = 26,

6173  miopenTensorMhaScaleDK = 27,

6174  miopenTensorMhaScaleDV = 28,

6175  miopenTensorMhaDQ = 29,

6176  miopenTensorMhaDK = 30,

6177  miopenTensorMhaDV = 31,

6178  miopenTensorMhaAmaxDQ = 32,

6179  miopenTensorMhaAmaxDK = 33,

6180  miopenTensorMhaAmaxDV = 34,

6181  miopenTensorMhaAmaxDS = 35,

6182  miopenTensorMhaBias = 36,

6183 

6184 #ifdef MIOPEN_BETA_API

6185  miopenTensorActivationX = 37,

6186  miopenTensorActivationY = 38,

6187  miopenTensorActivationDX = 39,

6188  miopenTensorActivationDY = 40,

6189  miopenTensorBiasX = 41,

6190  miopenTensorBiasY = 42,

6191  miopenTensorBias = 43,

6192  miopenTensorSoftmaxX = 44,

6193  miopenTensorSoftmaxY = 45,

6194  miopenTensorSoftmaxDX = 46,

6195  miopenTensorSoftmaxDY = 47,

6196  miopenTensorBatchnormX = 48,

6197  miopenTensorBatchnormY = 49,

6198  miopenTensorBatchnormRunningMean = 50,

6199  miopenTensorBatchnormRunningVariance = 51,

6200  miopenTensorBatchnormSavedMean = 52,

6201  miopenTensorBatchnormSavedVariance = 53,

6202  miopenTensorBatchnormScale = 54,

6203  miopenTensorBatchnormScaleDiff = 55,

6204  miopenTensorBatchnormEstimatedMean = 56,

6205  miopenTensorBatchnormEstimatedVariance = 57,

6206  miopenTensorBatchnormBias = 58,

6207  miopenTensorBatchnormBiasDiff = 59,

6208  miopenTensorBatchnormDX = 60,

6209  miopenTensorBatchnormDY = 61,

6210 #endif

6211 

6212  miopenTensorArgumentIsScalar = 1U << 31,

6213 

6214  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,

6215 #ifdef MIOPEN_BETA_API

6216  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,

6217  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,

6218 #endif

6219 } miopenTensorArgumentId_t;

6220 

6224 typedef enum

6225 {

6226  miopenFindResultsOrderByTime = 0,

6227  miopenFindResultsOrderByWorkspaceSize = 1,

6228 } miopenFindResultsOrder_t;

6229 

6237 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,

6238  miopenConvolutionDescriptor_t operatorDesc,

6239  miopenProblemDirection_t direction);

6240 

6252 typedef enum

6253 {

6254  miopenMhaMaskNone = 0,

6255  miopenMhaMaskCausal = 1,

6256 } miopenMhaMask_t;

6257 

6258 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,

6259  miopenMhaDescriptor_t operatorDesc,

6260  miopenProblemDirection_t direction);

6261 

6268 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);

6269 

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

6280 

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

6291 

6298 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);

6299 

6311 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,

6312  float alpha,

6313  float beta,

6314  miopenSoftmaxAlgorithm_t algorithm,

6315  miopenSoftmaxMode_t mode);

6316 

6328 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,

6329  float* alpha,

6330  float* beta,

6331  miopenSoftmaxAlgorithm_t* algorithm,

6332  miopenSoftmaxMode_t* mode);

6333 

6339 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);

6340 

6348 MIOPEN_EXPORT miopenStatus_t

6349 miopenSetProblemTensorDescriptor(miopenProblem_t problem,

6350  miopenTensorArgumentId_t id,

6351  const miopenTensorDescriptor_t descriptor);

6352 

6355 MIOPEN_DECLARE_OBJECT(miopenFindOptions);

6356 

6362 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);

6363 

6369 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);

6370 

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

6378 

6385 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,

6386  miopenFindResultsOrder_t value);

6387 

6395 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,

6396  size_t value);

6397 

6405 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,

6406  void* buffer,

6407  size_t size);

6408 

6417 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,

6418  miopenTensorArgumentId_t id,

6419  void* buffer);

6420 

6428 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,

6429  unsigned attach);

6430 

6433 MIOPEN_DECLARE_OBJECT(miopenSolution);

6434 

6446 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,

6447  miopenProblem_t problem,

6448  miopenFindOptions_t options,

6449  miopenSolution_t* solutions,

6450  size_t* numSolutions,

6451  size_t maxSolutions);

6452 

6455 struct miopenTensorArgument_t

6456 {

6457  /* @brief Identifier of the tensor argument.

6458  */

6459  miopenTensorArgumentId_t id;

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

6461  *

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

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

6464  */

6465  miopenTensorDescriptor_t* descriptor;

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

6467  * the value is scalar.

6468  */

6469  void* buffer;

6470 };

6471 

6483 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,

6484  miopenSolution_t solution,

6485  size_t nInputs,

6486  const miopenTensorArgument_t* tensors,

6487  void* workspace,

6488  size_t workspaceSize);

6489 

6495 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);

6496 

6504 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,

6505  const char* data,

6506  size_t size);

6507 

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

6515 

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

6523 

6530 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,

6531  size_t* workspaceSize);

6532 

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

6540 

6547 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,

6548  uint64_t* solverId);

6549 

6556 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,

6557  miopenConvAlgorithm_t* result);

6558 

6559 #ifdef MIOPEN_BETA_API

6560 

6569 MIOPEN_EXPORT miopenStatus_t

6570 miopenCreateActivationProblem(miopenProblem_t* problem,

6571  miopenActivationDescriptor_t operatorDesc,

6572  miopenProblemDirection_t direction);

6573 

6582 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,

6583  miopenBatchNormMode_t mode,

6584  bool runningMeanVariance,

6585  miopenProblemDirection_t direction);

6586 

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

6607 

6615 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,

6616  miopenProblemDirection_t direction);

6617 

6626 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,

6627  miopenSoftmaxDescriptor_t operatorDesc,

6628  miopenProblemDirection_t direction);

6629 

6630 #endif

6631 

6633 // CLOSEOUT find2 DOXYGEN GROUP

6634 

6635 #ifdef MIOPEN_BETA_API

6636 

6641 typedef enum

6642 {

6643  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,

6644  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =

6645  1,

6646 } miopenReduceCalculationNanPropagation_t;

6647 

6648 // ReduceCalculation APIs

6657 typedef enum

6658 {

6659  MIOPEN_REDUCE_CALCULATION_PROD =

6660  1,

6661  MIOPEN_REDUCE_CALCULATION_SUM =

6662  2,

6663 } miopenReduceCalculationOp_t;

6664 

6674 MIOPEN_EXPORT miopenStatus_t

6675 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,

6676  const miopenTensorDescriptor_t xDesc,

6677  const int32_t dim,

6678  const miopenReduceCalculationOp_t reduceCalculationOp,

6679  const miopenTensorDescriptor_t reduceDesc,

6680  size_t* sizeInBytes);

6681 

6695 MIOPEN_EXPORT miopenStatus_t

6696 miopenReduceCalculationForward(miopenHandle_t handle,

6697  miopenReduceCalculationNanPropagation_t nanPropagation,

6698  void* workspace,

6699  size_t workspaceSizeInBytes,

6700  const miopenTensorDescriptor_t xDesc,

6701  const void* x,

6702  const int32_t dim,

6703  const miopenReduceCalculationOp_t reduceCalculationOp,

6704  const miopenTensorDescriptor_t reduceDesc,

6705  void* y);

6706 

6708 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP

6709 #endif // MIOPEN_BETA_API

6710 

6711 #ifdef MIOPEN_BETA_API

6712 

6717 typedef enum

6718 {

6719  MIOPEN_REDUCE_EXTREME_ARGMIN =

6720  1,

6721  MIOPEN_REDUCE_EXTREME_ARGMAX =

6722  2,

6723  MIOPEN_REDUCE_EXTREME_MIN =

6724  3,

6725  MIOPEN_REDUCE_EXTREME_MAX =

6726  4,

6727 } miopenReduceExtremeOp_t;

6728 

6729 // ReduceExtreme APIs

6749 MIOPEN_EXPORT miopenStatus_t

6750 miopenReduceExtremeForward(miopenHandle_t handle,

6751  const miopenTensorDescriptor_t xDesc,

6752  const void* x,

6753  const int32_t dim,

6754  const miopenReduceExtremeOp_t reduceExtremeOp,

6755  const miopenTensorDescriptor_t yDesc,

6756  void* y,

6757  const miopenTensorDescriptor_t indiceDesc,

6758  void* indice);

6759 

6761 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP

6762 #endif // MIOPEN_BETA_API

6763 

6764 #ifdef MIOPEN_BETA_API

6765 // GroupNorm APIs

6790 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,

6791  miopenNormMode_t mode,

6792  const miopenTensorDescriptor_t xDesc,

6793  const void* x,

6794  const miopenTensorDescriptor_t weightDesc,

6795  const void* weight,

6796  const miopenTensorDescriptor_t biasDesc,

6797  const void* bias,

6798  const uint64_t num_groups,

6799  const float epsilon,

6800  const miopenTensorDescriptor_t yDesc,

6801  void* y,

6802  const miopenTensorDescriptor_t meanDesc,

6803  void* mean,

6804  const miopenTensorDescriptor_t rstdDesc,

6805  void* rstd);

6806 

6808 // CLOSEOUT groupnorm DOXYGEN GROUP

6809 #endif // MIOPEN_BETA_API

6810 

6811 #ifdef MIOPEN_BETA_API

6812 // LayerNorm APIs

6839 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,

6840  miopenNormMode_t mode,

6841  const miopenTensorDescriptor_t xDesc,

6842  const void* x,

6843  const miopenTensorDescriptor_t x2Desc,

6844  const void* x2,

6845  const miopenTensorDescriptor_t weightDesc,

6846  const void* weight,

6847  const miopenTensorDescriptor_t biasDesc,

6848  const void* bias,

6849  const float epsilon,

6850  const int32_t normalized_dim,

6851  const miopenTensorDescriptor_t yDesc,

6852  void* y,

6853  const miopenTensorDescriptor_t meanDesc,

6854  void* mean,

6855  const miopenTensorDescriptor_t rstdDesc,

6856  void* rstd);

6857 

6859 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6860 #endif // MIOPEN_BETA_API

6861 

6862 #ifdef MIOPEN_BETA_API

6863 // LayerNorm APIs

6883 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,

6884  miopenNormMode_t mode,

6885  const miopenTensorDescriptor_t xDesc,

6886  const void* x,

6887  const miopenTensorDescriptor_t weightDesc,

6888  const void* weight,

6889  const float epsilon,

6890  const miopenTensorDescriptor_t yDesc,

6891  void* y,

6892  const miopenTensorDescriptor_t rstdDesc,

6893  void* rstd);

6894 

6909 MIOPEN_EXPORT miopenStatus_t

6910 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,

6911  miopenNormMode_t mode,

6912  const miopenTensorDescriptor_t dyDesc,

6913  const miopenTensorDescriptor_t xDesc,

6914  const miopenTensorDescriptor_t weightDesc,

6915  const miopenTensorDescriptor_t rstdDesc,

6916  const miopenTensorDescriptor_t dxDesc,

6917  const miopenTensorDescriptor_t dwDesc,

6918  size_t* sizeInBytes);

6919 

6940 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,

6941  miopenNormMode_t mode,

6942  void* workspace,

6943  size_t workspaceSizeInBytes,

6944  const miopenTensorDescriptor_t dyDesc,

6945  const void* dy,

6946  const miopenTensorDescriptor_t xDesc,

6947  const void* x,

6948  const miopenTensorDescriptor_t weightDesc,

6949  const void* weight,

6950  const miopenTensorDescriptor_t rstdDesc,

6951  const void* rstd,

6952  const miopenTensorDescriptor_t dxDesc,

6953  void* dx,

6954  const miopenTensorDescriptor_t dwDesc,

6955  void* dw);

6957 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6958 #endif // MIOPEN_BETA_API

6959 

6964 typedef enum

6965 {

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

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

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

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

6970 

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

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

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

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

6975  But used to check for errors.*/

6976 } miopenAlphaBetaCase_t;

6977 

6978 #ifdef MIOPEN_BETA_API

6979 // FusedAdam APIs

7122 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,

7123  const miopenTensorDescriptor_t paramDesc,

7124  void* param,

7125  const miopenTensorDescriptor_t gradDesc,

7126  const void* grad,

7127  const miopenTensorDescriptor_t expAvgDesc,

7128  void* expAvg,

7129  const miopenTensorDescriptor_t expAvgSqDesc,

7130  void* expAvgSq,

7131  const miopenTensorDescriptor_t maxExpAvgSqDesc,

7132  void* maxExpAvgSq,

7133  const miopenTensorDescriptor_t stateStepDesc,

7134  void* stateStep,

7135  const unsigned int state_step,

7136  const float lr,

7137  const float beta1,

7138  const float beta2,

7139  const float weight_decay,

7140  const float eps,

7141  const bool amsgrad,

7142  const bool maximize,

7143  const bool adamw,

7144  const miopenTensorDescriptor_t gradScaleDesc,

7145  const void* gradScale,

7146  const miopenTensorDescriptor_t foundInfDesc,

7147  const void* foundInf);

7148 

7289 MIOPEN_EXPORT miopenStatus_t

7290 miopenFusedAdamWithOutput(miopenHandle_t handle,

7291  const miopenTensorDescriptor_t paramInDesc,

7292  void* paramIn,

7293  const miopenTensorDescriptor_t paramOutDesc,

7294  void* paramOut,

7295  const miopenTensorDescriptor_t paramOutFloat16Desc,

7296  void* paramOutFloat16,

7297  const miopenTensorDescriptor_t gradInDesc,

7298  const void* gradIn,

7299  const miopenTensorDescriptor_t expAvgInDesc,

7300  void* expAvgIn,

7301  const miopenTensorDescriptor_t expAvgOutDesc,

7302  void* expAvgOut,

7303  const miopenTensorDescriptor_t expAvgSqInDesc,

7304  void* expAvgSqIn,

7305  const miopenTensorDescriptor_t expAvgSqOutDesc,

7306  void* expAvgSqOut,

7307  const miopenTensorDescriptor_t maxExpAvgSqInDesc,

7308  void* maxExpAvgSqIn,

7309  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,

7310  void* maxExpAvgSqOut,

7311  const miopenTensorDescriptor_t stateStepInDesc,

7312  void* stateStepIn,

7313  const miopenTensorDescriptor_t stateStepOutDesc,

7314  void* stateStepOut,

7315  const unsigned int state_step,

7316  const float lr,

7317  const float beta1,

7318  const float beta2,

7319  const float weight_decay,

7320  const float eps,

7321  const bool amsgrad,

7322  const bool maximize,

7323  const bool adamw,

7324  const miopenTensorDescriptor_t gradScaleDesc,

7325  const void* gradScale,

7326  const miopenTensorDescriptor_t foundInfDesc,

7327  const void* foundInf);

7328 

7330 // CLOSEOUT SGD DOXYGEN GROUP

7331 #endif // MIOPEN_BETA_API

7332 

7333 #ifdef MIOPEN_BETA_API

7334 // TransformersAdamW APIs

7425 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,

7426  const miopenTensorDescriptor_t paramDesc,

7427  void* param,

7428  const miopenTensorDescriptor_t gradDesc,

7429  const void* grad,

7430  const miopenTensorDescriptor_t expAvgDesc,

7431  void* expAvg,

7432  const miopenTensorDescriptor_t expAvgSqDesc,

7433  void* expAvgSq,

7434  const miopenTensorDescriptor_t stateStepDesc,

7435  void* stateStep,

7436  const unsigned int state_step,

7437  const float lr,

7438  const float beta1,

7439  const float beta2,

7440  const float weight_decay,

7441  const float eps,

7442  const bool correct_bias,

7443  const miopenTensorDescriptor_t gradScaleDesc,

7444  const void* gradScale,

7445  const miopenTensorDescriptor_t foundInfDesc,

7446  const void* foundInf);

7447 

7574 MIOPEN_EXPORT miopenStatus_t

7575 miopenTransformersAdamWWithOutput(miopenHandle_t handle,

7576  const miopenTensorDescriptor_t paramInDesc,

7577  void* paramIn,

7578  const miopenTensorDescriptor_t paramOutDesc,

7579  void* paramOut,

7580  const miopenTensorDescriptor_t paramOutFloat16Desc,

7581  void* paramOutFloat16,

7582  const miopenTensorDescriptor_t gradInDesc,

7583  const void* gradIn,

7584  const miopenTensorDescriptor_t expAvgInDesc,

7585  void* expAvgIn,

7586  const miopenTensorDescriptor_t expAvgOutDesc,

7587  void* expAvgOut,

7588  const miopenTensorDescriptor_t expAvgSqInDesc,

7589  void* expAvgSqIn,

7590  const miopenTensorDescriptor_t expAvgSqOutDesc,

7591  void* expAvgSqOut,

7592  const miopenTensorDescriptor_t stateStepInDesc,

7593  void* stateStepIn,

7594  const miopenTensorDescriptor_t stateStepOutDesc,

7595  void* stateStepOut,

7596  const unsigned int state_step,

7597  const float lr,

7598  const float beta1,

7599  const float beta2,

7600  const float weight_decay,

7601  const float eps,

7602  const float step_size,

7603  const bool correct_bias,

7604  const miopenTensorDescriptor_t gradScaleDesc,

7605  const void* gradScale,

7606  const miopenTensorDescriptor_t foundInfDesc,

7607  const void* foundInf);

7608 

7610 // CLOSEOUT SGD DOXYGEN GROUP

7611 #endif // MIOPEN_BETA_API

7612 

7613 #ifdef MIOPEN_BETA_API

7614 // GetItem APIs

7627 MIOPEN_EXPORT miopenStatus_t

7628 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,

7629  uint32_t indexCount,

7630  const miopenTensorDescriptor_t* indexDescs,

7631  size_t* sizeInBytes);

7632 

7657 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,

7658  void* workspace,

7659  size_t workspaceSizeInBytes,

7660  const miopenTensorDescriptor_t dyDesc,

7661  const void* dy,

7662  uint32_t indexCount,

7663  const miopenTensorDescriptor_t* indexDescs,

7664  const void* const* indexs,

7665  const miopenTensorDescriptor_t dxDesc,

7666  void* dx,

7667  const miopenTensorDescriptor_t errorDesc,

7668  void* error,

7669  uint32_t dimCount,

7670  const int32_t* dims,

7671  uint32_t sliceCount,

7672  const int32_t* slices,

7673  uint32_t offset);

7674 

7676 // CLOSEOUT GETITEM DOXYGEN GROUP

7677 #endif // MIOPEN_BETA_API

7678 

7679 #ifdef MIOPEN_BETA_API

7680 // RotaryPositionalEmbeddings APIs

7698 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,

7699  const miopenTensorDescriptor_t xDesc,

7700  const void* x,

7701  const miopenTensorDescriptor_t cosDesc,

7702  const void* cos,

7703  const miopenTensorDescriptor_t sinDesc,

7704  const void* sin,

7705  const miopenTensorDescriptor_t yDesc,

7706  void* y);

7707 

7721 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,

7722  const miopenTensorDescriptor_t dyDesc,

7723  const void* dy,

7724  const miopenTensorDescriptor_t cosDesc,

7725  const void* cos,

7726  const miopenTensorDescriptor_t sinDesc,

7727  const void* sin,

7728  const miopenTensorDescriptor_t dxDesc,

7729  void* dx);

7731 // CLOSEOUT ROPE DOXYGEN GROUP

7732 // kthvalue APIs

7753 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,

7754  miopenTensorDescriptor_t inputDesc,

7755  const void* input,

7756  miopenTensorDescriptor_t outputDesc,

7757  void* output,

7758  miopenTensorDescriptor_t indicesDesc,

7759  size_t* indices,

7760  size_t k,

7761  int32_t dim = -1,

7762  bool keepDim = false);

7763 

7765 // CLOSEOUT kthvalue DOXYGEN GROUP

7766 #endif // MIOPEN_BETA_API

7767 

7768 #ifdef MIOPEN_BETA_API

7782 MIOPEN_EXPORT miopenStatus_t

7783 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,

7784  miopenTensorDescriptor_t inputDesc,

7785  miopenTensorDescriptor_t weightDesc,

7786  size_t* sizeInBytes);

7787 

7804 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,

7805  void* workspace,

7806  size_t workspaceSizeInBytes,

7807  miopenTensorDescriptor_t inputDesc,

7808  const void* input,

7809  miopenTensorDescriptor_t weightDesc,

7810  const void* weight,

7811  miopenTensorDescriptor_t doutputDesc,

7812  const void* doutput,

7813  miopenTensorDescriptor_t dinputDesc,

7814  void* dinput,

7815  miopenTensorDescriptor_t dweightDesc,

7816  void* dweight);

7817 

7819 // CLOSEOUT RELU DOXYGEN GROUP

7820 #endif // MIOPEN_BETA_API

7821 

7822 #ifdef MIOPEN_BETA_API

7823 

7828 typedef enum

7829 {

7830  MIOPEN_LOSS_REDUCTION_NONE = 0,

7831  MIOPEN_LOSS_REDUCTION_SUM = 1,

7832  MIOPEN_LOSS_REDUCTION_MEAN = 2,

7834 } miopenLossReductionMode_t;

7835 

7836 // SoftMarginLoss APIs

7854 MIOPEN_EXPORT miopenStatus_t

7855 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,

7856  miopenTensorDescriptor_t inputDesc,

7857  miopenTensorDescriptor_t targetDesc,

7858  miopenTensorDescriptor_t outputDesc,

7859  miopenLossReductionMode_t reduction,

7860  size_t* sizeInBytes);

7861 

7878 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,

7879  miopenTensorDescriptor_t inputDesc,

7880  const void* input,

7881  miopenTensorDescriptor_t targetDesc,

7882  const void* target,

7883  miopenTensorDescriptor_t outputDesc,

7884  void* output,

7885  miopenLossReductionMode_t reduction,

7886  void* workspace = nullptr,

7887  size_t workspaceSizeInBytes = 0);

7888 

7903 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,

7904  miopenTensorDescriptor_t inputDesc,

7905  const void* input,

7906  miopenTensorDescriptor_t targetDesc,

7907  const void* target,

7908  miopenTensorDescriptor_t doutputDesc,

7909  const void* doutput,

7910  miopenTensorDescriptor_t dinputDesc,

7911  void* dinput,

7912  miopenLossReductionMode_t reduction);

7913 

7915 // CLOSEOUT LossFunction DOXYGEN GROUP

7916 #endif

7917 

7918 #ifdef MIOPEN_BETA_API

7919 // MultiMarginLoss APIs

7943 MIOPEN_EXPORT miopenStatus_t

7944 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,

7945  miopenTensorDescriptor_t inputDesc,

7946  miopenTensorDescriptor_t targetDesc,

7947  miopenTensorDescriptor_t weightDesc,

7948  miopenTensorDescriptor_t outputDesc,

7949  long p,

7950  float margin,

7951  miopenLossReductionMode_t reduction,

7952  size_t* sizeInBytes);

7953 

7981 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,

7982  miopenTensorDescriptor_t inputDesc,

7983  const void* input,

7984  miopenTensorDescriptor_t targetDesc,

7985  const void* target,

7986  miopenTensorDescriptor_t weightDesc,

7987  const void* weight,

7988  miopenTensorDescriptor_t outputDesc,

7989  void* output,

7990  long p,

7991  float margin,

7992  miopenLossReductionMode_t reduction,

7993  void* workspace,

7994  size_t workspaceSizeInBytes);

7995 

7997 // CLOSEOUT LossFunction DOXYGEN GROUP

7998 #endif // MIOPEN_BETA_API

7999 

8011 typedef enum

8012 {

8013  miopenTuningPolicyNone = 1,

8014  miopenTuningPolicyDbUpdate = 2,

8015  miopenTuningPolicySearch =

8016  3,

8017  miopenTuningPolicySearchDbUpdate = 4,

8018  miopenTuningPolicyDbClean = 5,

8019 } miopenTuningPolicy_t;

8020 

8029 MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,

8030  miopenTuningPolicy_t newValue);

8031 

8039 MIOPEN_EXPORT miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle,

8040  miopenTuningPolicy_t* value);

8041 

8042 #ifdef __cplusplus

8043 }

8044 #endif

8045 

8046 #ifdef __clang__

8047 #pragma clang diagnostic pop

8048 #endif

8049 

8050 #endif // MIOPEN_GUARD_MIOPEN_H_

miopenCreateOpActivationBackward

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

Creates a backward activation operator.

miopenCreateOpBatchNormForward

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

Creates a forward training batch normalization operator.

miopenFusionPlanConvolutionGetAlgo

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

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

miopenFusionPlanGetWorkSpaceSize

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

Query the workspace size required for the fusion plan.

miopenFusionPlanConvolutionSetAlgo

miopenStatus_t miopenFusionPlanConvolutionSetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo)

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

miopenCreateOpBatchNormInference

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

Creates a forward inference batch normalization operator.

miopenSetOpArgsBiasForward

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

Sets the arguments for forward bias op.

miopenCreateOpConvForward

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

Creates forward convolution operator.

miopenSetOpArgsBatchNormInference

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

Sets the arguments for inference batch normalization op.

miopenSetOpArgsBatchNormForward

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

Sets the arguments for forward batch normalization op.

miopenExecuteFusionPlan

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

Executes the fusion plan. Only compatible with NHWC/NDHWC tensor layouts.

miopenFusionPlanGetOp

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

Allows access to the operators in a fusion plan.

miopenDestroyFusionPlan

miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc)

Destroy the fusion plan descriptor object.

miopenCreateOpActivationForward

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

Creates a forward activation operator.

miopenExecuteFusionPlan_v2

miopenStatus_t miopenExecuteFusionPlan_v2(const miopenHandle_t handle, const miopenFusionPlanDescriptor_t fusePlanDesc, const miopenTensorDescriptor_t inputDesc, const void *input, const miopenTensorDescriptor_t outputDesc, void *output, miopenOperatorArgs_t args, void *workspace, size_t workspaceSize)

Executes the fusion plan with a workspace buffer for layout transformations.

miopenFusionDirection_t

miopenFusionDirection_t

Kernel fusion direction in the network.

Definition: miopen.h:3816

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

miopenVerticalFusion

@ miopenVerticalFusion

Definition: miopen.h:3817

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

miopenLRNForward

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

Execute a LRN forward layer.

miopenDestroyLRNDescriptor

miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc)

Destroys the LRN descriptor object.

miopenGetCTCLossWorkspaceSize

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

Query the amount of memory required to execute miopenCTCLoss.

miopenGetSoftMarginLossForwardWorkspaceSize

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

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

miopenLossReductionMode_t

miopenLossReductionMode_t

Definition: miopen.h:7829

miopenGetMultiMarginLossForwardWorkspaceSize

miopenStatus_t miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, miopenTensorDescriptor_t targetDesc, miopenTensorDescriptor_t weightDesc, miopenTensorDescriptor_t outputDesc, long p, float margin, miopenLossReductionMode_t reduction, size_t *sizeInBytes)

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

miopenCTCLossAlgo_t

miopenCTCLossAlgo_t

Definition: miopen.h:5674

miopenSetCTCLossDescriptor

miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc, miopenDataType_t dataType, const int blank_label_id, bool apply_softmax_layer)

Set the details of a CTC loss function descriptor.

miopenCTCLoss

miopenStatus_t miopenCTCLoss(miopenHandle_t handle, const miopenTensorDescriptor_t probsDesc, const void *probs, const int *labels, const int *labelLengths, const int *inputLengths, void *losses, const miopenTensorDescriptor_t gradientsDesc, void *gradients, miopenCTCLossAlgo_t algo, const miopenCTCLossDescriptor_t ctcLossDesc, void *workSpace, size_t workSpaceSize)

Execute forward inference for CTCLoss layer.

miopenGetCTCLossDescriptor

miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc, miopenDataType_t *dataType, int *blank_label_id, bool *apply_softmax_layer)

Retrieves a CTC loss function descriptor's details.

miopenCreateCTCLossDescriptor

miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t *ctcLossDesc)

Create a CTC loss function Descriptor.

miopenMultiMarginLossForward

miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t targetDesc, const void *target, miopenTensorDescriptor_t weightDesc, const void *weight, miopenTensorDescriptor_t outputDesc, void *output, long p, float margin, miopenLossReductionMode_t reduction, void *workspace, size_t workspaceSizeInBytes)

Execute a MultiMarginLoss forward layer.

miopenSoftMarginLossBackward

miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t targetDesc, const void *target, miopenTensorDescriptor_t doutputDesc, const void *doutput, miopenTensorDescriptor_t dinputDesc, void *dinput, miopenLossReductionMode_t reduction)

Execute a SoftMarginLoss backward layer.

miopenSoftMarginLossForward

miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t targetDesc, const void *target, miopenTensorDescriptor_t outputDesc, void *output, miopenLossReductionMode_t reduction, void *workspace=nullptr, size_t workspaceSizeInBytes=0)

Execute a SoftMarginLoss forward layer.

miopenDestroyCTCLossDescriptor

miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc)

Destroys a CTC loss function descriptor object.

MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC

@ MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC

Definition: miopen.h:5675

miopenRNNMode_t

miopenRNNMode_t

Definition: miopen.h:4279

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

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

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

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

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

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 the size in bytes of the RNN input tensor.

miopenRNNFWDMode_t

miopenRNNFWDMode_t

Definition: miopen.h:4347

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

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

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

miopenLSTM

@ miopenLSTM

Definition: miopen.h:4282

miopenGRU

@ miopenGRU

Definition: miopen.h:4283

miopenRNNRELU

@ miopenRNNRELU

Definition: miopen.h:4280

miopenRNNlinear

@ miopenRNNlinear

Definition: miopen.h:4291

miopenRNNskip

@ miopenRNNskip

Definition: miopen.h:4292

miopenRNNbidirection

@ miopenRNNbidirection

Definition: miopen.h:4314

miopenRNNunidirection

@ miopenRNNunidirection

Definition: miopen.h:4313

miopenRNNwithBias

@ miopenRNNwithBias

Definition: miopen.h:4323

miopenRNNNoBias

@ miopenRNNNoBias

Definition: miopen.h:4322

miopenRNNDataSeqMajorPadded

@ miopenRNNDataSeqMajorPadded

Definition: miopen.h:4359

miopenRNNDataSeqMajorNotPadded

@ miopenRNNDataSeqMajorNotPadded

Definition: miopen.h:4358

miopenRNNDataBatchMajorPadded

@ miopenRNNDataBatchMajorPadded

Definition: miopen.h:4360

miopenRNNDataUnknownLayout

@ miopenRNNDataUnknownLayout

Definition: miopen.h:4357

miopenRNNroundedDynamic

@ miopenRNNroundedDynamic

Definition: miopen.h:4304

miopenRNNfundamental

@ miopenRNNfundamental

Definition: miopen.h:4302

miopenRNNdefault

@ miopenRNNdefault

Definition: miopen.h:4300

miopenRNNTraining

@ miopenRNNTraining

Definition: miopen.h:4348

miopenRNNInference

@ miopenRNNInference

Definition: miopen.h:4349

miopenRNNAlgoGEMM

@ miopenRNNAlgoGEMM

Definition: miopen.h:4331

miopenRNNIOWithPadding

@ miopenRNNIOWithPadding

Definition: miopen.h:4340

miopenRNNIONotPadded

@ miopenRNNIONotPadded

Definition: miopen.h:4339

miopenGetPReLUBackwardWorkspaceSize

miopenStatus_t miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle, miopenTensorDescriptor_t inputDesc, miopenTensorDescriptor_t weightDesc, size_t *sizeInBytes)

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

miopenPReLUBackward

miopenStatus_t miopenPReLUBackward(miopenHandle_t handle, void *workspace, size_t workspaceSizeInBytes, miopenTensorDescriptor_t inputDesc, const void *input, miopenTensorDescriptor_t weightDesc, const void *weight, miopenTensorDescriptor_t doutputDesc, const void *doutput, miopenTensorDescriptor_t dinputDesc, void *dinput, miopenTensorDescriptor_t dweightDesc, void *dweight)

Execute a PReLU backward layer.

miopenReduceExtremeForward

miopenStatus_t miopenReduceExtremeForward(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const void *x, const int32_t dim, const miopenReduceExtremeOp_t reduceExtremeOp, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t indiceDesc, void *indice)

Find the the extreme (minimum, maximum) value and index of a tensor across Dimension.

miopenReduceExtremeOp_t

miopenReduceExtremeOp_t

Definition: miopen.h:6718

miopenRoPEBackward

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

Execute a rope backward layer.

miopenRoPEForward

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

Execute a rope forward layer.

miopenFusedAdam

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

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

miopenTransformersAdamW

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

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

miopenFusedAdamWithOutput

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

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

miopenTransformersAdamWWithOutput

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

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

miopenReduceTensorIndices_t

miopenReduceTensorIndices_t

Definition: miopen.h:581

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

miopenIndicesType_t

miopenIndicesType_t

Definition: miopen.h:591

miopenReduceTensor

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

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

miopenGetReductionIndicesSize

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

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

miopenDestroyReduceTensorDescriptor

miopenStatus_t miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc)

Destroy the ReduceTensor descriptor object.

miopenGetReductionWorkspaceSize

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

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

miopenGetReduceTensorDescriptor

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

Query a ReduceTensor descriptor object.

miopenActivationForward

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

Execute an activation forward layer.

miopenGLUBackward

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

Execute a GLU backward layer.

miopenActivationBackward

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

Execute a activation backwards layer.

miopenActivationMode_t

miopenActivationMode_t

Definition: miopen.h:492

miopenSetActivationDescriptor

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

Sets the activation layer descriptor details.

miopenCreateActivationDescriptor

miopenStatus_t miopenCreateActivationDescriptor(miopenActivationDescriptor_t *activDesc)

Creates the Activation descriptor object.

miopenGetActivationDescriptor

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

Gets the activation layer descriptor details.

miopenGLUForward

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

Execute a GLU forward layer.

miopenDestroyActivationDescriptor

miopenStatus_t miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc)

Destroys the activation descriptor object.

miopenBatchNormalizationForwardInference

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

Execute forward inference layer for batch normalization.

miopenBatchNormalizationForwardInference_V2

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

Execute forward inference layer for batch normalization.

miopenBatchNormForwardTrainingActivation

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

Execute forward training layer for batch normalization with fused activation.

miopenBatchNormBackwardActivation

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

Execute backwards propagation layer for batch normalization with fused activation.

miopenBatchNormalizationForwardTraining_V3

miopenStatus_t miopenBatchNormalizationForwardTraining_V3(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, const void *prevResultRunningMean, const void *prevResultRunningVariance, void *nextResultRunningMean, void *nextResultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance)

Execute forward training layer for batch normalization.

miopenBatchNormalizationForwardTraining

miopenStatus_t miopenBatchNormalizationForwardTraining(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc, void *bnScale, void *bnBias, double expAvgFactor, void *resultRunningMean, void *resultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance)

Execute forward training layer for batch normalization.

miopenBatchNormalizationForwardTraining_V2

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

Execute forward training layer for batch normalization.

miopenBatchNormalizationBackward_V2

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

Execute backwards propagation layer for batch normalization.

miopenBatchNormForwardTrainingActivation_V2

miopenStatus_t miopenBatchNormForwardTrainingActivation_V2(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasVarDesc, const miopenTensorDescriptor_t savedMeanDesc, const miopenTensorDescriptor_t savedVarDesc, void *bnScale, void *bnBias, double expAvgFactor, const void *prevResultRunningMean, const void *prevResultRunningVariance, void *nextResultRunningMean, void *nextResultRunningVariance, double epsilon, void *resultSaveMean, void *resultSaveInvVariance, const miopenActivationDescriptor_t activDesc)

Execute forward training layer for batch normalization with fused activation.

miopenBatchNormalizationForwardInferenceInvVariance

miopenStatus_t miopenBatchNormalizationForwardInferenceInvVariance(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estInvVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedInvVariance)

Execute forward inference layer for batch normalization using inverse variance.

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

miopenBatchNormForwardInferenceActivation

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

Execute forward inference layer for batch normalization with fused activation.

miopenBatchNormForwardInferenceActivationInvVariance

miopenStatus_t miopenBatchNormForwardInferenceActivationInvVariance(miopenHandle_t handle, miopenBatchNormMode_t bn_mode, void *alpha, void *beta, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, const miopenTensorDescriptor_t scaleDesc, const miopenTensorDescriptor_t biasDesc, const miopenTensorDescriptor_t estMeanDesc, const miopenTensorDescriptor_t estInvVarianceDesc, void *bnScale, void *bnBias, void *estimatedMean, void *estimatedInvVariance, const miopenActivationDescriptor_t activDesc)

Execute forward inference layer for batch normalization with fused activation using inverse variance.

miopenDeriveBNTensorDescriptor

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

Derive tensor for gamma and beta from input tensor descriptor.

miopenCatForward

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

Execute a cat forward layer.

miopenInitConvolutionNdDescriptor

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

Creates a N-dimensional convolution layer descriptor.

miopenConvolutionForwardImmediate

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

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

miopenConvolutionBackwardDataCompileSolution

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

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

miopenConvolutionForwardGetSolutionWorkspaceSize

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

Returns the workspace size required for a particular solution id.

miopenConvolutionForward

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

Execute a forward convolution layer.

miopenGetConvolutionGroupCount

miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)

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

miopenGetConvolutionFindMode

miopenStatus_t miopenGetConvolutionFindMode(const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t *findMode)

Reads the Find Mode attribute from the convolution descriptor.

miopenInitConvolutionDescriptor

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

Creates a 2-D convolution layer descriptor.

miopenConvAlgorithm_t

miopenConvAlgorithm_t

Definition: miopen.h:1246

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

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

miopenConvolutionAttrib_t

miopenConvolutionAttrib_t

Definition: miopen.h:603

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

miopenSetConvolutionAttribute

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

Set the attribute of the convolution descriptor.

miopenConvolutionBackwardDataImmediate

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

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

miopenSetTransposeConvNdOutputPadding

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

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

miopenSetConvolutionFindMode

miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t findMode)

Sets the Find Mode attribute in the convolution descriptor.

miopenSetTransposeConvOutputPadding

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

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

miopenConvolutionFindMode_t

miopenConvolutionFindMode_t

Definition: miopen.h:632

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

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

miopenConvolutionAlgoWinograd

@ miopenConvolutionAlgoWinograd

Definition: miopen.h:1250

miopenConvolutionAlgoFFT

@ miopenConvolutionAlgoFFT

Definition: miopen.h:1249

miopenConvolutionAlgoImplicitGEMM

@ miopenConvolutionAlgoImplicitGEMM

Definition: miopen.h:1251

miopenConvolutionAlgoGEMM

@ miopenConvolutionAlgoGEMM

Definition: miopen.h:1247

miopenConvolutionFwdAlgoFFT

@ miopenConvolutionFwdAlgoFFT

Definition: miopen.h:1212

miopenConvolutionFwdAlgoImplicitGEMM

@ miopenConvolutionFwdAlgoImplicitGEMM

Definition: miopen.h:1214

miopenConvolutionFwdAlgoGEMM

@ miopenConvolutionFwdAlgoGEMM

Definition: miopen.h:1210

miopenConvolutionFwdAlgoWinograd

@ miopenConvolutionFwdAlgoWinograd

Definition: miopen.h:1213

miopenConvolutionFwdAlgoDirect

@ miopenConvolutionFwdAlgoDirect

Definition: miopen.h:1211

miopenTransposeBwdDataAlgoGEMM

@ miopenTransposeBwdDataAlgoGEMM

Definition: miopen.h:1237

miopenConvolutionBwdDataAlgoDirect

@ miopenConvolutionBwdDataAlgoDirect

Definition: miopen.h:1234

miopenConvolutionBwdDataAlgoGEMM

@ miopenConvolutionBwdDataAlgoGEMM

Definition: miopen.h:1233

miopenConvolutionBwdDataAlgoFFT

@ miopenConvolutionBwdDataAlgoFFT

Definition: miopen.h:1235

miopenConvolutionBwdDataAlgoWinograd

@ miopenConvolutionBwdDataAlgoWinograd

Definition: miopen.h:1236

miopenConvolutionBwdDataAlgoImplicitGEMM

@ miopenConvolutionBwdDataAlgoImplicitGEMM

Definition: miopen.h:1239

miopenConvolutionBwdWeightsAlgoGEMM

@ miopenConvolutionBwdWeightsAlgoGEMM

Definition: miopen.h:1222

miopenConvolutionBwdWeightsAlgoWinograd

@ miopenConvolutionBwdWeightsAlgoWinograd

Definition: miopen.h:1224

miopenConvolutionBwdWeightsAlgoDirect

@ miopenConvolutionBwdWeightsAlgoDirect

Definition: miopen.h:1223

miopenConvolutionBwdWeightsAlgoImplicitGEMM

@ miopenConvolutionBwdWeightsAlgoImplicitGEMM

Definition: miopen.h:1225

miopenDestroyDropoutDescriptor

miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)

Destroys the dropout descriptor object.

miopenRNGType_t

miopenRNGType_t

Definition: miopen.h:5794

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

miopenFindResultsOrder_t

miopenFindResultsOrder_t

Definition: miopen.h:6225

miopenGetSolutionSolverId

miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution, uint64_t *solverId)

Reads id of the solver referred by the solution.

miopenSetSoftmaxDescriptor

miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc, float alpha, float beta, miopenSoftmaxAlgorithm_t algorithm, miopenSoftmaxMode_t mode)

Sets the softmax descriptor details.

miopenGetSolutionTime

miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float *time)

Reads the time spent to execute the solution the last it was run.

miopenGetMhaDescriptor

miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float *scale)

Gets the Mha descriptor details.

miopenMhaMask_t

miopenMhaMask_t

Initializes a problem object describing a Mha operation.

Definition: miopen.h:6253

miopenSetMhaDescriptor

miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale)

Sets the Mha descriptor details.

miopenSetFindOptionWorkspaceLimit

miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options, size_t value)

Sets the workspace limit find option. Default value is maximum of size_t.

miopenSetFindOptionPreallocatedTensor

miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options, miopenTensorArgumentId_t id, void *buffer)

Attaches a preallocated tensor to find options. If not used, buffers are allocated by MIOpen internal...

miopenCreateSoftmaxProblem

miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t *problem, miopenSoftmaxDescriptor_t operatorDesc, miopenProblemDirection_t direction)

Initializes a problem object describing a softmax operation.

miopenDestroyFindOptions

miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options)

Destroys miopenFindOptions object.

miopenSetFindOptionAttachBinaries

miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options, unsigned attach)

Forces library to attach kernel binaries to solutions for later saving. This allows zero lookup miope...

miopenFuseProblems

miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2)

Fuse two problems into a single one. Problems can be either regular, or fused. No problems are dispos...

miopenGetSolutionSize

miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t *size)

Reads the expected size of a solution.

miopenTensorArgumentId_t

miopenTensorArgumentId_t

Definition: miopen.h:6144

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 execute the solution.

miopenSetFindOptionResultsOrder

miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options, miopenFindResultsOrder_t value)

Sets the results order find option. Default value is miopenFindResultsOrderByTime.

miopenRunSolution

miopenStatus_t miopenRunSolution(miopenHandle_t handle, miopenSolution_t solution, size_t nInputs, const miopenTensorArgument_t *tensors, void *workspace, size_t workspaceSize)

Runs the solution using the passed in buffers.

miopenCreateMhaProblem

miopenStatus_t miopenCreateMhaProblem(miopenProblem_t *problem, miopenMhaDescriptor_t operatorDesc, miopenProblemDirection_t direction)

miopenProblemDirection_t

miopenProblemDirection_t

Definition: miopen.h:6131

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

miopenFindResultsOrderByTime

@ miopenFindResultsOrderByTime

Definition: miopen.h:6226

miopenMhaMaskCausal

@ miopenMhaMaskCausal

Definition: miopen.h:6255

miopenMhaMaskNone

@ miopenMhaMaskNone

Definition: miopen.h:6254

miopenTensorMhaDescaleS

@ miopenTensorMhaDescaleS

Definition: miopen.h:6156

miopenTensorMhaO

@ miopenTensorMhaO

Definition: miopen.h:6162

miopenTensorMhaAmaxDV

@ miopenTensorMhaAmaxDV

Definition: miopen.h:6180

miopenTensorBatchnormScaleDiff

@ miopenTensorBatchnormScaleDiff

Definition: miopen.h:6203

miopenTensorMhaMask

@ miopenTensorMhaMask

Definition: miopen.h:6214

miopenTensorMhaDescaleDS

@ miopenTensorMhaDescaleDS

Definition: miopen.h:6170

miopenTensorMhaDropoutSeed

@ miopenTensorMhaDropoutSeed

Definition: miopen.h:6160

miopenTensorBatchnormSavedMean

@ miopenTensorBatchnormSavedMean

Definition: miopen.h:6200

miopenTensorActivationDY

@ miopenTensorActivationDY

Definition: miopen.h:6188

miopenTensorBatchnormDX

@ miopenTensorBatchnormDX

Definition: miopen.h:6208

miopenTensorMhaDescaleV

@ miopenTensorMhaDescaleV

Definition: miopen.h:6155

miopenTensorMhaK

@ miopenTensorMhaK

Definition: miopen.h:6150

miopenTensorConvolutionX

@ miopenTensorConvolutionX

Definition: miopen.h:6146

miopenTensorMhaAmaxDK

@ miopenTensorMhaAmaxDK

Definition: miopen.h:6179

miopenTensorMhaScaleDS

@ miopenTensorMhaScaleDS

Definition: miopen.h:6171

miopenTensorBatchnormBias

@ miopenTensorBatchnormBias

Definition: miopen.h:6206

miopenTensorMhaM

@ miopenTensorMhaM

Definition: miopen.h:6165

miopenTensorBatchnormRunningMean

@ miopenTensorBatchnormRunningMean

Definition: miopen.h:6198

miopenTensorMhaDropoutProbability

@ miopenTensorMhaDropoutProbability

Definition: miopen.h:6159

miopenTensorSoftmaxY

@ miopenTensorSoftmaxY

Definition: miopen.h:6193

miopenTensorSoftmaxDY

@ miopenTensorSoftmaxDY

Definition: miopen.h:6195

miopenTensorMhaDescaleO

@ miopenTensorMhaDescaleO

Definition: miopen.h:6168

miopenTensorMhaScaleO

@ miopenTensorMhaScaleO

Definition: miopen.h:6158

miopenScalarBatchnormExpAvgFactor

@ miopenScalarBatchnormExpAvgFactor

Definition: miopen.h:6216

miopenTensorBatchnormScale

@ miopenTensorBatchnormScale

Definition: miopen.h:6202

miopenTensorBatchnormRunningVariance

@ miopenTensorBatchnormRunningVariance

Definition: miopen.h:6199

miopenTensorActivationDX

@ miopenTensorActivationDX

Definition: miopen.h:6187

miopenTensorMhaScaleDK

@ miopenTensorMhaScaleDK

Definition: miopen.h:6173

miopenTensorMhaV

@ miopenTensorMhaV

Definition: miopen.h:6152

miopenTensorMhaAmaxS

@ miopenTensorMhaAmaxS

Definition: miopen.h:6164

miopenTensorBatchnormBiasDiff

@ miopenTensorBatchnormBiasDiff

Definition: miopen.h:6207

miopenTensorBatchnormSavedVariance

@ miopenTensorBatchnormSavedVariance

Definition: miopen.h:6201

miopenTensorActivationX

@ miopenTensorActivationX

Definition: miopen.h:6185

miopenTensorMhaScaleDV

@ miopenTensorMhaScaleDV

Definition: miopen.h:6174

miopenTensorMhaAmaxO

@ miopenTensorMhaAmaxO

Definition: miopen.h:6163

miopenScalarBatchnormEpsilon

@ miopenScalarBatchnormEpsilon

Definition: miopen.h:6217

miopenTensorMhaScaleDQ

@ miopenTensorMhaScaleDQ

Definition: miopen.h:6172

miopenTensorSoftmaxDX

@ miopenTensorSoftmaxDX

Definition: miopen.h:6194

miopenTensorMhaAmaxDS

@ miopenTensorMhaAmaxDS

Definition: miopen.h:6181

miopenTensorMhaDV

@ miopenTensorMhaDV

Definition: miopen.h:6177

miopenTensorMhaQ

@ miopenTensorMhaQ

Definition: miopen.h:6151

miopenTensorMhaAmaxDQ

@ miopenTensorMhaAmaxDQ

Definition: miopen.h:6178

miopenTensorConvolutionY

@ miopenTensorConvolutionY

Definition: miopen.h:6148

miopenTensorBatchnormEstimatedMean

@ miopenTensorBatchnormEstimatedMean

Definition: miopen.h:6204

miopenTensorBatchnormDY

@ miopenTensorBatchnormDY

Definition: miopen.h:6209

miopenTensorMhaZInv

@ miopenTensorMhaZInv

Definition: miopen.h:6166

miopenTensorMhaDescaleQ

@ miopenTensorMhaDescaleQ

Definition: miopen.h:6154

miopenTensorMhaBias

@ miopenTensorMhaBias

Definition: miopen.h:6182

miopenTensorBatchnormEstimatedVariance

@ miopenTensorBatchnormEstimatedVariance

Definition: miopen.h:6205

miopenTensorArgumentIsScalar

@ miopenTensorArgumentIsScalar

Definition: miopen.h:6212

miopenTensorArgumentIdInvalid

@ miopenTensorArgumentIdInvalid

Definition: miopen.h:6145

miopenTensorMhaDO

@ miopenTensorMhaDO

Definition: miopen.h:6167

miopenTensorMhaDescaleDO

@ miopenTensorMhaDescaleDO

Definition: miopen.h:6169

miopenTensorConvolutionW

@ miopenTensorConvolutionW

Definition: miopen.h:6147

miopenTensorMhaDescaleK

@ miopenTensorMhaDescaleK

Definition: miopen.h:6153

miopenTensorMhaDropoutOffset

@ miopenTensorMhaDropoutOffset

Definition: miopen.h:6161

miopenTensorBiasY

@ miopenTensorBiasY

Definition: miopen.h:6190

miopenTensorMhaDQ

@ miopenTensorMhaDQ

Definition: miopen.h:6175

miopenTensorSoftmaxX

@ miopenTensorSoftmaxX

Definition: miopen.h:6192

miopenTensorBatchnormY

@ miopenTensorBatchnormY

Definition: miopen.h:6197

miopenTensorMhaScaleS

@ miopenTensorMhaScaleS

Definition: miopen.h:6157

miopenTensorBias

@ miopenTensorBias

Definition: miopen.h:6191

miopenTensorActivationY

@ miopenTensorActivationY

Definition: miopen.h:6186

miopenTensorBatchnormX

@ miopenTensorBatchnormX

Definition: miopen.h:6196

miopenTensorBiasX

@ miopenTensorBiasX

Definition: miopen.h:6189

miopenTensorMhaDK

@ miopenTensorMhaDK

Definition: miopen.h:6176

miopenProblemDirectionBackwardWeights

@ miopenProblemDirectionBackwardWeights

Definition: miopen.h:6134

miopenProblemDirectionInference

@ miopenProblemDirectionInference

Definition: miopen.h:6136

miopenProblemDirectionForward

@ miopenProblemDirectionForward

Definition: miopen.h:6132

miopenProblemDirectionBackward

@ miopenProblemDirectionBackward

Definition: miopen.h:6133

miopenGetGetitemWorkspaceSize

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

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

miopenGetitemBackward

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

Execute a getitem backward layer.

miopenGroupNormForward

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

Execute a groupnorm forward layer.

miopenCreateWithStream

miopenStatus_t miopenCreateWithStream(miopenHandle_t *handle, miopenAcceleratorQueue_t stream)

Create a MIOpen handle with an accelerator stream.

miopenDestroy

miopenStatus_t miopenDestroy(miopenHandle_t handle)

Destroys the MIOpen handle.

miopenTuningPolicy_t

miopenTuningPolicy_t

Definition: miopen.h:8012

miopenGetTuningPolicy

miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t *value)

Get tuning policy from a handle.

miopenDeallocatorFunction

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

Custom deallocator function.

Definition: miopen.h:129

miopenMathType_t

miopenMathType_t

Definition: miopen.h:87

miopenGetStream

miopenStatus_t miopenGetStream(miopenHandle_t handle, miopenAcceleratorQueue_t *streamID)

Get the previously created accelerator command queue.

miopenEnableProfiling

miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable)

Enable profiling to retrieve kernel time.

miopenGetVersion

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

Method to return version of MIOpen.

miopenSetTuningPolicy

miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t newValue)

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

miopenStatus_t

miopenStatus_t

Definition: miopen.h:72

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

miopenAllocatorFunction

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

Custom allocator function.

Definition: miopen.h:119

miopenGetErrorString

const char * miopenGetErrorString(miopenStatus_t error)

Get character string for an error code.

miopenCreate

miopenStatus_t miopenCreate(miopenHandle_t *handle)

Method to create the MIOpen handle object.

miopenGetKernelTime

miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float *time)

Get time for last kernel launched.

miopenSetStream

miopenStatus_t miopenSetStream(miopenHandle_t handle, miopenAcceleratorQueue_t streamID)

Set accelerator command queue previously created.

miopenMathDefault

@ miopenMathDefault

Definition: miopen.h:89

miopenMathPedantic

@ miopenMathPedantic

Definition: miopen.h:90

miopenStatusUnsupportedOp

@ miopenStatusUnsupportedOp

Definition: miopen.h:81

miopenStatusGpuOperationsSkipped

@ miopenStatusGpuOperationsSkipped

Definition: miopen.h:82

miopenStatusUnknownError

@ miopenStatusUnknownError

Definition: miopen.h:80

miopenStatusSuccess

@ miopenStatusSuccess

Definition: miopen.h:73

miopenStatusVersionMismatch

@ miopenStatusVersionMismatch

Definition: miopen.h:83

miopenStatusAllocFailed

@ miopenStatusAllocFailed

Definition: miopen.h:77

miopenStatusNotImplemented

@ miopenStatusNotImplemented

Definition: miopen.h:79

miopenStatusBadParm

@ miopenStatusBadParm

Definition: miopen.h:76

miopenStatusNotInitialized

@ miopenStatusNotInitialized

Definition: miopen.h:74

miopenStatusInternalError

@ miopenStatusInternalError

Definition: miopen.h:78

miopenStatusInvalidValue

@ miopenStatusInvalidValue

Definition: miopen.h:75

miopenF8RoundingModeStandard

@ miopenF8RoundingModeStandard

Definition: miopen.h:97

miopenF8RoundingModeStochastic

@ miopenF8RoundingModeStochastic

Definition: miopen.h:98

miopenKthvalueForward

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

Execute a Kthvalue forward layer.

miopenLayerNormForward

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

Execute a layernorm forward layer.

miopenT5LayerNormBackward

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

Execute a T5layernorm backward layer.

miopenLayerNormBackward

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

Execute a layernorm backward layer.

miopenT5LayerNormForward

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

Execute a T5layernorm forward layer.

miopenNormMode_t

miopenNormMode_t

Definition: miopen.h:463

miopenGetLayerNormBackwardWorkspaceSize

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

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

miopenGetT5LayerNormBackwardWorkspaceSize

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

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

miopenAddLayerNormForward

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

Execute a add and layernorm forward layer.

miopenSet2dPoolingDescriptor

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

Sets a 2-D pooling layer descriptor details.

miopenSetPoolingWorkSpaceIndexMode

miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index)

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

miopenGetPoolingForwardOutputDim

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

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

miopenPoolingGetWorkSpaceSize

miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Get the amount of GPU memory required for pooling.

miopenSetNdPoolingDescriptor

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

Set details of a N-D pooling layer descriptor.

miopenPoolingForward

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

Execute a forward pooling layer.

miopenPoolingMode_t

miopenPoolingMode_t

Definition: miopen.h:430

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

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

miopenGetPoolingNdForwardOutputDim

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

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

miopenGetNdPoolingDescriptor

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

Get details of a N-D pooling layer descriptor.

miopenCreatePoolingDescriptor

miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t *poolDesc)

Creates a pooling layer descriptor.

miopenSetPoolingIndexType

miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t index_type)

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

miopenGet2dPoolingDescriptor

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

Gets a 2-D pooling layer descriptor details.

miopenDestroyPoolingDescriptor

miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc)

Destroys the pooling descriptor object.

miopenPoolingBackward

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

Execute a backward pooling layer.

miopenReduceCalculationForward

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

Execute a reducecalculation forward layer.

miopenReduceCalculationOp_t

miopenReduceCalculationOp_t

Definition: miopen.h:6658

miopenGetReduceCalculationWorkspaceSize

miopenStatus_t miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle, const miopenTensorDescriptor_t xDesc, const int32_t dim, const miopenReduceCalculationOp_t reduceCalculationOp, const miopenTensorDescriptor_t reduceDesc, size_t *sizeInBytes)

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

MIOPEN_REDUCE_CALCULATION_PROD

@ MIOPEN_REDUCE_CALCULATION_PROD

Definition: miopen.h:6659

MIOPEN_REDUCE_CALCULATION_SUM

@ MIOPEN_REDUCE_CALCULATION_SUM

Definition: miopen.h:6661

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

miopenSoftmaxAlgorithm_t

miopenSoftmaxAlgorithm_t

Definition: miopen.h:515

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

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

miopenCreateSeqTensorDescriptor

miopenStatus_t miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t *tensorDesc)

Create a Tensor Descriptor for sequence data.

miopenTensorOp_t

miopenTensorOp_t

Definition: miopen.h:395

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

miopenPaddingDefault

@ miopenPaddingDefault

Definition: miopen.h:420

miopenPaddingSame

@ miopenPaddingSame

Definition: miopen.h:421

miopenPaddingValid

@ miopenPaddingValid

Definition: miopen.h:422

miopenReduceCalculationNanPropagation_t

miopenReduceCalculationNanPropagation_t

Definition: miopen.h:6642

MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

Definition: miopen.h:6644

MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

Definition: miopen.h:6643

miopenAlphaBetaCase_t

miopenAlphaBetaCase_t

Enum for specifying the alpha-beta case for convolution operations.

Definition: miopen.h:6965

SCALE

@ SCALE

Definition: miopen.h:6972

BILINEAR

@ BILINEAR

Definition: miopen.h:6973

DEFAULT

@ DEFAULT

Definition: miopen.h:6971

ERROR_STATE

@ ERROR_STATE

Definition: miopen.h:6974

MIOPEN_DECLARE_OBJECT

#define MIOPEN_DECLARE_OBJECT(name)

Definition: miopen.h:46

miopenNanPropagation_t

miopenNanPropagation_t

Definition: miopen.h:571

MIOPEN_PROPAGATE_NAN

@ MIOPEN_PROPAGATE_NAN

Definition: miopen.h:573

MIOPEN_NOT_PROPAGATE_NAN

@ MIOPEN_NOT_PROPAGATE_NAN

Definition: miopen.h:572

miopenAcceleratorQueue_t

hipStream_t miopenAcceleratorQueue_t

Definition: miopen.h:56

MIOPEN_LOSS_REDUCTION_MEAN

@ MIOPEN_LOSS_REDUCTION_MEAN

Definition: miopen.h:7832

MIOPEN_LOSS_REDUCTION_SUM

@ MIOPEN_LOSS_REDUCTION_SUM

Definition: miopen.h:7831

MIOPEN_LOSS_REDUCTION_NONE

@ MIOPEN_LOSS_REDUCTION_NONE

Definition: miopen.h:7830

miopenTuningPolicyDbClean

@ miopenTuningPolicyDbClean

Definition: miopen.h:8018

miopenTuningPolicyDbUpdate

@ miopenTuningPolicyDbUpdate

Definition: miopen.h:8014

miopenTuningPolicyNone

@ miopenTuningPolicyNone

Definition: miopen.h:8013

miopenTuningPolicySearch

@ miopenTuningPolicySearch

Definition: miopen.h:8015

miopenTuningPolicySearchDbUpdate

@ miopenTuningPolicySearchDbUpdate

Definition: miopen.h:8017

miopenPoolingAverage

@ miopenPoolingAverage

Definition: miopen.h:432

miopenPoolingAverageInclusive

@ miopenPoolingAverageInclusive

Definition: miopen.h:433

miopenPoolingMax

@ miopenPoolingMax

Definition: miopen.h:431

miopenTensorCHWN

@ miopenTensorCHWN

Definition: miopen.h:369

miopenTensorNHWC

@ miopenTensorNHWC

Definition: miopen.h:368

miopenTensorNDHWC

@ miopenTensorNDHWC

Definition: miopen.h:375

miopenTensorNCHW

@ miopenTensorNCHW

Definition: miopen.h:367

miopenTensorCHWNc4

@ miopenTensorCHWNc4

Definition: miopen.h:372

miopenTensorNCHWc8

@ miopenTensorNCHWc8

Definition: miopen.h:371

miopenTensorNCDHW

@ miopenTensorNCDHW

Definition: miopen.h:374

miopenTensorCHWNc8

@ miopenTensorCHWNc8

Definition: miopen.h:373

miopenTensorNCHWc4

@ miopenTensorNCHWc4

Definition: miopen.h:370

MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

Definition: miopen.h:583

MIOPEN_REDUCE_TENSOR_NO_INDICES

@ MIOPEN_REDUCE_TENSOR_NO_INDICES

Definition: miopen.h:582

miopenActivationLEAKYRELU

@ miopenActivationLEAKYRELU

Definition: miopen.h:502

miopenActivationPASTHRU

@ miopenActivationPASTHRU

Definition: miopen.h:493

miopenActivationABS

@ miopenActivationABS

Definition: miopen.h:498

miopenActivationLOGISTIC

@ miopenActivationLOGISTIC

Definition: miopen.h:494

miopenActivationCLIPPEDRELU

@ miopenActivationCLIPPEDRELU

Definition: miopen.h:500

miopenActivationRELU

@ miopenActivationRELU

Definition: miopen.h:496

miopenActivationPOWER

@ miopenActivationPOWER

Definition: miopen.h:499

miopenActivationELU

@ miopenActivationELU

Definition: miopen.h:504

miopenActivationCLAMP

@ miopenActivationCLAMP

Definition: miopen.h:507

miopenActivationSOFTRELU

@ miopenActivationSOFTRELU

Definition: miopen.h:497

miopenActivationTANH

@ miopenActivationTANH

Definition: miopen.h:495

MIOPEN_REDUCE_TENSOR_MUL

@ MIOPEN_REDUCE_TENSOR_MUL

Definition: miopen.h:548

MIOPEN_REDUCE_TENSOR_MAX

@ MIOPEN_REDUCE_TENSOR_MAX

Definition: miopen.h:552

MIOPEN_REDUCE_TENSOR_AVG

@ MIOPEN_REDUCE_TENSOR_AVG

Definition: miopen.h:556

MIOPEN_REDUCE_TENSOR_NORM1

@ MIOPEN_REDUCE_TENSOR_NORM1

Definition: miopen.h:558

MIOPEN_REDUCE_TENSOR_AMAX

@ MIOPEN_REDUCE_TENSOR_AMAX

Definition: miopen.h:554

MIOPEN_REDUCE_TENSOR_MIN

@ MIOPEN_REDUCE_TENSOR_MIN

Definition: miopen.h:550

MIOPEN_REDUCE_TENSOR_ADD

@ MIOPEN_REDUCE_TENSOR_ADD

Definition: miopen.h:547

MIOPEN_REDUCE_TENSOR_NORM2

@ MIOPEN_REDUCE_TENSOR_NORM2

Definition: miopen.h:560

MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

Definition: miopen.h:608

MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

Definition: miopen.h:612

MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE

@ MIOPEN_CONVOLUTION_ATTRIB_MATH_TYPE

Definition: miopen.h:621

MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

Definition: miopen.h:604

miopenIndexUint16

@ miopenIndexUint16

Definition: miopen.h:385

miopenIndexUint64

@ miopenIndexUint64

Definition: miopen.h:387

miopenIndexUint32

@ miopenIndexUint32

Definition: miopen.h:386

miopenIndexUint8

@ miopenIndexUint8

Definition: miopen.h:384

miopenFloat

@ miopenFloat

Definition: miopen.h:348

miopenBFloat8_fnuz

@ miopenBFloat8_fnuz

Definition: miopen.h:356

miopenBFloat16

@ miopenBFloat16

Definition: miopen.h:352

miopenInt8

@ miopenInt8

Definition: miopen.h:350

miopenInt32

@ miopenInt32

Definition: miopen.h:349

miopenHalf

@ miopenHalf

Definition: miopen.h:347

miopenInt64

@ miopenInt64

Definition: miopen.h:357

miopenDouble

@ miopenDouble

Definition: miopen.h:354

miopenFloat8_fnuz

@ miopenFloat8_fnuz

Definition: miopen.h:355

MIOPEN_8BIT_INDICES

@ MIOPEN_8BIT_INDICES

Definition: miopen.h:595

MIOPEN_32BIT_INDICES

@ MIOPEN_32BIT_INDICES

Definition: miopen.h:592

MIOPEN_16BIT_INDICES

@ MIOPEN_16BIT_INDICES

Definition: miopen.h:594

MIOPEN_64BIT_INDICES

@ MIOPEN_64BIT_INDICES

Definition: miopen.h:593

miopenPoolingWorkspaceIndexImage

@ miopenPoolingWorkspaceIndexImage

Definition: miopen.h:445

miopenPoolingWorkspaceIndexMask

@ miopenPoolingWorkspaceIndexMask

Definition: miopen.h:444

miopenDepthwise

@ miopenDepthwise

Definition: miopen.h:411

miopenGroupConv

@ miopenGroupConv

Definition: miopen.h:410

miopenTranspose

@ miopenTranspose

Definition: miopen.h:409

miopenConvolution

@ miopenConvolution

Definition: miopen.h:408

MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

Definition: miopen.h:467

MIOPEN_WEIGHT_BIAS

@ MIOPEN_WEIGHT_BIAS

Definition: miopen.h:465

MIOPEN_ELEMENTWISE_AFFINE

@ MIOPEN_ELEMENTWISE_AFFINE

Definition: miopen.h:464

MIOPEN_WEIGHT_BIAS_T5

@ MIOPEN_WEIGHT_BIAS_T5

Definition: miopen.h:473

MIOPEN_ELEMENTWISE_AFFINE_T5

@ MIOPEN_ELEMENTWISE_AFFINE_T5

Definition: miopen.h:471

MIOPEN_WEIGHT_BIAS_FUSED_ADD

@ MIOPEN_WEIGHT_BIAS_FUSED_ADD

Definition: miopen.h:469

MIOPEN_REDUCE_EXTREME_ARGMAX

@ MIOPEN_REDUCE_EXTREME_ARGMAX

Definition: miopen.h:6721

MIOPEN_REDUCE_EXTREME_MIN

@ MIOPEN_REDUCE_EXTREME_MIN

Definition: miopen.h:6723

MIOPEN_REDUCE_EXTREME_MAX

@ MIOPEN_REDUCE_EXTREME_MAX

Definition: miopen.h:6725

MIOPEN_REDUCE_EXTREME_ARGMIN

@ MIOPEN_REDUCE_EXTREME_ARGMIN

Definition: miopen.h:6719

miopenTensorOpMin

@ miopenTensorOpMin

Definition: miopen.h:398

miopenTensorOpAdd

@ miopenTensorOpAdd

Definition: miopen.h:396

miopenTensorOpMul

@ miopenTensorOpMul

Definition: miopen.h:397

miopenTensorOpMax

@ miopenTensorOpMax

Definition: miopen.h:399

miopenBNSpatial

@ miopenBNSpatial

Definition: miopen.h:484

miopenBNPerActivation

@ miopenBNPerActivation

Definition: miopen.h:483

miopenConvolutionFindModeDynamicHybrid

@ miopenConvolutionFindModeDynamicHybrid

Definition: miopen.h:644

miopenConvolutionFindModeDefault

@ miopenConvolutionFindModeDefault

Definition: miopen.h:651

miopenConvolutionFindModeTrustVerifyFull

@ miopenConvolutionFindModeTrustVerifyFull

Definition: miopen.h:650

miopenConvolutionFindModeTrustVerify

@ miopenConvolutionFindModeTrustVerify

Definition: miopen.h:649

miopenConvolutionFindModeHybrid

@ miopenConvolutionFindModeHybrid

Definition: miopen.h:639

miopenConvolutionFindModeFast

@ miopenConvolutionFindModeFast

Definition: miopen.h:635

miopenConvolutionFindModeNormal

@ miopenConvolutionFindModeNormal

Definition: miopen.h:633

miopenLRNWithinChannel

@ miopenLRNWithinChannel

Definition: miopen.h:454

miopenLRNCrossChannel

@ miopenLRNCrossChannel

Definition: miopen.h:455

MIOPEN_SOFTMAX_MODE_INSTANCE

@ MIOPEN_SOFTMAX_MODE_INSTANCE

Definition: miopen.h:527

MIOPEN_SOFTMAX_MODE_CHANNEL

@ MIOPEN_SOFTMAX_MODE_CHANNEL

Definition: miopen.h:528

MIOPEN_SOFTMAX_FAST

@ MIOPEN_SOFTMAX_FAST

Definition: miopen.h:516

MIOPEN_SOFTMAX_ACCURATE

@ MIOPEN_SOFTMAX_ACCURATE

Definition: miopen.h:517

MIOPEN_SOFTMAX_LOG

@ MIOPEN_SOFTMAX_LOG

Definition: miopen.h:518

miopenConvAlgoPerf_t

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

Definition: miopen.h:1261

miopenConvAlgoPerf_t::fwd_algo

miopenConvFwdAlgorithm_t fwd_algo

Definition: miopen.h:1264

miopenConvAlgoPerf_t::bwd_data_algo

miopenConvBwdDataAlgorithm_t bwd_data_algo

Definition: miopen.h:1268

miopenConvAlgoPerf_t::memory

size_t memory

Definition: miopen.h:1272

miopenConvAlgoPerf_t::bwd_weights_algo

miopenConvBwdWeightsAlgorithm_t bwd_weights_algo

Definition: miopen.h:1265

miopenConvAlgoPerf_t::time

float time

Definition: miopen.h:1271

miopenConvSolution_t

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

Definition: miopen.h:1285

miopenConvSolution_t::algorithm

miopenConvAlgorithm_t algorithm

Definition: miopen.h:1292

miopenConvSolution_t::solution_id

uint64_t solution_id

Definition: miopen.h:1291

miopenConvSolution_t::workspace_size

size_t workspace_size

Definition: miopen.h:1289

miopenConvSolution_t::time

float time

Definition: miopen.h:1286

miopenTensorArgument_t

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

Definition: miopen.h:6456

miopenTensorArgument_t::id

miopenTensorArgumentId_t id

Definition: miopen.h:6459

miopenTensorArgument_t::buffer

void * buffer

Definition: miopen.h:6469

miopenTensorArgument_t::descriptor

miopenTensorDescriptor_t * descriptor

Definition: miopen.h:6465