/build/miopen-6znSIU/miopen-10.0+dfsg/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

53extern "C" {

54#endif

55

56typedef hipStream_t miopenAcceleratorQueue_t;

57

61MIOPEN_DECLARE_OBJECT(miopenHandle);

62

67

71typedef 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

86typedef 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

95typedef enum

96{

97 miopenF8RoundingModeStandard = 0,

98 miopenF8RoundingModeStochastic = 1,

99} miopenF8RoundingMode_t;

100#endif

101

109MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);

110

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

120

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

130

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

145

158MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);

159

174MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,

175 miopenAcceleratorQueue_t stream);

176

183MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);

184

192MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,

193 miopenAcceleratorQueue_t streamID);

194

202MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,

203 miopenAcceleratorQueue_t* streamID);

204

221MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,

222 miopenAllocatorFunction allocator,

223 miopenDeallocatorFunction deallocator,

224 void* allocatorContext);

225

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

238

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

248// CLOSEOUT HANDLE DOXYGEN GROUP

249

257MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);

258

266MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);

267

274MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);

275

283MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);

284

292MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);

293

301MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);

302

309MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);

310

314MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);

315

319MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);

320

324MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);

325

329MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);

330

334MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);

335

339MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);

340

345typedef 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

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

382typedef enum

383{

384 miopenIndexUint8 = 0,

385 miopenIndexUint16 = 1,

386 miopenIndexUint32 = 2,

387 miopenIndexUint64 = 3,

388} miopenIndexType_t;

389

394typedef enum

395{

396 miopenTensorOpAdd = 0,

397 miopenTensorOpMul = 1,

398 miopenTensorOpMin = 2,

399 miopenTensorOpMax = 3,

400} miopenTensorOp_t;

401

406typedef enum

407{

408 miopenConvolution = 0,

409 miopenTranspose = 1,

410 miopenGroupConv = 2,

411 miopenDepthwise = 3,

412} miopenConvolutionMode_t;

413

418typedef enum

419{

420 miopenPaddingDefault = 0,

421 miopenPaddingSame = 1,

422 miopenPaddingValid = 2,

423} miopenPaddingMode_t;

424

429typedef enum

430{

431 miopenPoolingMax = 0,

432 miopenPoolingAverage = 1,

433 miopenPoolingAverageInclusive = 2,

434} miopenPoolingMode_t;

435

442typedef enum

443{

444 miopenPoolingWorkspaceIndexMask = 0,

445 miopenPoolingWorkspaceIndexImage = 1,

446} miopenPoolingWorkspaceIndexMode_t;

447

452typedef enum

453{

454 miopenLRNWithinChannel = 0,

455 miopenLRNCrossChannel = 1,

456} miopenLRNMode_t;

457#ifdef MIOPEN_BETA_API

462typedef 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

481typedef enum

482{

483 miopenBNPerActivation = 0,

484 miopenBNSpatial = 1,

485} miopenBatchNormMode_t;

486

491typedef 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

514typedef enum

515{

516 MIOPEN_SOFTMAX_FAST = 0,

517 MIOPEN_SOFTMAX_ACCURATE = 1,

518 MIOPEN_SOFTMAX_LOG = 2,

519} miopenSoftmaxAlgorithm_t;

520

525typedef 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

545typedef 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

570typedef enum

571{

572 MIOPEN_NOT_PROPAGATE_NAN = 0,

573 MIOPEN_PROPAGATE_NAN = 1,

574} miopenNanPropagation_t;

575

580typedef enum

581{

582 MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,

583 MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,

584} miopenReduceTensorIndices_t;

585

590typedef 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

602typedef 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

631typedef 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

659

666MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);

667

680MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(

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

682

693MIOPEN_EXPORT miopenStatus_t

694miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,

695 miopenDataType_t dataType,

696 miopenTensorLayout_t tensorLayout,

697 const int* lens,

698 int num_lens);

718MIOPEN_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

745MIOPEN_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

766MIOPEN_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

775MIOPEN_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

792MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,

793 miopenDataType_t cast_type);

794#endif

795

804MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,

805 int* size);

806

815MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

816 miopenDataType_t* dataType,

817 int* dimsA,

818 int* stridesA);

819

825MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);

826

833MIOPEN_EXPORT miopenStatus_t

834miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);

835

841MIOPEN_EXPORT miopenStatus_t

842miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);

843

863MIOPEN_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

885MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,

886 const miopenTensorDescriptor_t yDesc,

887 void* y,

888 const void* alpha);

889

900MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,

901 const miopenTensorDescriptor_t yDesc,

902 void* y,

903 const void* alpha);

904

911MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,

912 size_t* numBytes);

913

931MIOPEN_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

946

952MIOPEN_EXPORT miopenStatus_t

953miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);

954

970MIOPEN_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

989MIOPEN_EXPORT miopenStatus_t

990miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

991 int spatialDim,

992 const int* padA,

993 const int* strideA,

994 const int* dilationA,

995 miopenConvolutionMode_t c_mode);

996

1003MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,

1004 int* spatialDim);

1005

1021MIOPEN_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

1041MIOPEN_EXPORT miopenStatus_t

1042miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1043 int requestedSpatialDim,

1044 int* spatialDim,

1045 int* padA,

1046 int* strideA,

1047 int* dilationA,

1048 miopenConvolutionMode_t* c_mode);

1049

1056MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1057 int* groupCount);

1058

1072MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1073 int groupCount);

1074

1087MIOPEN_EXPORT miopenStatus_t

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

1089

1102MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(

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

1104

1122MIOPEN_EXPORT miopenStatus_t

1123miopenGetConvolutionForwardOutputDim(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

1144MIOPEN_EXPORT miopenStatus_t

1145miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1146 const miopenTensorDescriptor_t inputTensorDesc,

1147 const miopenTensorDescriptor_t filterDesc,

1148 int* nDim,

1149 int* outputTensorDimA);

1150

1156MIOPEN_EXPORT miopenStatus_t

1157miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);

1158

1165MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1166 const miopenConvolutionAttrib_t attr,

1167 int value);

1168

1175MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1176 const miopenConvolutionAttrib_t attr,

1177 int* value);

1178

1192MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,

1193 miopenConvolutionFindMode_t findMode);

1194

1201MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(

1202 const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);

1203

1208typedef enum

1209{

1210 miopenConvolutionFwdAlgoGEMM = 0,

1211 miopenConvolutionFwdAlgoDirect = 1,

1212 miopenConvolutionFwdAlgoFFT = 2,

1213 miopenConvolutionFwdAlgoWinograd = 3,

1214 miopenConvolutionFwdAlgoImplicitGEMM = 5,

1215} miopenConvFwdAlgorithm_t;

1216

1220typedef enum

1221{

1222 miopenConvolutionBwdWeightsAlgoGEMM = 0,

1223 miopenConvolutionBwdWeightsAlgoDirect = 1,

1224 miopenConvolutionBwdWeightsAlgoWinograd = 3,

1225 miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,

1226} miopenConvBwdWeightsAlgorithm_t;

1227

1231typedef 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

1245typedef enum

1246{

1247 miopenConvolutionAlgoGEMM = 0,

1248 miopenConvolutionAlgoDirect = 1,

1249 miopenConvolutionAlgoFFT = 2,

1250 miopenConvolutionAlgoWinograd = 3,

1251 miopenConvolutionAlgoImplicitGEMM = 5,

1252} miopenConvAlgorithm_t;

1253

1260typedef 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;

1273

1274} miopenConvAlgoPerf_t;

1275

1284typedef struct

1285{

1286 float time;

1289 size_t workspace_size;

1291 uint64_t solution_id;

1292 miopenConvAlgorithm_t algorithm;

1293

1294} miopenConvSolution_t;

1295

1311MIOPEN_EXPORT miopenStatus_t

1312miopenConvolutionForwardGetSolutionCount(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

1342MIOPEN_EXPORT miopenStatus_t

1343miopenConvolutionForwardGetSolution(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

1369MIOPEN_EXPORT miopenStatus_t

1370miopenConvolutionForwardGetSolutionWorkspaceSize(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

1395MIOPEN_EXPORT miopenStatus_t

1396miopenConvolutionForwardCompileSolution(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

1420MIOPEN_EXPORT miopenStatus_t

1421miopenConvolutionForwardImmediate(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

1450MIOPEN_EXPORT miopenStatus_t

1451miopenConvolutionBackwardDataGetSolutionCount(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

1482MIOPEN_EXPORT miopenStatus_t

1483miopenConvolutionBackwardDataGetSolution(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

1509MIOPEN_EXPORT miopenStatus_t

1510miopenConvolutionBackwardDataGetSolutionWorkspaceSize(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

1536MIOPEN_EXPORT miopenStatus_t

1537miopenConvolutionBackwardDataCompileSolution(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

1561MIOPEN_EXPORT miopenStatus_t

1562miopenConvolutionBackwardDataImmediate(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

1591MIOPEN_EXPORT miopenStatus_t

1592miopenConvolutionBackwardWeightsGetSolutionCount(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

1622MIOPEN_EXPORT miopenStatus_t

1623miopenConvolutionBackwardWeightsGetSolution(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

1649MIOPEN_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

1675MIOPEN_EXPORT miopenStatus_t

1676miopenConvolutionBackwardWeightsCompileSolution(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

1701MIOPEN_EXPORT miopenStatus_t

1702miopenConvolutionBackwardWeightsImmediate(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

1740MIOPEN_EXPORT miopenStatus_t

1741miopenConvolutionForwardGetWorkSpaceSize(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

1791MIOPEN_EXPORT miopenStatus_t

1792miopenFindConvolutionForwardAlgorithm(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

1841MIOPEN_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

1870MIOPEN_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

1905MIOPEN_EXPORT miopenStatus_t

1906miopenConvolutionBackwardDataGetWorkSpaceSize(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

1956MIOPEN_EXPORT miopenStatus_t

1957miopenFindConvolutionBackwardDataAlgorithm(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

2005MIOPEN_EXPORT miopenStatus_t

2006miopenConvolutionBackwardData(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

2047MIOPEN_EXPORT miopenStatus_t

2048miopenConvolutionBackwardWeightsGetWorkSpaceSize(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

2098MIOPEN_EXPORT miopenStatus_t

2099miopenFindConvolutionBackwardWeightsAlgorithm(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

2147MIOPEN_EXPORT miopenStatus_t

2148miopenConvolutionBackwardWeights(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

2180MIOPEN_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

2196

2202MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);

2203

2212MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2213 miopenIndexType_t index_type);

2214

2222MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2223 miopenIndexType_t* index_type);

2224

2232MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(

2233 miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);

2234

2241MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(

2242 miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);

2243

2258MIOPEN_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

2281MIOPEN_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

2304MIOPEN_EXPORT miopenStatus_t

2305miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2306 const miopenTensorDescriptor_t tensorDesc,

2307 int* n,

2308 int* c,

2309 int* h,

2310 int* w);

2311

2327MIOPEN_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

2350MIOPEN_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

2370MIOPEN_EXPORT miopenStatus_t

2371miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2372 const miopenTensorDescriptor_t tensorDesc,

2373 int dims,

2374 int* tensorDimArr);

2375

2388MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2389 size_t* workSpaceSize);

2390

2403MIOPEN_EXPORT miopenStatus_t

2404miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,

2405 const miopenTensorDescriptor_t yDesc,

2406 size_t* workSpaceSize);

2407

2428MIOPEN_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

2460MIOPEN_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

2479MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);

2480

2482// CLOSEOUT POOLING DOXYGEN GROUP

2483

2484// LRN APIs

2494MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);

2495

2509MIOPEN_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

2528MIOPEN_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

2544MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2545 size_t* workSpaceSize);

2546

2565MIOPEN_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

2593MIOPEN_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

2612MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);

2613

2615// CLOSEOUT LRN DOXYGEN GROUP

2616

2617#ifdef MIOPEN_BETA_API

2618// LayerNorm APIs

2643MIOPEN_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

2677MIOPEN_EXPORT miopenStatus_t

2678miopenGetLayerNormBackwardWorkspaceSize(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

2716MIOPEN_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

2759MIOPEN_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

2776

2793MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,

2794 const miopenTensorDescriptor_t xDesc,

2795 miopenBatchNormMode_t bn_mode);

2796

2835MIOPEN_EXPORT miopenStatus_t

2836miopenBatchNormalizationForwardTraining(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);

2893MIOPEN_EXPORT miopenStatus_t

2894miopenBatchNormalizationForwardTraining_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);

2956MIOPEN_EXPORT miopenStatus_t

2957miopenBatchNormalizationForwardTraining_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);

3020MIOPEN_EXPORT miopenStatus_t

3021miopenBatchNormForwardTrainingActivation(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

3086MIOPEN_EXPORT miopenStatus_t

3087miopenBatchNormForwardTrainingActivation_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

3140MIOPEN_EXPORT miopenStatus_t

3141miopenBatchNormalizationForwardInference(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

3187MIOPEN_EXPORT miopenStatus_t

3188miopenBatchNormalizationForwardInference_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

3234MIOPEN_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

3282MIOPEN_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

3333MIOPEN_EXPORT miopenStatus_t

3334miopenBatchNormForwardInferenceActivation(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

3387MIOPEN_EXPORT miopenStatus_t

3388miopenBatchNormalizationBackward(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

3446MIOPEN_EXPORT miopenStatus_t

3447miopenBatchNormalizationBackward_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

3510MIOPEN_EXPORT miopenStatus_t

3511miopenBatchNormBackwardActivation(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

3548MIOPEN_EXPORT miopenStatus_t

3549miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);

3550

3562MIOPEN_EXPORT miopenStatus_t

3563miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3564 miopenActivationMode_t mode,

3565 double activAlpha,

3566 double activBeta,

3567 double activGamma);

3568

3580MIOPEN_EXPORT miopenStatus_t

3581miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3582 miopenActivationMode_t* mode,

3583 double* activAlpha,

3584 double* activBeta,

3585 double* activGamma);

3586

3599MIOPEN_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

3624MIOPEN_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

3642MIOPEN_EXPORT miopenStatus_t

3643miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);

3644

3646// CLOSEOUT ACTIVATION DOXYGEN GROUP

3647

3648#ifdef MIOPEN_BETA_API

3653

3664MIOPEN_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

3683MIOPEN_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

3714MIOPEN_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

3737MIOPEN_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

3760MIOPEN_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

3785MIOPEN_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

3803MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);

3804MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);

3805MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);

3806

3811

3815typedef enum

3816{

3817 miopenVerticalFusion = 0,

3818 miopenHorizontalFusion = 1,

3819} miopenFusionDirection_t;

3820

3828MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,

3829 const miopenFusionDirection_t fuseDirection,

3830 const miopenTensorDescriptor_t inputDesc);

3831

3837MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);

3838

3845MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,

3846 miopenFusionPlanDescriptor_t fusePlanDesc);

3847

3858MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,

3859 const int op_idx,

3860 miopenFusionOpDescriptor_t* op);

3861

3869MIOPEN_EXPORT miopenStatus_t

3870miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,

3871 miopenFusionPlanDescriptor_t fusePlanDesc,

3872 size_t* workSpaceSize,

3873 miopenConvFwdAlgorithm_t algo);

3874

3892MIOPEN_EXPORT miopenStatus_t

3893miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,

3894 const int requestAlgoCount,

3895 int* returnedAlgoCount,

3896 miopenConvFwdAlgorithm_t* returnedAlgos);

3897

3907MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(

3908 miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);

3909

3918MIOPEN_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 ---

3933MIOPEN_EXPORT miopenStatus_t

3934miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3935 miopenFusionOpDescriptor_t* activFwdOp,

3936 miopenActivationMode_t mode);

3937

3938// Activation backward create ops ---

3946MIOPEN_EXPORT miopenStatus_t

3947miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3948 miopenFusionOpDescriptor_t* activBwdOp,

3949 miopenActivationMode_t mode);

3950

3951// Bias create ops ---

3959MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3960 miopenFusionOpDescriptor_t* biasOp,

3961 const miopenTensorDescriptor_t bDesc);

3962

3963// Batch normalization create ops ---

3972MIOPEN_EXPORT miopenStatus_t

3973miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,

3974 miopenFusionOpDescriptor_t* bnOp,

3975 const miopenBatchNormMode_t bn_mode,

3976 const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);

3977

3987MIOPEN_EXPORT miopenStatus_t

3988miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3989 miopenFusionOpDescriptor_t* bnFwdOp,

3990 const miopenBatchNormMode_t bn_mode,

3991 bool runningMeanVariance);

3992

4000MIOPEN_EXPORT miopenStatus_t

4001miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

4002 miopenFusionOpDescriptor_t* bnBwdOp,

4003 const miopenBatchNormMode_t bn_mode);

4004

4005//---

4011MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);

4012

4018MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);

4019

4020// Convolution set arguments ---

4030MIOPEN_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 ---

4047MIOPEN_EXPORT miopenStatus_t

4048miopenSetOpArgsActivForward(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

4069MIOPEN_EXPORT miopenStatus_t

4070miopenSetOpArgsActivBackward(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 ---

4094MIOPEN_EXPORT miopenStatus_t

4095miopenSetOpArgsBatchNormInference(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

4121MIOPEN_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

4149MIOPEN_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 ---

4171MIOPEN_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

4191MIOPEN_EXPORT miopenStatus_t

4192miopenExecuteFusionPlan(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

4214MIOPEN_EXPORT miopenStatus_t

4215miopenExecuteFusionPlan_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

4247

4248MIOPEN_EXPORT miopenStatus_t

4249miopenConvolutionBiasActivationForward(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

4274

4278typedef enum

4279{

4280 miopenRNNRELU = 0,

4281 miopenRNNTANH = 1,

4282 miopenLSTM = 2,

4283 miopenGRU = 3,

4284} miopenRNNMode_t;

4285

4289typedef enum

4290{

4291 miopenRNNlinear = 0,

4292 miopenRNNskip = 1,

4293} miopenRNNInputMode_t;

4294

4298typedef enum

4299{

4300 miopenRNNdefault = 0,

4302 miopenRNNfundamental = 1,

4304 miopenRNNroundedDynamic = 2,

4306} miopenRNNAlgo_t;

4307

4311typedef enum

4312{

4313 miopenRNNunidirection = 0,

4314 miopenRNNbidirection = 1,

4315} miopenRNNDirectionMode_t;

4316

4320typedef enum

4321{

4322 miopenRNNNoBias = 0,

4323 miopenRNNwithBias = 1,

4324} miopenRNNBiasMode_t;

4325

4329typedef enum

4330{

4331 miopenRNNAlgoGEMM = 0,

4332} miopenRNNGEMMalgoMode_t;

4333

4337typedef enum

4338{

4339 miopenRNNIONotPadded = 0,

4340 miopenRNNIOWithPadding = 1,

4341} miopenRNNPaddingMode_t;

4342

4346typedef enum

4347{

4348 miopenRNNTraining = 0,

4349 miopenRNNInference = 1,

4350} miopenRNNFWDMode_t;

4351

4355typedef enum

4356{

4357 miopenRNNDataUnknownLayout = 0,

4358 miopenRNNDataSeqMajorNotPadded = 1,

4359 miopenRNNDataSeqMajorPadded = 2,

4360 miopenRNNDataBatchMajorPadded = 3,

4361} miopenRNNBaseLayout_t;

4362

4369MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);

4370

4383MIOPEN_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

4408MIOPEN_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

4424MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);

4425

4441MIOPEN_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

4469MIOPEN_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

4494MIOPEN_EXPORT miopenStatus_t

4495miopenSetRNNDataSeqTensorDescriptor(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

4521

4522MIOPEN_EXPORT miopenStatus_t

4523miopenGetRNNDataSeqTensorDescriptor(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

4549MIOPEN_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

4571MIOPEN_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

4593MIOPEN_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

4612MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,

4613 miopenRNNDescriptor_t rnnDesc,

4614 miopenTensorDescriptor_t xDesc,

4615 size_t* numBytes,

4616 miopenDataType_t dtype);

4617

4630MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,

4631 miopenRNNDescriptor_t rnnDesc,

4632 miopenTensorDescriptor_t xDesc,

4633 miopenTensorDescriptor_t wDesc,

4634 miopenDataType_t dtype);

4635

4653MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,

4654 miopenRNNDescriptor_t rnnDesc,

4655 const int seqLen,

4656 miopenTensorDescriptor_t* xDesc,

4657 size_t* numBytes);

4658

4671MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,

4672 miopenRNNDescriptor_t rnnDesc,

4673 const int seqLen,

4674 miopenTensorDescriptor_t* xDesc,

4675 size_t* numBytes);

4676

4717MIOPEN_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

4761MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,

4762 miopenRNNDescriptor_t rnnDesc,

4763 const int layer,

4764 const int biasID,

4765 size_t* numBytes);

4766

4825MIOPEN_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

4892MIOPEN_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

4956MIOPEN_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

5013MIOPEN_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

5072MIOPEN_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

5132MIOPEN_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

5153MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

5154 miopenRNNPaddingMode_t paddingMode);

5155

5162

5163MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

5164 miopenRNNPaddingMode_t* paddingMode);

5165

5216MIOPEN_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

5285MIOPEN_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

5340MIOPEN_EXPORT miopenStatus_t

5341miopenRNNBackwardWeightsSeqTensor(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

5413MIOPEN_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

5507MIOPEN_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

5571MIOPEN_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

5642MIOPEN_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

5669

5673typedef enum

5674{

5675 MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,

5676} miopenCTCLossAlgo_t;

5677

5684MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);

5685

5695MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5696 miopenDataType_t* dataType,

5697 int* blank_label_id,

5698 bool* apply_softmax_layer);

5699

5705MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);

5706

5716MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5717 miopenDataType_t dataType,

5718 const int blank_label_id,

5719 bool apply_softmax_layer);

5720

5737MIOPEN_EXPORT miopenStatus_t

5738miopenGetCTCLossWorkspaceSize(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

5767MIOPEN_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

5789

5793typedef enum

5794{

5795 MIOPEN_RNG_PSEUDO_XORWOW = 0,

5796} miopenRNGType_t;

5797

5803MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);

5804

5810MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);

5811

5820MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,

5821 size_t* reserveSpaceSizeInBytes);

5822

5831MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,

5832 size_t* stateSizeInBytes);

5833

5850MIOPEN_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

5881MIOPEN_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

5910MIOPEN_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

5937MIOPEN_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

5964MIOPEN_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

5982

5988MIOPEN_EXPORT miopenStatus_t

5989miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);

5990

5996MIOPEN_EXPORT miopenStatus_t

5997miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);

5998

6011MIOPEN_EXPORT miopenStatus_t

6012miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,

6013 miopenReduceTensorOp_t reduceTensorOp,

6014 miopenDataType_t reduceTensorCompType,

6015 miopenNanPropagation_t reduceTensorNanOpt,

6016 miopenReduceTensorIndices_t reduceTensorIndices,

6017 miopenIndicesType_t reduceTensorIndicesType);

6018

6034MIOPEN_EXPORT miopenStatus_t

6035miopenGetReduceTensorDescriptor(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

6051MIOPEN_EXPORT miopenStatus_t

6052miopenGetReductionIndicesSize(miopenHandle_t handle,

6053 const miopenReduceTensorDescriptor_t reduceTensorDesc,

6054 const miopenTensorDescriptor_t aDesc,

6055 const miopenTensorDescriptor_t cDesc,

6056 size_t* sizeInBytes);

6057

6067MIOPEN_EXPORT miopenStatus_t

6068miopenGetReductionWorkspaceSize(miopenHandle_t handle,

6069 const miopenReduceTensorDescriptor_t reduceTensorDesc,

6070 const miopenTensorDescriptor_t aDesc,

6071 const miopenTensorDescriptor_t cDesc,

6072 size_t* sizeInBytes);

6073

6097MIOPEN_EXPORT miopenStatus_t

6098miopenReduceTensor(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

6119

6125MIOPEN_DECLARE_OBJECT(miopenProblem);

6126

6130typedef 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

6143typedef 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

6224typedef enum

6225{

6226 miopenFindResultsOrderByTime = 0,

6227 miopenFindResultsOrderByWorkspaceSize = 1,

6228} miopenFindResultsOrder_t;

6229

6237MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,

6238 miopenConvolutionDescriptor_t operatorDesc,

6239 miopenProblemDirection_t direction);

6240

6248

6252typedef enum

6253{

6254 miopenMhaMaskNone = 0,

6255 miopenMhaMaskCausal = 1,

6256} miopenMhaMask_t;

6257

6258MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,

6259 miopenMhaDescriptor_t operatorDesc,

6260 miopenProblemDirection_t direction);

6261

6267

6268MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);

6269

6278

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

6280

6289

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

6291

6297

6298MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);

6299

6311MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,

6312 float alpha,

6313 float beta,

6314 miopenSoftmaxAlgorithm_t algorithm,

6315 miopenSoftmaxMode_t mode);

6316

6328MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,

6329 float* alpha,

6330 float* beta,

6331 miopenSoftmaxAlgorithm_t* algorithm,

6332 miopenSoftmaxMode_t* mode);

6333

6339MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);

6340

6348MIOPEN_EXPORT miopenStatus_t

6349miopenSetProblemTensorDescriptor(miopenProblem_t problem,

6350 miopenTensorArgumentId_t id,

6351 const miopenTensorDescriptor_t descriptor);

6352

6355MIOPEN_DECLARE_OBJECT(miopenFindOptions);

6356

6362MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);

6363

6369MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);

6370

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

6378

6385MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,

6386 miopenFindResultsOrder_t value);

6387

6395MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,

6396 size_t value);

6397

6405MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,

6406 void* buffer,

6407 size_t size);

6408

6417MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,

6418 miopenTensorArgumentId_t id,

6419 void* buffer);

6420

6428MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,

6429 unsigned attach);

6430

6433MIOPEN_DECLARE_OBJECT(miopenSolution);

6434

6446MIOPEN_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

6455struct 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

6483MIOPEN_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

6495MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);

6496

6504MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,

6505 const char* data,

6506 size_t size);

6507

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

6515

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

6523

6530MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,

6531 size_t* workspaceSize);

6532

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

6540

6547MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,

6548 uint64_t* solverId);

6549

6556MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,

6557 miopenConvAlgorithm_t* result);

6558

6559#ifdef MIOPEN_BETA_API

6560

6569MIOPEN_EXPORT miopenStatus_t

6570miopenCreateActivationProblem(miopenProblem_t* problem,

6571 miopenActivationDescriptor_t operatorDesc,

6572 miopenProblemDirection_t direction);

6573

6582MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,

6583 miopenBatchNormMode_t mode,

6584 bool runningMeanVariance,

6585 miopenProblemDirection_t direction);

6586

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

6607

6615MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,

6616 miopenProblemDirection_t direction);

6617

6625

6626MIOPEN_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

6641typedef 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

6653

6657typedef enum

6658{

6659 MIOPEN_REDUCE_CALCULATION_PROD =

6660 1,

6661 MIOPEN_REDUCE_CALCULATION_SUM =

6662 2,

6663} miopenReduceCalculationOp_t;

6664

6674MIOPEN_EXPORT miopenStatus_t

6675miopenGetReduceCalculationWorkspaceSize(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

6695MIOPEN_EXPORT miopenStatus_t

6696miopenReduceCalculationForward(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

6717typedef 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

6734

6749MIOPEN_EXPORT miopenStatus_t

6750miopenReduceExtremeForward(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

6790MIOPEN_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

6839MIOPEN_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

6883MIOPEN_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

6909MIOPEN_EXPORT miopenStatus_t

6910miopenGetT5LayerNormBackwardWorkspaceSize(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

6940MIOPEN_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

6964typedef 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

7122MIOPEN_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

7289MIOPEN_EXPORT miopenStatus_t

7290miopenFusedAdamWithOutput(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

7425MIOPEN_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

7574MIOPEN_EXPORT miopenStatus_t

7575miopenTransformersAdamWWithOutput(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

7627MIOPEN_EXPORT miopenStatus_t

7628miopenGetGetitemWorkspaceSize(miopenHandle_t handle,

7629 uint32_t indexCount,

7630 const miopenTensorDescriptor_t* indexDescs,

7631 size_t* sizeInBytes);

7632

7657MIOPEN_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

7698MIOPEN_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

7721MIOPEN_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

7737

7753MIOPEN_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

7773

7782MIOPEN_EXPORT miopenStatus_t

7783miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,

7784 miopenTensorDescriptor_t inputDesc,

7785 miopenTensorDescriptor_t weightDesc,

7786 size_t* sizeInBytes);

7787

7804MIOPEN_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

7828typedef 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

7841

7854MIOPEN_EXPORT miopenStatus_t

7855miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,

7856 miopenTensorDescriptor_t inputDesc,

7857 miopenTensorDescriptor_t targetDesc,

7858 miopenTensorDescriptor_t outputDesc,

7859 miopenLossReductionMode_t reduction,

7860 size_t* sizeInBytes);

7861

7878MIOPEN_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

7903MIOPEN_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

7924

7943MIOPEN_EXPORT miopenStatus_t

7944miopenGetMultiMarginLossForwardWorkspaceSize(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

7981MIOPEN_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

8011typedef enum

8012{

8013 miopenTuningPolicyNone = 1,

8014 miopenTuningPolicyDbUpdate = 2,

8015 miopenTuningPolicySearch =

8016 3,

8017 miopenTuningPolicySearchDbUpdate = 4,

8018 miopenTuningPolicyDbClean = 5,

8019} miopenTuningPolicy_t;

8020

8029MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,

8030 miopenTuningPolicy_t newValue);

8031

8039MIOPEN_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.

miopenGetErrorString

const char * miopenGetErrorString(miopenStatus_t error)

Get character string for an error code.

miopenCreateWithStream

miopenStatus_t miopenCreateWithStream(miopenHandle_t *handle, miopenAcceleratorQueue_t stream)

Create a MIOpen handle with an accelerator stream.

miopenDestroy

miopenStatus_t miopenDestroy(miopenHandle_t handle)

Destroys the MIOpen handle.

miopenTuningPolicy_t

miopenTuningPolicy_t

Definition miopen.h: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

miopenAllocatorFunction

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

Custom allocator function.

Definition miopen.h:119

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

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